diff --git a/.github/workflows/gameboost-build.yml b/.github/workflows/gameboost-build.yml
new file mode 100644
index 0000000..771ee3f
--- /dev/null
+++ b/.github/workflows/gameboost-build.yml
@@ -0,0 +1,102 @@
+name: build
+
+on:
+  push:
+    branches: [main]
+    paths: ['GameBoost/**', '.github/workflows/build.yml']
+  pull_request:
+    paths: ['GameBoost/**']
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: GameBoost
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '9.0.x'
+
+      - name: Restaurar
+        run: dotnet restore GameBoost.sln
+
+      - name: Compilar
+        run: dotnet build GameBoost.sln -c Release --no-restore -warnaserror
+
+      - name: Testar
+        run: dotnet test GameBoost.sln -c Release --no-build --logger "trx;LogFileName=testes.trx"
+
+      - name: Publicar testes
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: resultado-testes
+          path: GameBoost/**/TestResults/*.trx
+
+      - name: Publicar executavel
+        run: >
+          dotnet publish src/GameBoost.App/GameBoost.App.csproj
+          -c Release -r win-x64 --self-contained
+          -p:PublishSingleFile=true
+          -p:IncludeNativeLibrariesForSelfExtract=true
+          -p:PublishReadyToRun=true
+          -o publish
+
+      # Trimming quebra WPF e reflexao (secao 10 do spec). Falha a build se alguem ligar.
+      - name: Conferir que o trimming segue desligado
+        shell: pwsh
+        run: |
+          $props = Get-Content Directory.Build.props -Raw
+          if ($props -notmatch '<PublishTrimmed>false</PublishTrimmed>') {
+            throw 'PublishTrimmed precisa continuar false: trimming quebra WPF.'
+          }
+
+      - name: Montar o instalador
+        shell: pwsh
+        run: |
+          choco install innosetup --no-progress -y --no-color
+
+          # $env:ProgramFiles(x86) nao e sintaxe valida: o PowerShell le
+          # "$env:ProgramFiles" e deixa "(x86)" solto, virando
+          # "C:\Program Files(x86)". A forma correta e ${env:...}.
+          # O ISCC tambem muda de lugar conforme a instalacao, entao vale
+          # procurar em vez de fixar um caminho.
+          $candidatos = @(
+            "${env:ProgramFiles(x86)}\Inno Setup 6\ISCC.exe",
+            "$env:ProgramFiles\Inno Setup 6\ISCC.exe",
+            "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe"
+          )
+
+          $iscc = $candidatos | Where-Object { Test-Path $_ } | Select-Object -First 1
+          if (-not $iscc) {
+            throw "ISCC.exe nao encontrado. Procurado em: $($candidatos -join '; ')"
+          }
+
+          Write-Host "Usando $iscc"
+          & $iscc installer\GameBoost.iss
+          if ($LASTEXITCODE -ne 0) { throw "ISCC falhou com codigo $LASTEXITCODE" }
+
+      - name: Gerar SHA256SUMS
+        shell: pwsh
+        run: |
+          $arquivos = @(Get-ChildItem publish\GameBoost.exe, installer\Output\*.exe -ErrorAction SilentlyContinue)
+          $arquivos | ForEach-Object {
+            $h = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLower()
+            "$h  $($_.Name)"
+          } | Set-Content SHA256SUMS.txt -Encoding utf8
+          Get-Content SHA256SUMS.txt
+
+      - name: Publicar artefatos
+        uses: actions/upload-artifact@v4
+        with:
+          name: gameboost
+          path: |
+            GameBoost/publish/GameBoost.exe
+            GameBoost/installer/Output/*.exe
+            GameBoost/SHA256SUMS.txt
diff --git a/.github/workflows/gameboost-release.yml b/.github/workflows/gameboost-release.yml
new file mode 100644
index 0000000..9e7d4dd
--- /dev/null
+++ b/.github/workflows/gameboost-release.yml
@@ -0,0 +1,220 @@
+name: release
+
+# Dispara só em tag `gameboost-vX.Y.Z`. O repositório guarda mais de um
+# projeto, então a tag carrega o nome do produto: uma tag `v2.0.0` solta
+# construiria o GameBoost por engano quando outro projeto for versionado.
+on:
+  push:
+    tags: ['gameboost-v*']
+  workflow_dispatch:
+    inputs:
+      versao:
+        description: 'Versão a empacotar (ex.: 2.0.0). Só para teste manual.'
+        required: true
+
+defaults:
+  run:
+    working-directory: GameBoost
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '9.0.x'
+
+      - name: Descobrir a versao
+        id: versao
+        shell: pwsh
+        run: |
+          if ($env:GITHUB_REF -like 'refs/tags/gameboost-v*') {
+            $v = $env:GITHUB_REF -replace '.*/gameboost-v', ''
+          } else {
+            $v = '${{ github.event.inputs.versao }}'
+          }
+
+          if ($v -notmatch '^\d+\.\d+\.\d+$') {
+            throw "Versao invalida: '$v'. Esperado X.Y.Z."
+          }
+
+          # A tag e o Directory.Build.props precisam concordar. Publicar uma
+          # tag 2.1.0 com o assembly dizendo 2.0.0 deixaria o auto-update
+          # comparando numeros que nao batem com o que o usuario tem.
+          $props = Get-Content Directory.Build.props -Raw
+          if ($props -notmatch "<VersionPrefix>$([regex]::Escape($v))</VersionPrefix>") {
+            throw "A tag diz $v mas o Directory.Build.props diz outra coisa. Alinhe os dois."
+          }
+
+          "versao=$v" >> $env:GITHUB_OUTPUT
+          Write-Host "Versao: $v"
+
+      - name: Restaurar
+        run: dotnet restore GameBoost.sln
+
+      - name: Testar
+        run: dotnet test GameBoost.sln -c Release --logger "trx;LogFileName=testes.trx"
+
+      - name: Publicar executavel
+        run: >
+          dotnet publish src/GameBoost.App/GameBoost.App.csproj
+          -c Release -r win-x64 --self-contained
+          -p:PublishSingleFile=true
+          -p:IncludeNativeLibrariesForSelfExtract=true
+          -p:PublishReadyToRun=true
+          -p:Version=${{ steps.versao.outputs.versao }}
+          -o publish
+
+      # ------------------------------------------------------------------
+      # Assinatura de codigo
+      # ------------------------------------------------------------------
+      #
+      # Condicional de proposito. O certificado OV vive num token USB ou HSM
+      # (exigencia das CAs desde jun/2023), entao nem sempre esta disponivel
+      # para o CI. Sem o segredo, a release sai **sem assinatura** e o passo
+      # seguinte avisa em alto e bom som, em vez de falhar a build inteira.
+      #
+      # Ver docs/ASSINATURA.md para o que foi apurado sobre as opcoes.
+      - name: Assinar o executavel
+        if: ${{ secrets.GAMEBOOST_CERT_PFX != '' }}
+        env:
+          CERT_PFX: ${{ secrets.GAMEBOOST_CERT_PFX }}
+          CERT_SENHA: ${{ secrets.GAMEBOOST_CERT_SENHA }}
+        shell: pwsh
+        run: |
+          $pfx = "$env:RUNNER_TEMP\cert.pfx"
+          [IO.File]::WriteAllBytes($pfx, [Convert]::FromBase64String($env:CERT_PFX))
+
+          $signtool = Get-ChildItem "${env:ProgramFiles(x86)}\Windows Kits\10\bin" -Recurse -Filter signtool.exe |
+            Where-Object { $_.FullName -like '*\x64\*' } |
+            Select-Object -First 1 -ExpandProperty FullName
+
+          if (-not $signtool) { throw 'signtool.exe nao encontrado no runner.' }
+
+          & $signtool sign /f $pfx /p $env:CERT_SENHA `
+            /fd SHA256 /tr http://timestamp.sectigo.com /td SHA256 `
+            publish\GameBoost.exe
+
+          if ($LASTEXITCODE -ne 0) { throw "signtool falhou com codigo $LASTEXITCODE" }
+          Remove-Item $pfx -Force
+
+      - name: Avisar que a release sai sem assinatura
+        if: ${{ !secrets.GAMEBOOST_CERT_PFX }}
+        shell: pwsh
+        run: |
+          Write-Host '::warning::Sem certificado configurado: esta release sai SEM assinatura de codigo. O SmartScreen vai avisar no primeiro download. Ver docs/ASSINATURA.md.'
+
+      # ------------------------------------------------------------------
+      # Pacote de atualizacao (Velopack)
+      # ------------------------------------------------------------------
+      - name: Empacotar com o Velopack
+        shell: pwsh
+        run: |
+          dotnet tool install -g vpk
+          $env:PATH = "$env:USERPROFILE\.dotnet\tools;$env:PATH"
+
+          vpk pack `
+            --packId GameBoost `
+            --packVersion ${{ steps.versao.outputs.versao }} `
+            --packDir publish `
+            --mainExe GameBoost.exe `
+            --packTitle GameBoost `
+            --packAuthors "Jonathan Vaz" `
+            --outputDir velopack
+
+          if ($LASTEXITCODE -ne 0) { throw "vpk pack falhou com codigo $LASTEXITCODE" }
+
+      - name: Montar o instalador
+        shell: pwsh
+        run: |
+          choco install innosetup --no-progress -y --no-color
+
+          $candidatos = @(
+            "${env:ProgramFiles(x86)}\Inno Setup 6\ISCC.exe",
+            "$env:ProgramFiles\Inno Setup 6\ISCC.exe",
+            "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe"
+          )
+
+          $iscc = $candidatos | Where-Object { Test-Path $_ } | Select-Object -First 1
+          if (-not $iscc) { throw "ISCC.exe nao encontrado. Procurado em: $($candidatos -join '; ')" }
+
+          & $iscc /DAppVersion=${{ steps.versao.outputs.versao }} installer\GameBoost.iss
+          if ($LASTEXITCODE -ne 0) { throw "ISCC falhou com codigo $LASTEXITCODE" }
+
+      # ------------------------------------------------------------------
+      # Portatil
+      # ------------------------------------------------------------------
+      #
+      # O mesmo exe, mais um portable.txt vazio ao lado. O AppPaths procura
+      # esse arquivo e, achando, guarda tudo em .\data\ em vez de
+      # %LOCALAPPDATA%. Nada muda no codigo.
+      - name: Montar o portatil
+        shell: pwsh
+        run: |
+          $pasta = "portatil\GameBoost-${{ steps.versao.outputs.versao }}-portatil"
+          New-Item -ItemType Directory -Force $pasta | Out-Null
+
+          Copy-Item publish\GameBoost.exe $pasta
+          Copy-Item README.md "$pasta\LEIA-ME.txt"
+
+          @(
+            'Este arquivo faz o GameBoost guardar tudo em .\data\, ao lado do executavel,'
+            'em vez de %LOCALAPPDATA%\GameBoost.'
+            ''
+            'Apague este arquivo para voltar ao comportamento normal.'
+            ''
+            'O modo portatil nao tem atualizacao automatica: baixe a versao nova pela'
+            'pagina de releases quando quiser trocar.'
+          ) | Set-Content "$pasta\portable.txt" -Encoding utf8
+
+          Compress-Archive -Path "$pasta\*" -DestinationPath "portatil\GameBoost-${{ steps.versao.outputs.versao }}-portatil.zip" -Force
+
+      - name: Gerar SHA256SUMS
+        shell: pwsh
+        run: |
+          $arquivos = @(
+            Get-ChildItem publish\GameBoost.exe -ErrorAction SilentlyContinue
+            Get-ChildItem installer\Output\*.exe -ErrorAction SilentlyContinue
+            Get-ChildItem portatil\*.zip -ErrorAction SilentlyContinue
+            Get-ChildItem velopack\*.nupkg, velopack\*.exe -ErrorAction SilentlyContinue
+          )
+
+          if ($arquivos.Count -eq 0) { throw 'Nenhum artefato para somar.' }
+
+          $arquivos | ForEach-Object {
+            $h = (Get-FileHash $_.FullName -Algorithm SHA256).Hash.ToLower()
+            "$h  $($_.Name)"
+          } | Set-Content SHA256SUMS.txt -Encoding utf8
+
+          Get-Content SHA256SUMS.txt
+
+      - name: Anexar tudo ao Release
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: softprops/action-gh-release@v2
+        with:
+          name: GameBoost ${{ steps.versao.outputs.versao }}
+          body_path: GameBoost/installer/NOTAS-DA-RELEASE.md
+          files: |
+            GameBoost/publish/GameBoost.exe
+            GameBoost/installer/Output/*.exe
+            GameBoost/portatil/*.zip
+            GameBoost/velopack/*
+            GameBoost/SHA256SUMS.txt
+
+      - name: Guardar artefatos da execucao manual
+        if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: gameboost-${{ steps.versao.outputs.versao }}
+          path: |
+            GameBoost/publish/GameBoost.exe
+            GameBoost/installer/Output/*.exe
+            GameBoost/portatil/*.zip
+            GameBoost/velopack/*
+            GameBoost/SHA256SUMS.txt
diff --git a/GameBoost/.gitignore b/GameBoost/.gitignore
new file mode 100644
index 0000000..ac42ad8
--- /dev/null
+++ b/GameBoost/.gitignore
@@ -0,0 +1,16 @@
+# Build
+bin/
+obj/
+publish/
+*.user
+*.suo
+.vs/
+
+# Publish e instalador
+installer/Output/
+*.exe
+*.msi
+
+# Dados locais do app em modo portatil
+data/
+*.log
diff --git a/GameBoost/CHANGELOG.md b/GameBoost/CHANGELOG.md
new file mode 100644
index 0000000..ac7d3ab
--- /dev/null
+++ b/GameBoost/CHANGELOG.md
@@ -0,0 +1,510 @@
+# Changelog
+
+Formato baseado em Keep a Changelog. Versionamento semantico.
+
+## [2.0.0] - 2026-09-14
+
+### QA manual, quinta rodada - a deteccao de jogo funcionava, o resto nao (2026-09-14)
+
+Seis correcoes no bloco de perfis. A deteccao em si sempre funcionou — o log registrava
+os tres criterios do spec, com confianca e tela cheia. Tudo o que vinha depois dela
+estava quebrado.
+
+#### Corrigido
+- **O convite era disparado e ninguem escutava.** O shell dispara `AoPedirAviso` e nenhum
+  assinante existia: nem balao, nem faixa. O jogo era detectado, o log registrava, e o
+  usuario nao via nada em lugar nenhum. Agora vai para a bandeja E para uma faixa na
+  janela — com o jogo em tela cheia o Windows engole o balao, e a faixa espera.
+- **Aceitar o convite nao aplicava o perfil.** So navegava para a tela Inicio. Prioridade,
+  afinidade e tweaks ficavam parados no arquivo, e o ProfileRunner nao era chamado por
+  ninguem.
+- **Fechar o jogo nao desfazia nada**, mas o aviso dizia "tudo o que o GameBoost alterou
+  foi desfeito". Afirmar reversao sem reverter e o oposto da regra 1.
+- **O perfil nao casava com o jogo.** O perfil e chaveado pelo executavel
+  ("warframe.x64") e o casamento usava o nome da pasta ("Warframe"). A linha aparecia
+  duas vezes: uma dizendo que tem perfil e outra que nao tem. Agora casa pela pasta de
+  instalacao, que os dois tem em comum.
+- **Falso positivo na deteccao: o Agent do Battle.net.** Ele mora em
+  `ProgramData\Battle.net\Agent`, que bate com a lista de pastas de launcher, e engorda
+  enquanto baixa atualizacao — passou do limite de memoria e foi anunciado como jogo numa
+  sessao real. Nome que descreve funcao ("agent", "launcher", "updater", "helper") dentro
+  de pasta de launcher e infraestrutura, nunca jogo.
+- **"Nao havia perfil aplicado" quando havia.** Quando o jogo fecha antes do Desfazer, nao
+  sobra prioridade para restaurar — ela morre com o processo. O texto negava que houvesse
+  perfil em vez de explicar isso.
+- O contador do cabecalho da pagina Jogos nao acompanhava criar e remover perfil.
+
+#### Adicionado
+- Teste que prova que maquinaria de launcher nunca e jogo, com 2 GB de RAM para garantir
+  que o filtro de nome vale mesmo com o processo gordo — e que um jogo de verdade na mesma
+  pasta continua sendo detectado.
+
+### QA manual, quarta rodada - o Reverter da inicializacao nao revertia (2026-09-14)
+
+#### Corrigido
+- **Reverter da Inicializacao devolvia sucesso sem fazer nada.** A tela passa GUIDs de
+  ChangeRecord, mas o modulo esperava NOMES de programa e tentava casar com
+  `id.Contains(e.Nome)`. Um GUID nunca contem "WallpaperEngine": a lista de alvos saia
+  vazia, nada era desfeito e o metodo retornava sucesso. A tela dizia "Pronto" e o item
+  continuava desativado.
+
+  Alem de errado, aquilo dependia de alguem ter varrido na mesma sessao: reabrir o app e
+  clicar em Reverter nao funcionaria nem com o casamento certo. Agora usa o
+  RollbackEngine, que le o proprio ChangeRecord — mesmo caminho dos Tweaks.
+
+#### Adicionado
+- Teste do ciclo completo da inicializacao, com uma entrada descartavel criada so para
+  ele: desativa, confere os 12 bytes com o primeiro em 0x03, reativa e confere que voltou.
+
+#### Notas
+- Reativar pode apagar o valor em vez de gravar 0x02, e as duas formas valem: no
+  StartupApproved a ausencia significa habilitado. Apagar e mais limpo, porque nao deixa
+  residuo de uma chave que nao existia antes.
+
+### QA manual, terceira rodada - a Lixeira derrubava o aplicativo (2026-09-14)
+
+#### Corrigido
+- **`Pack = 1` na struct do SHFileOperation derrubava o processo.** Em x64 o `Pack = 1`
+  tira o preenchimento entre os campos, e o ponteiro `pFrom` sai no deslocamento 12 em vez
+  de 16. O shell32 continua lendo do 16, pega metade de um ponteiro colada na metade de
+  outro e usa aquilo como endereco: violacao de acesso (0xc0000005), processo morto sem
+  excecao gerenciada, sem log e sem caixa de erro.
+
+  **A Lixeira nunca funcionou em lugar nenhum.** Limpeza, Espaco e Restos usam a mesma
+  funcao. Era o item que estava marcado como nao testado no docs/QA.md desde a Fase 2, e o
+  que ele escondia era um crash garantido em toda tentativa.
+
+#### Adicionado
+- Teste que manda um arquivo de verdade para a Lixeira e confere que ele saiu da origem.
+  Marshalling errado nao quebra a compilacao: so uma chamada real pega.
+
+### QA manual, segunda rodada - medicao de velocidade e quatro correcoes (2026-09-14)
+
+Achados nos blocos de tweaks e de rede do docs/QA.md.
+
+#### Corrigido
+- **O teste de velocidade media a rajada, nao a linha.** Ele transferia 25 MB e
+  cronometrava. Numa fibra domestica a operadora deixa passar bem acima do contratado por
+  um ou dois segundos, e uma transferencia que termina em 0,6 s mede so isso. Com 8, 25 e
+  50 MB o upload saiu 131, 354 e 275 Mbps — tres numeros que nao se parecem, na mesma
+  linha e no mesmo minuto. Agora mede por **tempo** (8 s por amostra), descartando os 2
+  primeiros segundos, onde moram a rajada e o slow start do TCP. O erro caiu de +44% para
+  -15% contra um teste dedicado, e 15% abaixo e o resultado certo para um teste de um
+  servidor so e uma conexao so.
+- **A lista nao atualizava depois de agir.** O badge de um servico continuava dizendo
+  "automatico" depois de ele ja ter virado "manual": a tela parecia nao ter feito nada.
+  Onde a varredura e barata (Tweaks), ela refaz sozinha; onde e cara (Apps), a tela avisa
+  que a lista mostra o estado de antes.
+- **Markdown cru aparecia na tela.** Textos escritos com `**negrito**` mostravam os
+  asteriscos, porque o WPF nao renderiza markdown. A enfase passou a vir da estrutura da
+  frase.
+- **Glifos de icone se perdiam.** Os icones do menu sao caracteres da area de uso privado
+  do Unicode, e todo reescrita do arquivo por outra ferramenta os apagava. Agora estao em
+  escape `\uXXXX`, que e ASCII puro.
+
+#### Notas
+- O teste de velocidade ganhou um teto de 120 MB por amostra, para nao comer a franquia de
+  quem tem limite.
+- Um teste de velocidade dedicado tambem erra quando o servidor escolhido esta
+  congestionado: na mesma maquina e no mesmo minuto, um servidor deu 73 Mbps de upload e
+  outro deu 264. A tela agora diz que o numero sai 10% a 15% abaixo e por que.
+
+### QA manual, primeira rodada - seis correcoes (2026-09-14)
+
+Achados rodando o app elevado na maquina real, no bloco de reversibilidade do
+docs/QA.md. Dois deles apareciam em toda sessao.
+
+#### Corrigido
+- **Sessao nunca era encerrada.** O botao "Restaurar agora" revertia tudo e limpava a tela,
+  mas nao marcava o session.json como encerrado. O aviso "foi fechado com o Modo Game ainda
+  ativo" voltava em TODA abertura, mesmo com zero pendencias. Um aviso que aparece sempre
+  deixa de ser aviso.
+- **Excecao em toda saida.** `GameWatcher.Dispose()` era chamado pelo App e de novo pelo
+  container de DI, que descarta todo singleton IDisposable. Na segunda chamada o `Cancel()`
+  caia num CancellationTokenSource ja descartado, e a excecao escapava para a caixa de erro
+  porque o `ServiceProvider.Dispose()` estava fora do try. Dispose agora e idempotente.
+- **Lista de restauracao nao existia.** O rodape anunciava "N aguardando na lista de
+  restauracao" e nao havia lista nenhuma. Agora ha o bloco "Aguardando para reabrir", com
+  botao por app e a explicacao de por que ele nao voltou sozinho.
+- **O contador contradizia a acao.** O resumo dizia "38 apps marcados" com um unico item
+  marcado, porque era o texto da varredura e nao acompanhava a selecao. Agora ha contagem
+  viva ao lado, e o resumo da varredura fica em segundo plano.
+
+#### Adicionado
+- **Busca em toda pagina de modulo.** Entrou na classe base, entao vale para Inicio, Apps,
+  Limpeza, Tweaks e todas as outras. Ignora acento e caixa: quem digita "gravacao" acha
+  "Gravação". Filtrar **nao** desmarca nada — a contagem continua sobre a lista inteira.
+- **Marcar todos e Limpar na tela Inicio**, que era a unica pagina sem eles.
+
+### Fase 7 - Distribuicao: auto-update, CI de release, portatil e assinatura (2026-09-14)
+
+#### Adicionado
+- Auto-update com Velopack apontando para as releases do GitHub. Checagem silenciosa na
+  abertura, download em segundo plano, e a troca de versao so no proximo inicio ou quando
+  o usuario mandar.
+- `VelopackApp.Build().Run()` como primeira linha do Main, antes de ler argumentos: o
+  Velopack roda o proprio exe para instalar e atualizar, e essa chamada precisa
+  interceptar.
+- Secao "Versao do GameBoost" em Configuracoes: versao atual, botao Verificar e, quando
+  ha download pronto, "Instalar e reiniciar".
+- Workflow `gameboost-release.yml`: dispara em tag `gameboost-v*`, confere que a tag bate
+  com o Directory.Build.props, testa, publica, assina (quando ha certificado), empacota
+  com o Velopack, monta o instalador e o portatil, gera SHA256SUMS e anexa tudo a release.
+- Passo de assinatura condicional. Sem o segredo, a release sai sem assinatura e o CI
+  emite um aviso visivel, em vez de falhar a build inteira.
+- Portatil montado no CI: o mesmo exe, mais um `portable.txt` explicando o que ele faz.
+- Instalador com escolha entre instalar para todos os usuarios ou so para o atual. A
+  chave de autostart passou de HKCU para HKA, que resolve para a raiz certa nos dois casos.
+- `docs/ASSINATURA.md`: o que foi apurado sobre certificado (o Brasil esta fora do Azure
+  Artifact Signing, EV nao pula mais o SmartScreen desde 2024, OV e o caminho viavel) e
+  como submeter falso positivo.
+- `installer/NOTAS-DA-RELEASE.md`: o que baixar, e como conferir o SHA256 quando o
+  SmartScreen avisar.
+
+#### Corrigido
+- A here-string do PowerShell (`@'...'@`) exige o terminador na coluna 0, e isso quebrava
+  o bloco YAML do workflow, que precisa de todo conteudo indentado. Trocada por array de
+  strings.
+- O `.iss` tinha `#define AppVersion` fixo, entao o `/DAppVersion` do CI seria ignorado.
+  Agora e `#ifndef`.
+- O `UseWindowsForms` da Fase 6 ligou os analisadores do WinForms, e o WFO0003 manda tirar
+  a configuracao de DPI do manifesto — regra que nao se aplica a um app WPF. Com o
+  `-warnaserror` do CI, isso quebraria a build de Release inteira. Suprimido com o motivo
+  escrito no csproj.
+
+#### Notas
+- Modo portatil nao tem auto-update, e a tela diz isso: o Velopack atualiza uma instalacao
+  que ele mesmo montou, e um exe solto numa pasta nao tem o que atualizar.
+- O teste do modo portatil nao pode exigir que o caminho fique fora de `%LOCALAPPDATA%`:
+  a pasta temporaria do Windows mora dentro dele. A invariante testada e nao cair na pasta
+  padrao do app.
+
+### Fase 7 - Distribuicao: auto-update, CI de release, portatil e assinatura (2026-09-14)
+
+#### Adicionado
+- Auto-update com Velopack apontando para as releases do GitHub. Checagem silenciosa na
+  abertura, download em segundo plano, e a troca de versao so no proximo inicio ou quando
+  o usuario mandar.
+- `VelopackApp.Build().Run()` como primeira linha do Main, antes de ler argumentos: o
+  Velopack roda o proprio exe para instalar e atualizar, e essa chamada precisa
+  interceptar.
+- Secao "Versao do GameBoost" em Configuracoes: versao atual, botao Verificar e, quando
+  ha download pronto, "Instalar e reiniciar".
+- Workflow `gameboost-release.yml`: dispara em tag `gameboost-v*`, confere que a tag bate
+  com o Directory.Build.props, testa, publica, assina (quando ha certificado), empacota
+  com o Velopack, monta o instalador e o portatil, gera SHA256SUMS e anexa tudo a release.
+- Passo de assinatura condicional. Sem o segredo, a release sai sem assinatura e o CI
+  emite um aviso visivel, em vez de falhar a build inteira.
+- Portatil montado no CI: o mesmo exe, mais um `portable.txt` explicando o que ele faz.
+- Instalador com escolha entre instalar para todos os usuarios ou so para o atual. A
+  chave de autostart passou de HKCU para HKA, que resolve para a raiz certa nos dois casos.
+- `docs/ASSINATURA.md`: o que foi apurado sobre certificado (o Brasil esta fora do Azure
+  Artifact Signing, EV nao pula mais o SmartScreen desde 2024, OV e o caminho viavel) e
+  como submeter falso positivo.
+- `installer/NOTAS-DA-RELEASE.md`: o que baixar, e como conferir o SHA256 quando o
+  SmartScreen avisar.
+
+#### Corrigido
+- A here-string do PowerShell (`@'...'@`) exige o terminador na coluna 0, e isso quebrava
+  o bloco YAML do workflow, que precisa de todo conteudo indentado. Trocada por array de
+  strings.
+- O `.iss` tinha `#define AppVersion` fixo, entao o `/DAppVersion` do CI seria ignorado.
+  Agora e `#ifndef`.
+
+#### Notas
+- Modo portatil nao tem auto-update, e a tela diz isso: o Velopack atualiza uma instalacao
+  que ele mesmo montou, e um exe solto numa pasta nao tem o que atualizar.
+- O teste do modo portatil nao pode exigir que o caminho fique fora de `%LOCALAPPDATA%`:
+  a pasta temporaria do Windows mora dentro dele. A invariante testada e nao cair na pasta
+  padrao do app.
+
+### Fase 6 - Perfis por jogo, bandeja e onboarding (2026-09-14)
+
+#### Adicionado
+- Perfis por jogo (secao 5.11): um arquivo por jogo em `profiles/*.json`. Um perfil diz o
+  que fazer quando o jogo abre e o que desfazer quando ele fecha; a reversao nao e
+  opcional nem configuravel.
+- Deteccao automatica de jogo (secao 5.1): vigia os processos a cada 2 s numa thread de
+  prioridade baixa, cruzando nome conhecido, pasta de launcher e janela em tela cheia.
+- Perfil novo **nunca** ativa sozinho. O convite aparece, e so quem marcar "ativa sozinho"
+  passa a ter o perfil aplicado sem perguntar (regra 3).
+- Afinidade de CPU por perfil, desligada por padrao, recusando indice de nucleo que nao
+  existe na maquina atual.
+- Resolucao de timer em 0,5 ms por perfil, desligada por padrao e com o texto dizendo que
+  vale menos do que a internet promete.
+- Pagina Jogos: biblioteca dos launchers cruzada com os perfis. Medido: 14 jogos,
+  974,2 GB.
+- Icone na bandeja com o menu da secao 6 (Ativar Modo Game, Limpar RAM, Abrir, Sair).
+  Fechar a janela esconde na bandeja, com aviso na primeira vez; "Sair" sai de verdade.
+- "Limpar RAM" como acao propria, com ganho medido antes e depois. Quando nao ha o que
+  liberar, o texto diz isso em vez de inventar um numero.
+- Onboarding de tres telas na primeira abertura: reversivel, sem telemetria, e o que faz
+  diferenca de verdade. Nao vende FPS.
+- Dois interruptores novos em Configuracoes: icone na bandeja e deteccao automatica.
+
+#### Corrigido
+- `UseWindowsForms` (necessario para o NotifyIcon) injeta using global de
+  `System.Windows.Forms` e `System.Drawing` em todo arquivo, tornando `Control`,
+  `Application`, `Brush` e `MouseEventArgs` ambiguos com os tipos do WPF na aplicacao
+  inteira. Os usings implicitos foram removidos no csproj.
+- O texto de estado vazio da pagina Jogos aparecia por cima da lista cheia: a
+  visibilidade dependia do Resumo, que nunca fica vazio.
+
+#### Notas
+- A deteccao e por polling, nao por `Win32_ProcessStartTrace`. WMI em laco foi o que
+  estourou o orcamento de CPU na Fase 1; 2 segundos de atraso nao importam para algo que
+  o usuario vai confirmar num dialogo.
+- Sair do app desfaz o perfil aplicado antes de encerrar. Sem isso, prioridade e tweaks
+  ficariam de pe depois que o processo sumiu.
+
+### Complemento da Fase 4 - aba Atualizacoes (winget) e aba Restos na tela (2026-09-14)
+
+Entrega retroativa: a secao 5.3 ganhou a aba de atualizacoes depois que a Fase 4 ja
+estava commitada. Vem em commit proprio para o historico nao mentir sobre o que cada
+fase entregou.
+
+#### Adicionado
+- Aba "Atualizacoes" em cima do winget: lista o que tem versao nova, classificado e
+  agrupado. Medido: 35 atualizacoes, 4 de seguranca, 7 que se atualizam sozinhos.
+- Classificacao por id: driver (bloqueado, o GameBoost nao instala driver), runtime,
+  "atualiza sozinho" e "o winget nao sabe a versao instalada". Cada grupo tras o texto
+  que explica por que tratar diferente.
+- Apps que abrem arquivo vindo da internet (navegador, compactador, leitor de PDF, Java)
+  sao marcados como atualizacao de seguranca: neles ficar desatualizado nao e conforto.
+- App aberto e detectado e a linha avisa "feche antes".
+- Atualizacao uma a uma, com progresso por item. `winget upgrade --all` seria mais curto
+  e perderia o que importa: com `--all` um app que falha some no meio da saida.
+- Codigos de saida do winget viram frase em portugues; o caminho do log detalhado aparece
+  quando algo falha. Historico em updates-history.json.
+- Quando o winget nao existe, a aba explica o que ele e e abre a pagina do App Installer
+  na Microsoft Store.
+- Aba "Restos de apps antigos" **na interface**. A varredura existia no Core desde a Fase
+  4, mas nunca tinha sido ligada a uma tela.
+- Pagina de Apps reorganizada em tres abas, cada uma com o seu proprio botao de acao.
+
+#### Corrigido
+- O template de TabControl escrito para o tema escuro quebrava a arvore de automacao:
+  nenhum controle dentro das abas era exposto. Leitor de tela nao alcancaria nada, e a
+  navegacao por teclado perdia o destino. Faltava o `ContentPresenter` chamado
+  `PART_SelectedContentHost`, que e o nome que o `TabControlAutomationPeer` procura.
+- O casamento de id do winget era por prefixo cru, entao "Google.Chrome" pegava
+  "Google.ChromeRemoteDesktopHost": o host de acesso remoto aparecia como navegador e
+  como atualizacao de seguranca. Agora exige fronteira de ponto.
+- As abas do TabControl saiam ilegiveis: o estilo padrao do WPF usa fundo claro e texto
+  escuro, que sobre a superficie escura do GameBoost fica branco no branco.
+
+#### Notas
+- A saida do `winget upgrade` nao tem formato estruturado: nem JSON, nem XML. E uma
+  tabela de largura fixa com cabecalho traduzido. A leitura e por **posicao de coluna**,
+  calculada a partir do cabecalho, o que funciona em qualquer idioma.
+- Nada e pre-marcado, nem a atualizacao de seguranca: instalar versao nova pode quebrar
+  o que funcionava, e a escolha e de quem usa a maquina.
+
+### Fase 5 - Tweaks, servicos, rede com NAT e drivers (2026-09-14)
+
+#### Adicionado
+- Pagina Tweaks (secoes 5.8 e 5.7): 12 ajustes do catalogo e 12 servicos do Windows na
+  mesma lista, agrupados por categoria. Cada ajuste tras o efeito real, a evidencia, o
+  risco e como desfazer. Medido: 24 itens, 1 ja ativo na maquina de teste.
+- Nada e pre-marcado, nem o que o proprio GameBoost recomenda: o selo "recomendado"
+  aparece no texto e a caixa continua vazia (regra 3).
+- Isolamento de nucleo (VBS) aparece so de leitura, com o custo declarado (5% a 15%
+  segundo testes publicos) e o botao que abre a tela da Microsoft. Mitigacoes de
+  Spectre/Meltdown nao entram nem como item bloqueado.
+- SysMain, servicos do Xbox e Windows Update aparecem bloqueados **para explicar por que
+  nao mexer**: a informacao de que nao se deve desligar vale tanto quanto a sugestao de
+  desligar.
+- Pagina Rede (secao 5.9) em tres blocos: "Posso jogar online?" com semaforo, "Velocidade"
+  e as tabelas de latencia, DNS e conexoes.
+- Cliente STUN proprio (RFC 5389) com dois servidores por duas portas locais. Classifica o
+  NAT no vocabulario dos jogos: aberto, moderado, estrito. Medido na maquina real: aberto.
+- Deteccao das causas: CGNAT pela faixa 100.64.0.0/10, NAT duplo por saltos privados no
+  traceroute, UPnP por SSDP, Teredo pelo registro e perfis do firewall.
+- Teste de velocidade com 3 amostras e mediana, opt-in: gasta cerca de 100 MB, entao
+  depende de permissao explicita em Configuracoes, desligada por padrao.
+- Reativacao do Teredo, reversivel, com ChangeRecord por chave. E a correcao do caso mais
+  comum de "Game Pass nao conecta": alguem desativou seguindo tutorial de otimizacao.
+- Troca de DNS por adaptador, reversivel inclusive para "automatico (DHCP)", e reset de
+  Winsock com risco Alto e o aviso de que nao tem desfazer.
+- Comparacao de DNS por consulta UDP montada a mao, porque `Dns.GetHostEntry` perguntaria
+  sempre ao resolvedor do sistema.
+- Leitura do driver de video (secao 5.10) pelo registro, com traducao da versao da NVIDIA
+  para a de marketing (32.0.16.1664 vira 616.64) e a idade em meses.
+- `docs/PORTAS.md`: portas por launcher e por jogo, o que fazer em CGNAT e em NAT duplo, e
+  onde fica UPnP em sete marcas de roteador.
+
+#### Corrigido
+- O badge "Protegido" aparecia em ajuste que so precisava de elevacao. Sao coisas
+  diferentes: protegido e o GameBoost se recusando a mexer; precisar de admin some ao
+  reabrir elevado. `ActionItem` ganhou `RotuloBloqueio`.
+- A leitura da hibernacao procurava `C:\hiberfil.sys`, e `File.Exists` devolve **false**
+  para aquele arquivo mesmo com a hibernacao ligada: a ACL barra a consulta sem elevacao.
+  O app diria "ja desligada" para todo mundo que abrisse sem ser administrador. Agora le o
+  registro.
+- O driver de video listava o adaptador virtual do Hyper-V, carimbado com 21/06/2006, e a
+  tela anunciaria "seu driver tem 242 meses" numa maquina com driver do mes passado.
+- A lista de quem usa a rede repetia o mesmo nome varias vezes, uma por PID. Agora agrupa
+  por nome e diz quantos processos sao.
+- A barra de status da pagina Rede repetia a explicacao do NAT que ja tem bloco proprio, e
+  saia cortada no meio da frase.
+
+#### Notas
+- O spec foi substituido no meio desta fase. Os conflitos entre o que ja estava escrito e o
+  texto novo estao listados em docs/DECISOES.md, com o que foi corrigido e o que ficou
+  pendente.
+- A aba "Atualizacoes" via winget (secao 5.3) e da Fase 4, que ja foi entregue. Entra como
+  complemento retroativo depois desta fase, com commit proprio.
+- Banda por processo nao e possivel como o spec descreve: `GetExtendedTcpTable` devolve
+  conexoes com o PID dono, nao contadores de trafego. A tela mostra conexoes e diz isso.
+
+### Fase 4 - Desinstalador e gerenciador de inicializacao (2026-09-14)
+
+#### Adicionado
+- Inventario de aplicativos (secao 5.3) lendo registro (32 e 64 bits, maquina e usuario),
+  Microsoft Store e UserAssist. Medido: 217 apps, 113 da Store, 78 protegidos.
+- Desinstalacao em lote, sempre pelo desinstalador do proprio app: QuietUninstallString,
+  depois `msiexec /x {GUID} /qn`, depois `Remove-AppxPackage`, e por ultimo o desinstalador
+  com janela. Limite de 10 minutos por app. Saidas 0, 3010 e 1605 contam como sucesso.
+- Varredura de restos depois de cada desinstalacao, com remocao para a Lixeira.
+- Aba "Restos de apps antigos": varre %APPDATA%, %LOCALAPPDATA% e %PROGRAMDATA% e lista
+  pastas sem app correspondente, com tamanho e data. Medido: 30 pastas, 3,9 GB.
+- Gerenciador de inicializacao (secao 5.6): chaves Run, pastas Inicializar e o estado do
+  StartupApproved. Desativar grava o mesmo formato de 12 bytes do Gerenciador de Tarefas,
+  com ChangeRecord antes de cada escrita. Medido: 26 entradas, 4 bloqueadas, 8 sugeridas.
+- Verificacao de assinatura Authenticode com WinVerifyTrust, para mostrar o fabricante.
+
+#### Corrigido
+- O resumo dos apps anunciava 1812,4 GB numa maquina com 953 GB. Eram duas contas erradas:
+  app que declara InstallLocation generica (media a pasta inteira) e varios apps declarando
+  a MESMA pasta, contada uma vez por app. Agora sao 1044 GB para 2145 GB de disco.
+- A lista vinha ordenada pelo tamanho DECLARADO no registro, medido so depois: o ARK, com
+  309 GB reais, aparecia atras do AutoCAD, que declara 4 GB.
+- App da Store cujo executavel mora em WindowsApps era acusado de "sem assinatura digital".
+  A ACL de la barra ate o administrador; nao dava para verificar, e agora o texto diz isso.
+- O impacto no boot aparecia duas vezes na mesma linha.
+- `WinVerifyTrust` rodava duas vezes por entrada de inicializacao.
+
+#### Notas
+- Desinstalacao nao tem desfazer automatico, e a tela diz isso antes de confirmar.
+- `Get-AppxPackage` so funciona com `-EncodedCommand` e com as duas saidas lidas: com
+  `-Command` o PowerShell reinterpreta pipes, e sem ler o stderr o buffer de progresso
+  CLIXML enche e o processo trava. Ver docs/DECISOES.md.
+- Nada e pre-marcado nesta fase, em nenhuma das tres listas (regra 3).
+
+### Fase 3 - Analisador de espaco e biblioteca de jogos (2026-09-14)
+
+#### Adicionado
+- Varredura de volume com FindFirstFileEx e FIND_FIRST_EX_LARGE_FETCH, paralelizada por
+  subarvore. Medido: 1.548.745 arquivos e 809,5 GB em 20,3 s, acima do volume do criterio
+  da secao 5.4 e abaixo do tempo.
+- Treemap navegavel com algoritmo squarified, colorido por categoria, com clique para
+  descer e trilha para voltar.
+- Top 100 arquivos e top 50 pastas, com abrir no Explorer e enviar para a Lixeira.
+- Categorias inteligentes: jogos, videos, imagens, instaladores, caches, sistema,
+  documentos, codigo e musica. A pasta manda mais que a extensao.
+- Arquivos especiais (hiberfil.sys, pagefile.sys, Windows.old) explicados em vez de so
+  listados, com o risco de cada um.
+- Biblioteca de jogos (secao 5.11) lendo Steam, Epic, GOG e Xbox, com tamanho e quando foi
+  jogado pela ultima vez. Jogo grande e parado ha mais de 6 meses ganha selo.
+
+#### Notas
+- A MFT crua nao foi usada: FSCTL_ENUM_USN_DATA nao devolve o tamanho do arquivo. Ver
+  docs/DECISOES.md.
+- O contador de pastas inacessiveis reportava 40.871; o numero real e 543.
+- A arvore consumia 1,1 GB de RAM por guardar o caminho completo em cada no; agora sao
+  594 MB.
+
+### Fase 2 - Limpeza e ferramentas rapidas (2026-09-13)
+
+#### Adicionado
+- Modulo Cleaner (secao 5.2): 20 alvos de limpeza, do %TEMP% ao shader cache, com
+  pagina no shell e o comando `--clean --preset seguro|completo`.
+- Whitelist de leitura separada da de remocao: a varredura pode olhar Downloads para
+  dizer quanto ha de instalador velho, sem nunca ganhar permissao de apagar de la.
+- Remocao de conteudo do usuario sempre pela Lixeira (SHFileOperation com FOF_ALLOWUNDO).
+- Historico de limpeza em cleanup-history.json.
+- Ferramentas rapidas (secao 5.13): reiniciar Explorer e driver de video, limpar cache
+  de DNS, esvaziar Lixeira, abrir Limpeza de Disco, criar ponto de restauracao, sfc e
+  DISM com saida ao vivo, teste de velocidade de disco e informacoes do sistema.
+
+#### Notas
+- Cada alvo de limpeza diz o efeito colateral antes: shader cache avisa do engasgo,
+  prefetch avisa que raramente compensa. Ha teste exigindo advertencia em todo alvo de
+  risco medio ou alto.
+- RevertAsync do Cleaner diz que nao ha reversao automatica, em vez de fingir que desfaz.
+- `ipconfig /flushdns` virou DnsFlushResolverCache, e Checkpoint-Computer virou WMI
+  SystemRestore: regra 9, sem chamar executavel quando ha API.
+- A pagina de Limpeza nao tem XAML proprio: herda a tela inteira do ModulePageViewModel.
+
+### Shell de navegacao (2026-09-13)
+
+- Menu lateral com as 11 entradas da secao 6, tema escuro mantido.
+- ModulePageViewModel: padrao de pagina de modulo reutilizavel, com cabecalho e Varrer,
+  lista generica de ActionItem, rodape com "Aplicar N selecionados" e "Reverter".
+- Paginas dos modulos ainda nao implementados explicam o que farao e em qual fase chegam.
+- Configuracoes com abas Preferencias e Historico, lendo o state-backup.
+
+### Fase 1 - Diagnostico de gargalos e relatorio de saude (2026-09-13)
+
+#### Adicionado
+- Modulo Bottleneck (secao 5.5): coleta a cada 1 s com buffer de 5 minutos, medindo CPU,
+  memoria, Standby List, GPU, disco, rede e temperatura.
+- 17 regras de diagnostico como classes IFindingRule testaveis, cada uma escrevendo em
+  linguagem humana: "Chrome esta usando 38% da CPU", nao "cpu_threshold_exceeded".
+- Deteccao de reset por atualizacao do Windows: guarda a build e avisa quando um update
+  desfez os ajustes. Nenhum concorrente faz isso.
+- FindingEngine com debounce de 30 s, entao a lista nao pisca a cada segundo.
+- Pagina Diagnostico: cinco medidores ao vivo com grafico de 60 s, top 10 processos e a
+  lista de achados com botao de acao.
+- Modulo HealthReport (secao 5.12): nota 0 a 100 por area com os 5 principais achados,
+  exportavel em HTML (arquivo unico, sem link externo) e JSON.
+- Pagina Inicio mostra a nota de saude e exporta o relatorio.
+- `GameBoost.exe --report saida.html` na CLI, com versao texto e `--json`.
+
+#### Desempenho
+- Custo da coleta: **0,115% de CPU, ciclo de 36 ms**, contra o limite de 1,5% da secao 5.5.
+  A primeira versao media 5,02% com ciclo de 1039 ms. Ver docs/DECISOES.md.
+
+#### Notas
+- Nada de PerformanceCounter por nome: num Windows pt-BR os contadores do spec nao existem
+  com aquele nome. Onde ha API nativa, usa-se API nativa.
+- Temperaturas ficam "indisponivel" nesta fase: a leitura boa exige driver de sensores.
+  Nunca aparece zero no lugar.
+
+### Fase 0 - Fundacao (2026-09-13)
+
+#### Adicionado
+- Solucao dividida em `GameBoost.Core` (sem WPF, testavel), `GameBoost.App` (WPF),
+  `GameBoost.Cli` (parser e runner) e `GameBoost.Tests` (xUnit + NSubstitute).
+- `SafetyGuard`: blindagem central consultada por todos os modulos. Listas de processos
+  criticos, anti-cheats, antivirus (WMI + estatica), caminhos e servicos protegidos.
+- `RollbackEngine` e `StateBackup`: toda alteracao de sistema grava o valor anterior antes
+  de ser aplicada e tem reversao testada. Reversao em ordem inversa; falha em um item nao
+  interrompe os demais.
+- `IGameBoostLogger` com log estruturado e rotacao (5 MB x 5 arquivos).
+- `AppSettings` com `schemaVersion` e migradores em sequencia; arquivo antigo vira `.bak`.
+- Modo portatil: `portable.txt` ao lado do exe move os dados para `.\data\`.
+- Contrato `IModule` / `ActionItem` e tela generica de lista com checkbox, badge de risco e
+  botao "?" com o que faz, qual o risco e como desfazer.
+- Modo Game portado para o contrato: varredura com blindagem, encerramento gracioso com
+  fallback forcado, limpeza de RAM (`EmptyWorkingSet` + purga da Standby List), plano de
+  energia, prioridade do jogo, silenciamento do sistema e pausa do Windows Update.
+- Deteccao de jogo por nome conhecido, pasta de launcher e heuristica de consumo.
+- CLI com a superficie da secao 8 do spec; `--scan` preserva o comportamento da v1.
+- `--dry-run` funcional em todos os caminhos: mesmo relatorio, zero escrita.
+- Modo somente leitura quando o app roda sem privilegios de administrador.
+- Aviso na abertura quando o app foi fechado com o Modo Game ativo.
+- CI no GitHub Actions: build, testes, publish e instalador.
+- Documentacao: `CLAUDE.md`, `docs/PROTECAO.md`, `docs/TWEAKS.md`, `docs/DECISOES.md`,
+  `docs/QA.md`.
+
+#### Notas
+- A v1.0.0 foi reconstruida a partir do `LEIA-ME.txt` porque o codigo-fonte original nao
+  existia mais. Ver `docs/DECISOES.md`.
+- `--report` e `--clean` estao no parser mas respondem com a fase em que chegam.
+
+## [1.0.0] - 2026-09-03
+
+Versao original. Modo Game com encerramento de processos, limpeza de RAM, plano de energia,
+prioridade do jogo, silenciamento do sistema, snapshot e reversao, e `--scan`.
+Codigo-fonte perdido.
diff --git a/GameBoost/CLAUDE.md b/GameBoost/CLAUDE.md
new file mode 100644
index 0000000..e0c17da
--- /dev/null
+++ b/GameBoost/CLAUDE.md
@@ -0,0 +1,100 @@
+# CLAUDE.md — GameBoost
+
+Regras resumidas para quem escreve código neste repositório. Geradas a partir da seção 2
+do `GAMEBOOST_V2_SPEC.md`. **Valem para todo código novo, sem exceção.**
+
+---
+
+## As 10 regras inegociáveis
+
+1. **Reversível ou não existe.** Toda alteração de sistema (registro, serviço, plano de
+   energia, tweak) grava o valor anterior num `ChangeRecord` em `state-backup.json` **antes**
+   de aplicar, e tem caminho de reversão testado em `RollbackEngineTests`.
+2. **Nunca deletar sem lixeira ou confirmação.** Arquivos de usuário vão para a Lixeira
+   (`SHFileOperation` com `FOF_ALLOWUNDO`). Temporários de sistema podem ser apagados direto,
+   mas só das pastas da whitelist do módulo.
+3. **Nada é pré-marcado se puder causar perda.** Jogos, launchers, IDEs com trabalho aberto e
+   apps de gravação aparecem na lista, nunca marcados.
+4. **Honestidade sobre ganho.** Cada ação mostra o ganho **medido** (MB liberados, apps
+   fechados, segundos de boot). Proibido inventar número. Proibido "limpeza de registro".
+5. **Sem telemetria, sem anúncios, sem upsell.** Nada sai da máquina sem o usuário clicar em
+   "Enviar diagnóstico".
+6. **Blindagem primeiro.** `ISafetyGuard` é consultado por **todos** os módulos, não só pelo
+   Modo Game.
+7. **Tudo em PT-BR.** Strings de UI em recurso para permitir EN depois.
+8. **Log de tudo.** Toda ação grava linha estruturada em `gameboost.log`
+   (timestamp, módulo, ação, alvo, resultado) via `IGameBoostLogger`.
+9. **Sem PowerShell quando houver API.** Win32/WMI/CIM via P/Invoke ou `System.Management`.
+   PowerShell só para o que não tem API razoável (`Get-AppxPackage`), sempre com
+   `-NoProfile -NonInteractive -ExecutionPolicy Bypass`.
+10. **Nunca travar a UI.** Toda varredura roda em `Task` com `IProgress<T>` e
+    `CancellationToken`.
+
+---
+
+## Mapa de pastas
+
+```
+GameBoost/
+├── src/
+│   ├── GameBoost.Core/           Lógica pura, sem WPF. Testável.
+│   │   ├── Abstractions/         Interfaces: IProcessService, IRegistryService, IFileSystem, IClock…
+│   │   ├── Native/               P/Invoke centralizado (NativeMethods interno + Bridge público)
+│   │   ├── Safety/               SafetyGuard, ProtectedProcesses/Paths/Services, AntivirusDetector
+│   │   ├── State/                ChangeRecord, StateBackup, RollbackEngine
+│   │   ├── Logging/              Logger estruturado, rotação 5 MB × 5
+│   │   ├── Settings/             AppPaths, AppSettings, SettingsStore, SettingsMigrator
+│   │   ├── Services/             Implementações Windows das Abstractions
+│   │   └── Modules/
+│   │       ├── IModule.cs, ActionItem.cs, RiskLevel.cs
+│   │       └── GameMode/         GameModeModule, GameDetector, SystemSilencer, GameSession
+│   ├── GameBoost.App/            WPF: Views, ViewModels, Converters, Themes
+│   ├── GameBoost.Cli/            Parser e runner dos comandos de linha
+│   └── GameBoost.Tests/          xUnit + NSubstitute
+├── installer/GameBoost.iss
+└── docs/                         DECISOES.md, PROTECAO.md, TWEAKS.md, QA.md
+```
+
+---
+
+## Contratos que todo módulo novo segue
+
+```csharp
+public interface IModule
+{
+    string Id { get; }
+    Task<ScanResult>  ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct);
+    Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct);
+    Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct);
+}
+```
+
+Cada item acionável é um `ActionItem { Id, Categoria, Titulo, Descricao, Risco,
+GanhoEstimado, PreMarcado, ComoDesfazer, Bloqueado, MotivoBloqueio }`. A UI é genérica: uma
+lista de `ActionItem` com checkbox, badge de risco e botão "?".
+
+**Todo módulo precisa de `dryRun` funcional**: mesmo relatório, zero escrita. Existe teste
+provando que os fakes não recebem chamadas de escrita.
+
+---
+
+## Padrões
+
+- **MVVM** com CommunityToolkit.Mvvm (`[ObservableProperty]`, `[RelayCommand]`).
+- **DI** com `Microsoft.Extensions.DependencyInjection`, montado em `CoreServices`.
+  Classe de módulo recebe interfaces, nunca `static`.
+- **Elevação**: `requireAdministrator` no manifest. Sem admin o app entra em modo somente
+  leitura: varreduras funcionam, ações ficam desabilitadas com aviso.
+- **Trimming**: proibido. Quebra WPF e reflexão.
+
+---
+
+## Antes de abrir PR
+
+```powershell
+dotnet build GameBoost.sln          # 0 erros, 0 avisos
+dotnet test  GameBoost.sln          # tudo verde
+```
+
+Qualquer decisão que fuja do `GAMEBOOST_V2_SPEC.md` vai para `docs/DECISOES.md` com data e
+motivo. Tweak novo entra em `docs/TWEAKS.md`; lista de proteção nova, em `docs/PROTECAO.md`.
diff --git a/GameBoost/Directory.Build.props b/GameBoost/Directory.Build.props
new file mode 100644
index 0000000..ffe4cd8
--- /dev/null
+++ b/GameBoost/Directory.Build.props
@@ -0,0 +1,20 @@
+<Project>
+  <PropertyGroup>
+    <!-- Versao semantica unica, propagada para os assemblies e para o Inno Setup. -->
+    <VersionPrefix>2.0.0</VersionPrefix>
+    <Product>GameBoost</Product>
+    <Company>Jonathan Vaz</Company>
+    <Authors>Jonathan Vaz</Authors>
+    <Copyright>Copyright (c) 2026 Jonathan Vaz</Copyright>
+
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <WarningsAsErrors>nullable</WarningsAsErrors>
+    <NeutralLanguage>pt-BR</NeutralLanguage>
+    <InvariantGlobalization>false</InvariantGlobalization>
+    <!-- Trimming quebra WPF e reflexao (secao 10 do spec). Nunca habilitar. -->
+    <PublishTrimmed>false</PublishTrimmed>
+  </PropertyGroup>
+</Project>
diff --git a/GameBoost/GAMEBOOST_V2_SPEC.md b/GameBoost/GAMEBOOST_V2_SPEC.md
new file mode 100644
index 0000000..e85a774
--- /dev/null
+++ b/GameBoost/GAMEBOOST_V2_SPEC.md
@@ -0,0 +1,626 @@
+# GameBoost v2 · Especificação completa para o Claude Code
+
+> Documento de trabalho para o Claude Code evoluir o GameBoost de "booster de jogos" para "central de otimização e manutenção do PC gamer". Leia inteiro antes de escrever código. As regras da seção 2 valem para todo o projeto.
+
+---
+
+## 0. Como usar este documento
+
+1. Abra o repositório do GameBoost (`src/GameBoost/GameBoost.csproj`, `installer/GameBoost.iss`).
+2. Rode a Fase 0 (seção 12) antes de qualquer feature nova: refatorar para módulos, criar a infraestrutura compartilhada.
+3. Implemente as fases na ordem. Cada fase termina com build limpo, testes passando e um commit.
+4. Toda decisão que fugir deste documento deve ser registrada em `docs/DECISOES.md` com data e motivo.
+
+---
+
+## 1. Estado atual (v1.0.0)
+
+**Stack**: C# / .NET 9 / WPF, publish self-contained single-file, instalador Inno Setup 6, requer admin (manifest `requireAdministrator`).
+
+**O que já existe e deve ser preservado:**
+
+| Recurso | Implementação atual |
+|---|---|
+| Modo Game (ativar/desativar) | Varredura de processos, tela de confirmação pré-marcada, encerramento gracioso (3 s) depois forçado |
+| Reabertura de apps essenciais (★) | `session.json` guarda caminho + argumentos |
+| Limpeza de RAM | `EmptyWorkingSet` em todos os processos + purga da Standby List (`NtSetSystemInformation` / `SystemMemoryListInformation`) |
+| Plano de energia | Alto desempenho / Desempenho Máximo, restaura o anterior |
+| Prioridade do jogo | Detecção do jogo e prioridade Alta (nunca Realtime) |
+| Silenciar sistema | Notificações, Game DVR, Game Bar overlay, pausa Windows Update |
+| Blindagem | Lista de processos críticos, tudo em `C:\Windows`, antivírus/EDR via WMI, drivers, outras sessões |
+| Snapshot e reversão | `state-backup.json`, botão "Reverter tudo", aviso na abertura se ficou ativo, reversão no desinstalador |
+| Diagnóstico | `GameBoost.exe --scan relatorio.txt` |
+| Persistência | `%LOCALAPPDATA%\GameBoost\` (`settings.json`, `session.json`, `state-backup.json`, `gameboost.log`) |
+
+**Limitações conhecidas da v1:**
+- Uma única função (Modo Game). Usuário instala, usa uma vez, esquece.
+- Sem visão de "o que está pesando" na máquina. O usuário não sabe por que o PC está lento.
+- Sem manutenção contínua (limpeza, inicialização, espaço em disco).
+- Sem assinatura digital (SmartScreen e falsos positivos de antivírus).
+- Sem auto-update.
+
+---
+
+## 2. Regras inegociáveis (valem para todo código novo)
+
+1. **Reversível ou não existe.** Toda alteração de sistema (registro, serviço, plano de energia, tweak) grava o valor anterior em `state-backup.json` antes de aplicar e tem um caminho de reversão testado.
+2. **Nunca deletar sem lixeira ou confirmação.** Arquivos de usuário vão para a Lixeira (`SHFileOperation` com `FOF_ALLOWUNDO`). Arquivos de sistema temporários podem ser deletados direto, mas só das pastas da whitelist (seção 5.2).
+3. **Nada é pré-marcado se puder causar perda.** Jogos, launchers, IDEs com trabalho aberto, apps de gravação: aparecem, nunca vêm marcados.
+4. **Honestidade sobre ganho.** Cada ação mostra o ganho real medido (MB liberados, apps fechados, segundos de boot economizados). Proibido inventar número. Proibido "limpeza de registro" (não traz ganho mensurável e é risco puro).
+5. **Sem telemetria, sem anúncios, sem upsell.** Nada sai da máquina sem o usuário clicar em "Enviar diagnóstico".
+6. **Blindagem primeiro.** As listas de proteção (seção 9) são aplicadas em todos os módulos, não só no Modo Game.
+7. **Tudo em PT-BR**, com strings em arquivo de recursos (`Resources/Strings.pt-BR.resx`) para permitir EN depois.
+8. **Log de tudo.** Toda ação grava linha estruturada em `gameboost.log` (timestamp, módulo, ação, alvo, resultado).
+9. **Sem PowerShell quando houver API.** Prefira Win32/WMI/CIM via P/Invoke ou `System.Management`. PowerShell só para o que não tem API razoável (ex.: `Get-AppxPackage`), e sempre com `-NoProfile -NonInteractive -ExecutionPolicy Bypass`.
+10. **Nunca travar a UI.** Toda varredura roda em `Task` com `IProgress<T>` e `CancellationToken`.
+
+---
+
+## 3. Pesquisa de mercado
+
+> Referência de concorrentes e do que os usuários pedem. Validado com fontes de 2026 (guias de otimização, reviews e fóruns) em 13/09/2026. Fontes principais listadas em 3.5.
+
+### 3.1 Concorrentes diretos (boosters de jogos)
+
+| Produto | Preço | Pontos fortes | Reclamações recorrentes dos usuários |
+|---|---|---|---|
+| **Razer Cortex** | Grátis | Ainda o "free all-rounder" mais citado em 2026: suspende serviços, limpa RAM, restaura ao sair, contador de FPS, launcher unificado | Anúncios e promoções embutidos, ganho mínimo em PC bom, relatos de conflito com apps e jogos, consumo próprio de recursos, exige conta |
+| **Wise Game Booster** | Grátis | Leve, simples, gerencia serviços e processos | Interface datada, sem monitoramento, pouco mantido |
+| **IObit Advanced SystemCare / Game Booster** | Freemium (~US$20/ano) | Suite completa (limpeza, startup, drivers, privacidade) | Bloatware, pop-ups agressivos, instala outros produtos IObit, "limpeza de registro" placebo |
+| **Smart Game Booster** | Freemium | Overlay FPS, monitor de temperatura, auto-boost | Falsos positivos de antivírus, upsell constante |
+| **Game Fire / GearUP Booster / Chris-PC Game Booster** | Freemium | Preset por jogo antes de abrir, restauração ao sair, teste antes/depois dentro do app (Game Fire e GearUP) | Pouco conhecidos, parte das funções paga |
+| **Process Lasso** | Freemium | Regras persistentes por processo, ProBalance, afinidade de CPU. Sempre citado como "o que funciona de verdade" | Curva de aprendizado, não é pensado pra leigo |
+| **Windows Game Mode + Xbox Game Bar** | Grátis (nativo) | Integração de sistema, sem instalação | Game Bar consome recursos, Game Mode faz pouco, sem controle fino |
+| **AMD Adrenalin / NVIDIA App** | Grátis | Overlay, gravação, tweaks de driver | Só GPU, não cuida de processos/disco |
+
+### 3.2 Concorrentes indiretos (limpeza e manutenção)
+
+| Categoria | Referências | O que fazem bem |
+|---|---|---|
+| Limpeza | CCleaner (Piriform/Gen), BleachBit (open source), Wise Disk Cleaner, Windows Storage Sense | Presets por app (navegadores, Discord, Steam shader cache), agendamento |
+| Análise de disco | **WizTree 4.30 (mar/2026)**: lê a MFT, varre SSD grande em segundos, trata hard links, treemap, top arquivos, busca rápida, export CSV e localizador de duplicados desde a v4. WinDirStat, TreeSize Free, SpaceSniffer | É a referência unânime em 2026 ("free, blindingly fast"). Não apaga nada sozinho, só mostra e abre no Explorer. Guias sempre listam os mesmos suspeitos: hiberfil.sys, Windows.old (20 GB+ após update), temp, jogos de 80 a 150 GB, backups velhos |
+| Desinstalação | **Bulk Crap Uninstaller** (Apache 2.0, acha desinstaladores quebrados/ocultos, portáteis, Store, Windows Features, Chocolatey, apps de lojas de jogos), **Revo Uninstaller Free 2.7.0 (mai/2026)** com Hunter Mode pra apps da Store e restos melhorados, Geek Uninstaller | Varredura de restos após desinstalar (com aviso de que não é garantida), desinstalação silenciosa em lote, remoção de bloatware da Store |
+| Inicialização | Autoruns (Sysinternals), Gerenciador de Tarefas, Startup Delayer | Mostrar impacto real no boot, tarefas agendadas, serviços |
+| Gerência de processos | Process Lasso, Process Explorer | Regras por processo persistentes, afinidade de CPU, ProBalance |
+| Tweaks | Chris Titus WinUtil, Winaero Tweaker, O&O ShutUp10++, Atlas OS / ReviOS | Tweaks documentados, reversíveis, com explicação de cada um |
+| Monitoramento | HWiNFO64, MSI Afterburner + RTSS, LibreHardwareMonitor, LatencyMon | Temperaturas, clocks, throttling, DPC latency, overlay em jogo |
+| Drivers | Driver Booster (IObit), DDU, Snappy Driver Installer | Detectar driver de GPU desatualizado (mas instalar driver automaticamente é risco) |
+
+### 3.3 O que os usuários realmente pedem (Reddit r/pcgaming, r/Windows11, r/pcmasterrace, Steam forums, reviews da Microsoft Store)
+
+**Querem:**
+1. Saber **o que está pesando** o PC agora (o "por que está lento?").
+2. **Espaço em disco**: onde estão os GB perdidos (shader cache, Windows.old, downloads antigos, jogos que não jogam mais).
+3. **Desinstalar de verdade**, inclusive bloatware da Store e apps que reaparecem.
+4. **Inicialização limpa**: o PC demora pra ligar e não sabem o que desativar com segurança.
+5. **Ganho de FPS honesto**: dizer claramente o que faz diferença (fechar Chrome/Discord overlay, plano de energia, driver de GPU, HAGS, Fullscreen Optimizations) e o que é placebo.
+6. **Leve, sem anúncio, sem conta, sem assinatura**, de preferência portátil.
+7. **Explicação em cada opção**: "o que isso faz, qual o risco, como desfazer".
+8. **Não quebrar nada**: medo de tweak que trava Windows Update, some com o Wi-Fi, quebra a impressora.
+9. **Perfis por jogo**: ao abrir Valorant faz X, ao abrir Cyberpunk faz Y.
+10. **Temperatura e throttling**: saber se o FPS caiu porque a CPU/GPU está esquentando.
+
+**Odeiam:**
+- Limpeza de registro, "otimização de DNS mágica", "acelerador de RAM" sem número.
+- Pop-up de upgrade, instalação de toolbar, envio de dados.
+- App que fecha o anti-cheat ou o próprio jogo.
+- Alterações sem explicação e sem "desfazer".
+
+### 3.4 Consenso técnico de 2026 sobre o que realmente dá ganho
+
+Os guias mais sérios convergem: cerca de seis ajustes explicam quase todo o ganho real, o resto é placebo, já é padrão ou troca segurança por poucos %.
+
+1. **Plano de energia em Alto desempenho / Melhor desempenho** (evita clock baixo).
+2. **Podar inicialização e apps em background** (junto com o item 1, são os dois de maior valor e os mais fáceis de reverter).
+3. **Game Mode do Windows ligado** (versão 22H2+ ajuda e evita Windows Update durante o jogo; só desligar se houver conflito).
+4. **Game Bar / gravação em segundo plano desligados.**
+5. **Jogo em SSD** (lançamentos de 2025/2026 já exigem SSD e engasgam em HDD).
+6. **Driver de GPU atualizado da fonte oficial** e monitor configurado na taxa de atualização certa (Windows volta pra 60 Hz depois de driver ou troca de cabo com frequência).
+
+Pontos que exigem teste, não regra:
+- **HAGS**: obrigatório para DLSS Frame Generation; melhora frame pacing em GPUs recentes (RTX 30+, RX 6000+) com driver atual, mas causa stutter em CPUs antigas ou certas versões de driver. É "o único ajuste que você precisa testar em vez de só ligar". Custa até 1 GB de VRAM (atenção em placas de 8 GB).
+- **VBS / Memory Integrity (Core Isolation)**: vem ligado por padrão no Windows 11 e os guias medem 5 a 15% de FPS em jogos CPU-bound (até 25% em casos extremos). É recurso de segurança contra malware de kernel. Consenso: desligar só em PC exclusivo de jogo, manter em máquina de trabalho/banco. Por isso o GameBoost **informa e mede, mas não desliga**: mostra o estado, o impacto estimado e o caminho nas Configurações do Windows.
+- **Updates grandes do Windows (24H2, 26H2) resetam** Game Mode, HAGS, plano de energia, efeitos visuais e Game Bar. O GameBoost deve detectar isso e avisar "seu perfil foi desfeito por uma atualização".
+
+Placebo ou risco confirmados: limpeza de registro, "defrag" em SSD, updaters de driver automáticos, tweaks agressivos de serviço.
+
+### 3.5 Fontes consultadas (set/2026)
+- Frozen Tweaks, Gear-Rank, SmoothFPS, Switchblade Gaming, TechFixGrid: guias de otimização Windows 11 2026 (VBS, HAGS, Game Mode, 26H2).
+- iTechGuides, TechBloat, TechBre, Techlasi, Gitnux, Worldmetrics: rankings de boosters 2026.
+- Neat Net Tricks e Swastiktechnology: reviews WizTree 2026; RottenWifi: BCU, Revo 2.7.0, Storage Sense.
+- Steam Community e Tom's Guide: percepção de usuário sobre boosters ("snake oil", "bloatware em PC bem cuidado").
+- Microsoft Learn: SmartScreen reputation, opções de assinatura de código, Azure Artifact Signing.
+
+### 3.6 Posicionamento do GameBoost v2
+
+**"O booster que mostra o que faz e desfaz tudo."** Diferenciais:
+- Transparência total (cada botão explica antes, mede depois, reverte sempre).
+- Zero anúncios, zero telemetria, PT-BR nativo.
+- Diagnóstico de gargalo em linguagem humana ("seu Chrome está usando 40% da CPU com 62 abas").
+- Portátil opcional (mesmo exe roda sem instalar).
+- **Prova de ganho**: medição antes/depois em cada ação (Game Fire e GearUP já fazem isso e os reviews valorizam muito).
+- **Detector de reset pós-update**: nenhum concorrente avisa que o Windows desfez os ajustes.
+
+---
+
+## 4. Arquitetura alvo
+
+### 4.1 Estrutura de pastas
+
+```
+GameBoost/
+├── src/
+│   ├── GameBoost.Core/              # Lógica pura, sem WPF. Testável.
+│   │   ├── Abstractions/            # Interfaces (IProcessService, IRegistryService, IFileSystem, IClock...)
+│   │   ├── Native/                  # P/Invoke centralizado (Kernel32, Psapi, NtDll, Advapi32, Shell32, PowrProf)
+│   │   ├── Safety/                  # Blindagem: ProtectedProcesses, ProtectedPaths, ProtectedServices, AntiCheatList
+│   │   ├── State/                   # Snapshot/rollback (StateBackup, ChangeRecord, RollbackEngine)
+│   │   ├── Logging/                 # Logger estruturado (JSON lines + texto legível)
+│   │   ├── Settings/                # Settings, perfis, migração de versão
+│   │   └── Modules/
+│   │       ├── GameMode/            # (existente, refatorado)
+│   │       ├── Cleaner/             # Limpeza de temporários e caches
+│   │       ├── Uninstaller/         # Desinstalador Win32 + Store + restos
+│   │       ├── DiskAnalyzer/        # Análise de espaço (MFT + fallback)
+│   │       ├── Bottleneck/          # Monitor e diagnóstico de gargalos
+│   │       ├── Startup/             # Inicialização, tarefas agendadas
+│   │       ├── Services/            # Serviços do Windows
+│   │       ├── Tweaks/              # Tweaks de jogos reversíveis
+│   │       ├── Network/             # Velocidade, NAT (STUN), UPnP, Teredo, firewall
+│   │       ├── Drivers/             # Verificação de drivers de GPU
+│   │       ├── Profiles/            # Perfis por jogo
+│   │       └── HealthReport/        # Relatório e pontuação
+│   ├── GameBoost.App/               # WPF: Views, ViewModels, Converters, Themes
+│   │   ├── Views/
+│   │   ├── ViewModels/
+│   │   ├── Controls/                # Treemap, Gauge, ProcessList, ConfirmDialog
+│   │   ├── Themes/                  # Dark.xaml (padrão), Light.xaml
+│   │   └── Resources/Strings.pt-BR.resx
+│   ├── GameBoost.Cli/               # Modo linha de comando (--scan, --clean, --report)
+│   └── GameBoost.Tests/             # xUnit + NSubstitute
+├── installer/GameBoost.iss
+├── docs/
+│   ├── DECISOES.md
+│   ├── TWEAKS.md                    # Catálogo de cada tweak: chave, valor, efeito, risco, fonte
+│   ├── PORTAS.md                    # Portas por jogo/launcher para UPnP e firewall
+│   └── PROTECAO.md                  # Listas de blindagem documentadas
+├── CLAUDE.md                        # Regras resumidas para o Claude Code (gerar a partir da seção 2)
+└── README.md
+```
+
+### 4.2 Padrões
+
+- **MVVM** com CommunityToolkit.Mvvm (`[ObservableProperty]`, `[RelayCommand]`).
+- **DI** com `Microsoft.Extensions.DependencyInjection`. Toda classe de módulo recebe interfaces, nunca `static`.
+- **Cada módulo expõe** `IModule` com: `ScanAsync(progress, ct)` → `ScanResult`, `ApplyAsync(selection, ct)` → `ApplyResult`, `RevertAsync(changeIds)`.
+- **Cada item acionável** é um `ActionItem { Id, Categoria, Titulo, Descricao, Risco (Baixo/Medio/Alto), GanhoEstimado, PreMarcado, ComoDesfazer }`. A UI é genérica: uma lista de `ActionItem` com checkbox, badge de risco e botão "?" com a explicação.
+- **Elevação**: manter `requireAdministrator`. Adicionar modo "somente leitura" quando rodar sem admin (varreduras funcionam, ações ficam desabilitadas com aviso).
+
+---
+
+## 5. Módulos: especificação funcional
+
+Cada módulo abaixo tem: objetivo, fonte de dados/API, itens gerados, regras, UI, critérios de aceite.
+
+### 5.1 Modo Game (existente, melhorias)
+
+**Melhorias:**
+- Detecção automática de jogo: monitorar criação de processos (WMI `Win32_ProcessStartTrace` ou polling a cada 2 s) e cruzar com (a) lista de jogos conhecidos, (b) executáveis dentro de `steamapps/common`, `Epic Games`, `Riot Games`, `Battle.net`, `GOG Galaxy/Games`, `XboxGames`, (c) janela em fullscreen exclusivo/borderless ocupando 100% da tela. Ao detectar, oferecer "Ativar Modo Game para <jogo>?" via notificação (ou ativar direto se o perfil do jogo mandar).
+- Timer resolution: `NtSetTimerResolution(0.5 ms)` enquanto Modo Game ativo (Windows 11 já lida bem, mas em 10 ajuda). Reverter ao sair.
+- Afinidade de CPU opcional para o jogo (perfil avançado): permitir reservar núcleos. Padrão desligado.
+- Modo "Só o essencial": encerrar apenas processos com >2% CPU ou >300 MB RAM nos últimos 30 s (evita lista gigante).
+- Exibir ganho: RAM livre antes/depois, nº de processos fechados, % CPU em background antes/depois.
+
+**Critérios de aceite:** ativar e desativar 10 vezes seguidas sem vazar estado; matar o app durante o modo ativo e reabrir mostra o aviso de restauração; jogo nunca aparece pré-marcado.
+
+### 5.2 Limpeza de arquivos temporários e caches
+
+**Objetivo:** liberar espaço com segurança, mostrando o que será apagado e quanto ocupa.
+
+**Categorias e alvos (whitelist, só estes caminhos):**
+
+| Categoria | Caminhos | Risco | Pré-marcado |
+|---|---|---|---|
+| Temp do usuário | `%TEMP%` (arquivos não bloqueados, >24 h) | Baixo | Sim |
+| Temp do sistema | `C:\Windows\Temp` | Baixo | Sim |
+| Prefetch | `C:\Windows\Prefetch\*.pf` mais antigos que 30 dias | Baixo | Não (afeta boot por alguns dias) |
+| Windows Update cache | `C:\Windows\SoftwareDistribution\Download` (parar serviço `wuauserv` antes) | Baixo | Sim |
+| Delivery Optimization | via `IDOManager` ou `Get-DeliveryOptimizationStatus`; simples: `Clear-DeliveryOptimizationCache` não existe, usar Limpeza de Disco API `cleanmgr /sageset` presets ou pasta `%WINDIR%\ServiceProfiles\NetworkService\AppData\Local\Microsoft\Windows\DeliveryOptimization\Cache` | Baixo | Sim |
+| Windows.old | `C:\Windows.old` (só se existir; usar `cleanmgr` handler "Previous Windows installation(s)" ou takeown + delete) | Médio | Não |
+| Lixeira | `SHEmptyRecycleBin` | Médio | Não |
+| Miniaturas / cache de ícones | `%LOCALAPPDATA%\Microsoft\Windows\Explorer\thumbcache_*.db`, `iconcache_*.db` | Baixo | Não |
+| Logs do Windows | `C:\Windows\Logs\CBS\*.log` antigos, `%WINDIR%\Panther` (não), `C:\ProgramData\Microsoft\Windows\WER\ReportQueue` | Baixo | Sim (só WER) |
+| Dumps de memória | `C:\Windows\Minidump`, `C:\Windows\MEMORY.DMP` | Baixo | Sim |
+| Cache de navegadores | Chrome/Edge/Brave/Opera (`User Data\<Profile>\Cache`, `Code Cache`, `GPUCache`), Firefox (`cache2`). NUNCA cookies, senhas, histórico | Baixo | Sim, só se navegador fechado |
+| Discord | `%APPDATA%\discord\Cache`, `Code Cache`, `GPUCache` | Baixo | Sim, se fechado |
+| Spotify | `%LOCALAPPDATA%\Spotify\Storage`, `Data` | Baixo | Não |
+| Shader cache | NVIDIA: `%LOCALAPPDATA%\NVIDIA\DXCache`, `%LOCALAPPDATA%\NVIDIA\GLCache`, `%PROGRAMDATA%\NVIDIA Corporation\NV_Cache`; AMD: `%LOCALAPPDATA%\AMD\DxCache`, `GLCache`; DirectX: `%LOCALAPPDATA%\D3DSCache`; Steam: `Steam\steamapps\shadercache` | Médio (jogos vão engasgar ao recompilar) | Não, com explicação |
+| Steam | `Steam\appcache\httpcache`, `Steam\logs`, `Steam\dumps` | Baixo | Sim |
+| Epic / Riot / Battle.net | Logs e caches de cada launcher (documentar caminhos em `TWEAKS.md`) | Baixo | Sim |
+| Instaladores esquecidos | `%USERPROFILE%\Downloads\*.exe|*.msi|*.zip` > 30 dias | Alto | Nunca. Apenas listar em "Sugestões" |
+
+**Regras:**
+- Varredura calcula tamanho por categoria antes de mostrar. Exibir total "até X GB".
+- Arquivos em uso (`IOException` sharing violation) são pulados e contados em "não foi possível remover N arquivos (em uso)".
+- Cache de navegador/Discord só limpa se o processo não estiver rodando; senão, oferece "Fechar e limpar".
+- Nunca tocar em: `AppData\Roaming` de jogos (saves), `Documents`, `Pictures`, `OneDrive`, qualquer pasta com `.git`.
+- Guardar histórico: `cleanup-history.json` com data, categorias, MB liberados.
+- Agendamento opcional: tarefa no Agendador (`schtasks`) semanal com `GameBoost.exe --clean --preset seguro`.
+
+**Critérios de aceite:** rodar limpeza duas vezes seguidas, segunda vez libera ~0; nenhum arquivo fora da whitelist é tocado (teste com `IFileSystem` fake registrando todos os caminhos); tamanho reportado bate com o `du` real com margem de 5%.
+
+### 5.3 Desinstalador de aplicativos
+
+**Objetivo:** listar tudo instalado (Win32, Store/UWP, portáteis detectados), permitir desinstalação em lote e limpar restos.
+
+**Fontes:**
+- Registro: `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall`, `HKLM\SOFTWARE\WOW6432Node\...\Uninstall`, `HKCU\...\Uninstall`. Ler `DisplayName`, `DisplayVersion`, `Publisher`, `InstallDate`, `InstallLocation`, `EstimatedSize`, `UninstallString`, `QuietUninstallString`, `WindowsInstaller` (MSI → `msiexec /x {GUID} /qn`).
+- Store/UWP: `Get-AppxPackage -AllUsers` via PowerShell (ou `PackageManager` da WinRT via `Windows.Management.Deployment`). Marcar `NonRemovable`, `IsFramework` e pacotes de sistema como protegidos.
+- Uso real: cruzar com `HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist` (decodificar ROT13) e `LastWriteTime` dos executáveis para mostrar "último uso" e "nunca usado".
+- Tamanho real: `EstimatedSize` do registro é pouco confiável; se `InstallLocation` existir, calcular tamanho da pasta em background.
+
+**Lista de bloatware conhecido (sugestão, nunca pré-marcado):** Candy Crush, Spotify (Store), TikTok, Xbox TCUI (não remover se for jogar), Microsoft Solitaire, 3D Viewer, Clipchamp, LinkedIn, McAfee/Norton trial, Booking.com, Disney+, Netflix (Store shortcut), OEM utilities (HP Wolf, Lenovo Vantage é útil, cuidado), Cortana, Feedback Hub, Get Help, Mixed Reality Portal.
+
+**Nunca desinstalar (protegido):** Visual C++ Redistributables, .NET Runtimes, DirectX, drivers de GPU/áudio/chipset, Microsoft Edge (WebView2 é dependência), Xbox Identity Provider e Xbox Game Services (anti-cheat e jogos do Game Pass dependem), antivírus ativo, qualquer app do publisher "Microsoft Corporation" da lista de frameworks.
+
+**Fluxo:**
+1. Lista com busca, filtros (Store / Win32 / Grandes / Nunca usados / Bloatware sugerido), ordenação por tamanho e último uso.
+2. Seleção múltipla → "Desinstalar N apps" → tela de confirmação com badge de risco.
+3. Execução sequencial: preferir `QuietUninstallString`; se não houver, rodar `UninstallString` e mostrar aviso "este app abre o desinstalador próprio". Timeout de 10 min por app.
+4. Após cada desinstalação, **varredura de restos**: pasta `InstallLocation` residual, `%APPDATA%\<Publisher|Nome>`, `%LOCALAPPDATA%\<Nome>`, `%PROGRAMDATA%\<Nome>`, chaves `HKCU\Software\<Nome>` e `HKLM\Software\<Nome>`. Só sugerir se o nome tiver match exato (nunca substring curta). Restos vão para a Lixeira / chave exportada em `.reg` antes de apagar.
+5. Ponto de restauração do sistema opcional antes de lote grande (`Checkpoint-Computer` via PowerShell ou `SystemRestore` WMI), com aviso de que o Windows limita a 1 por 24 h por padrão.
+
+**Aba "Atualizações" (winget):**
+- Verificar se o `winget` está disponível (`winget --version`; vem com o App Installer no Windows 10 1709+ e 11). Se não estiver, oferecer instalar pela Store (`ms-appinstaller:`).
+- Listar desatualizados com `winget upgrade --include-unknown --accept-source-agreements --disable-interactivity` e parsear a saída (ou usar `--output json` quando disponível na versão instalada; detectar pela versão do winget). Colunas: nome, versão atual, versão nova, fonte (winget / msstore).
+- Cruzar com a lista de instalados da aba principal pra mostrar tamanho e último uso ao lado.
+- Ações: "Atualizar selecionados" (`winget upgrade --id <Id> --silent --accept-package-agreements --accept-source-agreements`) e "Atualizar tudo" (mesmo comando por item, em sequência, com progresso por app; evitar `--all` pra poder pular e mostrar erro por app).
+- Regras:
+  - Nunca pré-marcar launchers e apps que se atualizam sozinhos (Steam, Epic, Discord, navegadores, Spotify, NVIDIA App): mostrar com tag "atualiza sozinho" e explicar que forçar pelo winget pode conflitar.
+  - Nunca atualizar drivers ou runtimes (Visual C++, .NET) sem o usuário marcar explicitamente; badge de risco Médio.
+  - Se um app estiver aberto, avisar "feche X antes" e oferecer fechar (reutilizando a lógica de encerramento gracioso do Modo Game).
+  - Apps com versão "desconhecida" (`--include-unknown`) ficam em grupo separado com aviso de que o winget não consegue comparar.
+  - Log de cada atualização em `updates-history.json`; se um update falhar, mostrar o código de erro do winget e link pro log em `%LOCALAPPDATA%\Packages\Microsoft.DesktopAppInstaller_*\LocalState\DiagOutputDir`.
+- Finding no Diagnóstico: "N apps desatualizados (M de segurança: navegadores, Java, 7-Zip)".
+- Agendamento opcional: checar semanalmente e notificar na bandeja, nunca atualizar sozinho.
+- Também pode ser usado pra **desinstalar** apps que o winget conhece (`winget uninstall --id`), como alternativa quando o `UninstallString` estiver quebrado.
+
+**Critérios de aceite:** lista bate com "Aplicativos instalados" do Windows (±2 itens de diferença aceitável por apps ocultos); desinstalação silenciosa de um app MSI de teste funciona; restos de app removido são detectados; nenhum item protegido aparece selecionável.
+
+### 5.4 Analisador de espaço em disco
+
+**Objetivo:** responder "onde foram parar meus GB" em segundos, estilo WizTree.
+
+**Implementação:**
+- **Caminho rápido (NTFS):** ler a MFT diretamente com `FSCTL_ENUM_USN_DATA` (`DeviceIoControl` em `\\.\C:`), reconstruir a árvore por `ParentFileReferenceNumber`, obter tamanho via `FSCTL_GET_RETRIEVAL_POINTERS` ou, mais simples, via `NtQueryDirectoryFile`/`FindFirstFileEx` com `FIND_FIRST_EX_LARGE_FETCH` só nos diretórios já enumerados. Alternativa aceitável na primeira versão: `FindFirstFileEx` recursivo paralelizado com `FIND_FIRST_EX_LARGE_FETCH`, que já é bem mais rápido que `DirectoryInfo`.
+- **Fallback (FAT/exFAT/sem admin):** enumeração recursiva normal.
+- Resultado em árvore com tamanho agregado, contagem de arquivos, extensão dominante.
+
+**UI:**
+- **Treemap** (controle próprio em WPF, retângulos por tamanho, cor por categoria: jogos, vídeo, instaladores, cache, sistema, outros). Clique para descer nível, breadcrumb para voltar.
+- **Top 100 maiores arquivos** e **Top 50 maiores pastas**.
+- **Categorias inteligentes:** Jogos (pastas de launchers), Vídeos (>500 MB `.mp4/.mkv`), Instaladores (`.exe/.msi/.iso` em Downloads), Caches, Windows.old, Arquivos de hibernação (`hiberfil.sys`) e paginação (`pagefile.sys`) com explicação e opção "Desativar hibernação (`powercfg /h off`)" com badge de risco Médio.
+- Ações por item: abrir no Explorer, mover para Lixeira, "Ignorar sempre".
+- Duplicados (fase posterior): hash parcial (primeiros 64 KB + tamanho) e só depois hash completo dos candidatos.
+
+**Critérios de aceite:** varredura de 500 GB com 1 milhão de arquivos em < 30 s via MFT em SSD; treemap responde a clique em < 100 ms; nunca oferece apagar nada dentro de `C:\Windows`, `Program Files` (só via Desinstalador) ou pastas de saves.
+
+### 5.5 Diagnóstico de gargalos (o "por que está lento?")
+
+**Objetivo:** mostrar em tempo real e em linguagem simples o que está consumindo CPU, GPU, RAM, disco e rede, e quem é o culpado.
+
+**Coleta (intervalo 1 s, buffer de 5 min em memória):**
+- **CPU:** total e por processo (`PerformanceCounter` ou delta de `Process.TotalProcessorTime`; preferir `NtQuerySystemInformation(SystemProcessInformation)` que traz tudo numa chamada). Frequência atual vs. base (`Win32_Processor.CurrentClockSpeed` é lento; usar contador `\Processor Information(_Total)\% Processor Performance`).
+- **RAM:** `GlobalMemoryStatusEx`, Standby List, Commit, por processo (Working Set privado).
+- **GPU:** contadores `\GPU Engine(*)\Utilization Percentage` e `\GPU Adapter Memory(*)\Dedicated Usage` (disponíveis no Windows 10 1709+). Por processo via instância do contador (`pid_XXXX_luid...`). Temperatura e clocks via **LibreHardwareMonitorLib** (NuGet, MPL 2.0) para NVIDIA/AMD/Intel.
+- **Disco:** `\PhysicalDisk(*)\% Idle Time`, fila, MB/s; por processo via ETW (`Microsoft.Diagnostics.Tracing.TraceEvent`, kernel provider `DiskIO`) ou, mais simples, `Process` IO counters delta (`GetProcessIoCounters`).
+- **Rede:** `\Network Interface(*)\Bytes Total/sec`; por processo via `GetExtendedTcpTable` + ETW `TcpIp` provider (fase posterior).
+- **Temperaturas:** CPU package, GPU core, NVMe (LibreHardwareMonitor). Detectar **throttling**: CPU com `% Processor Performance` < 80% enquanto uso > 70% e temperatura > 90 °C.
+- **Latência DPC/ISR** (opcional, avançado): ETW kernel `DPC`/`Interrupt` events para apontar driver problemático (estilo LatencyMon). Marcar como experimental.
+
+**Diagnóstico automático (regras, cada uma gera um `Finding` com texto humano e ação sugerida):**
+
+| Regra | Texto exemplo | Ação sugerida |
+|---|---|---|
+| Processo > 25% CPU por 30 s fora do jogo | "Chrome está usando 38% da CPU (62 abas abertas)" | Fechar / adicionar ao Modo Game |
+| RAM disponível < 10% | "Só 1,2 GB de RAM livre. Discord + Chrome usam 4,1 GB" | Limpar RAM / fechar apps |
+| Standby List > 40% da RAM | "6 GB de RAM presos em cache do sistema" | Purgar Standby |
+| Disco do sistema > 90% ocupado | "C: com 94% de uso. SSD cheio fica lento" | Abrir Analisador de Disco |
+| Disco com % Idle < 20% por 30 s | "Seu disco está no limite. Windows Search está indexando" | Pausar indexação / ver processo |
+| GPU > 95% e FPS baixo | "GPU no máximo. Reduza resolução/qualidade ou ative DLSS/FSR" | Informativo |
+| CPU > 95% e GPU < 60% em jogo | "Gargalo de CPU: o processador não alimenta a placa de vídeo" | Fechar apps / prioridade |
+| Throttling térmico | "CPU a 97 °C reduzindo clock. Limpe o cooler / ajuste curva" | Informativo |
+| Plano de energia balanceado em jogo | "Plano Balanceado ativo durante o jogo" | Ativar Alto desempenho |
+| Driver de GPU > 6 meses | "Driver NVIDIA de fev/2026. Nova versão disponível" | Abrir página oficial |
+| Muitos apps na inicialização | "23 programas iniciam com o Windows (boot estimado +48 s)" | Abrir Inicialização |
+| Windows Search / Defender / Update usando disco | "Windows Defender fazendo varredura completa" | Informativo (nunca desativar Defender) |
+| Xbox Game Bar / Game DVR ligado | "Gravação em segundo plano ativa" | Desativar (reversível) |
+| Build do Windows mudou desde a última execução e tweaks/perfil não batem mais | "A atualização 26H2 desfez 4 ajustes seus" | Reaplicar perfil |
+| Monitor a 60 Hz sendo capaz de mais (`EnumDisplaySettings`) | "Seu monitor de 165 Hz está em 60 Hz" | Abrir configurações de vídeo |
+| VBS / Memory Integrity ativo | "Isolamento do núcleo ativo (custo típico 5 a 15% em jogos CPU-bound)" | Informativo com link |
+| HDD como disco do jogo | "Jogo instalado em HDD. Mova para SSD" | Informativo |
+| Memória em single channel | Via `Win32_PhysicalMemory` contagem de pentes | Informativo |
+
+**UI:** painel com 5 medidores (CPU, GPU, RAM, Disco, Rede) + temperatura, gráfico de 60 s, tabela "Top 10 processos" por recurso selecionado, e lista de `Findings` ordenada por impacto. Modo compacto "sempre no topo" (janela pequena) para deixar ao lado do jogo em segundo monitor.
+
+**Critérios de aceite:** coleta consome < 1,5% de CPU e < 60 MB de RAM; funciona sem LibreHardwareMonitor (temperaturas ficam "indisponível"); Findings não repetem a cada segundo (debounce de 30 s).
+
+### 5.6 Gerenciador de inicialização
+
+**Fontes:** `HKCU/HKLM\...\Run`, `RunOnce`, pasta Startup do usuário e comum, `HKLM\...\Explorer\StartupApproved` (estado ativado/desativado igual ao Gerenciador de Tarefas), Tarefas Agendadas com gatilho "no logon" (`Microsoft.Win32.TaskScheduler` NuGet ou `schtasks /query /xml`), serviços com início Automático de terceiros.
+
+**Dados por item:** nome, publisher, caminho, assinado digitalmente (sim/não, via `WinVerifyTrust` ou `X509Certificate.CreateFromSignedFile`), impacto no boot (ler `HKCU\...\Explorer\StartupApproved` não traz impacto; estimar via tamanho do exe + nº de DLLs importadas, ou usar dados de `Windows Performance` se disponíveis; mostrar como Baixo/Médio/Alto estimado).
+
+**Ações:** Desativar (gravar em `StartupApproved` com o mesmo formato do Gerenciador de Tarefas, para o Windows mostrar coerente), Atrasar (criar tarefa agendada com delay de N s e desativar a entrada original), Abrir local, Ver no Desinstalador.
+
+**Protegidos:** drivers de áudio/vídeo, antivírus, OneDrive (avisar), Bluetooth/touchpad OEM, SecurityHealth. Sugerir desativar: Spotify, Discord (se o usuário quiser abrir manualmente), Steam/Epic/EA app, Teams, Adobe Updater, iTunes Helper, Cortana.
+
+### 5.7 Serviços do Windows
+
+Lista de serviços com filtro "terceiros" e "otimizáveis para jogos". Tweaks reversíveis (guardar `StartType` anterior):
+
+| Serviço | Ação sugerida | Risco |
+|---|---|---|
+| `SysMain` (Superfetch) | Desativar só em SSD com <16 GB RAM? Não. Manter. Apenas explicar | Médio |
+| `WSearch` | Manual (busca do Explorer fica lenta) | Baixo |
+| `DiagTrack` (telemetria) | Desativar | Baixo |
+| `XblAuthManager`, `XblGameSave`, `XboxNetApiSvc` | Manter se usa Game Pass / anti-cheat da MS. Explicar | Médio |
+| `Fax`, `RemoteRegistry`, `WMPNetworkSvc`, `MapsBroker` | Desativar | Baixo |
+| `Spooler` | Manual se não tem impressora | Baixo |
+| `wuauserv` | Nunca desativar. Só pausar dentro do Modo Game (já existe) | Alto |
+| Serviços de antivírus, `WinDefend`, `SecurityHealthService` | Protegido | Alto |
+
+### 5.8 Tweaks de jogos (catálogo documentado em `docs/TWEAKS.md`)
+
+Cada tweak: chave/valor, efeito, evidência, risco, reversão. Todos desligados por padrão, aplicados individualmente, com snapshot.
+
+| Tweak | Onde | Efeito real | Risco |
+|---|---|---|---|
+| Hardware-Accelerated GPU Scheduling (HAGS) | `HKLM\SYSTEM\CurrentControlSet\Control\GraphicsDrivers\HwSchMode = 2` (reboot) | Obrigatório para DLSS Frame Gen; melhora frame pacing em RTX 30+/RX 6000+ com driver atual, piora em CPU antiga. Usa até 1 GB de VRAM. Oferecer "Testar com/sem" com benchmark rápido | Médio |
+| Game Mode do Windows | `HKCU\Software\Microsoft\GameBar\AutoGameModeEnabled` | Positivo no 22H2+ (bloqueia Update durante o jogo). Recomendar ligado; desligar só se der conflito com streaming | Baixo |
+| Game DVR / Game Bar | `HKCU\System\GameConfigStore\GameDVR_Enabled = 0`, `HKCU\Software\Microsoft\GameBar\UseNexusForGameBarEnabled = 0` | Reduz overhead de gravação | Baixo |
+| Fullscreen Optimizations por exe | `HKCU\System\GameConfigStore` `GameDVR_FSEBehaviorMode`, e `HKCU\...\AppCompatFlags\Layers` `DISABLEDXMAXIMIZEDWINDOWEDMODE` por jogo | Depende do jogo; oferecer por perfil | Baixo |
+| Multi-Plane Overlay (MPO) | `HKLM\SOFTWARE\Microsoft\Windows\Dwm\OverlayTestMode = 5` | Resolve stutter/flicker em alguns setups NVIDIA | Médio |
+| Nagle (TcpAckFrequency, TCPNoDelay) | `HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\<GUID>` | Ganho marginal em jogos com muitos pacotes pequenos; a maioria já usa UDP. Explicar honestamente | Baixo |
+| Network Throttling Index | `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile\NetworkThrottlingIndex = 0xFFFFFFFF` | Marginal | Baixo |
+| SystemResponsiveness | mesma chave, `SystemResponsiveness = 0` | Prioriza foreground | Baixo |
+| Games task priority | `...\SystemProfile\Tasks\Games` `GPU Priority = 8`, `Priority = 6`, `Scheduling Category = High` | Marginal | Baixo |
+| Mouse: desativar aceleração | `HKCU\Control Panel\Mouse` `MouseSpeed=0`, `MouseThreshold1/2=0` | Consistência de mira | Baixo |
+| Power throttling off para o jogo | `powercfg /setacvalueindex ... PERFBOOSTMODE` e `HKLM\...\Power\PowerThrottling\PowerThrottlingOff` | Evita clock baixo em notebook | Baixo |
+| Desativar hibernação | `powercfg /h off` | Libera espaço = tamanho da RAM, perde Inicialização Rápida | Médio |
+| Ultimate Performance plan | `powercfg /duplicatescheme e9a42b02-...` | Já existe no Modo Game | Baixo |
+| Visual effects "melhor desempenho" | `HKCU\...\Explorer\VisualEffects` | Ajuda só em máquina muito fraca; afeta UX | Baixo |
+| Timer resolution | Já no Modo Game | Baixo |
+| Core Isolation / VBS (Memory Integrity) | **Não alterar.** Detectar via `msinfo32`/WMI `Win32_DeviceGuard` e mostrar Finding: "VBS ativo, custo medido pela comunidade de 5 a 15% em jogos CPU-bound". Botão abre Configurações → Segurança do Windows → Isolamento do núcleo. Explicar o trade-off (PC só de jogo vs. máquina de trabalho/banco) | Alto |
+| Spectre/Meltdown mitigations | **Nunca.** | Alto |
+
+### 5.9 Rede: velocidade, NAT e conectividade para jogar online
+
+**Objetivo:** responder "minha internet está boa pra jogar?" e "por que não consigo entrar na partida/festa do meu amigo?" (NAT estrito), corrigindo o que for do Windows e apontando com precisão o que é do roteador ou da operadora.
+
+**5.9.1 Teste de velocidade**
+- Download/upload contra endpoints públicos (Cloudflare `speed.cloudflare.com/__down?bytes=N` e `__up`; fallback: arquivos de teste de CDNs conhecidas). Rodar 3 amostras de 10 s, reportar mediana. Nunca usar API da Ookla (termos restritos).
+- Ping/jitter/perda (ICMP `Ping` + TCP connect quando ICMP bloqueado) para: gateway, 1.1.1.1, 8.8.8.8 e servidores de jogo cadastrados pelo usuário (lista inicial com regiões de Riot, Valve, Blizzard, Epic, EA em São Paulo).
+- Resultado com semáforo: ping < 30 ms verde, 30 a 80 amarelo, > 80 vermelho; jitter > 15 ms e perda > 1% viram Finding.
+- Histórico em `network-history.json` pra mostrar "sua conexão piorou à noite".
+
+**5.9.2 Detecção do tipo de NAT (STUN, RFC 5389/5780)**
+- Cliente STUN próprio em UDP (poucas centenas de linhas): enviar Binding Request para 2 servidores públicos (ex.: `stun.l.google.com:19302`, `stun.cloudflare.com:3478`) por 2 portas locais e comparar os endereços mapeados. Classificar:
+  - **Aberto** (full cone / sem NAT): mesmo mapeamento em todos os testes e recebe de qualquer origem.
+  - **Moderado** (restricted / port-restricted cone): mapeamento estável, mas só recebe de quem já falou.
+  - **Estrito** (simétrico): mapeamento muda por destino. É o que impede duas pessoas com NAT estrito de se conectarem.
+- Exibir no mesmo vocabulário que Xbox/Call of Duty/Discord usam (Open/Moderate/Strict) e explicar em uma frase o que cada um bloqueia.
+
+**5.9.3 Detecção das causas**
+
+| Verificação | Como | Finding |
+|---|---|---|
+| **CGNAT** da operadora | IP WAN do roteador (via UPnP `GetExternalIPAddress` ou página do gateway) na faixa `100.64.0.0/10`, ou diferente do IP visto pelo STUN/`api.ipify.org` | "Sua operadora usa CGNAT. Nenhum ajuste no PC ou no roteador resolve NAT estrito. Peça IP público (às vezes chamado de IP fixo) ou use IPv6" |
+| **NAT duplo** | `tracert` para 1.1.1.1: dois ou mais saltos iniciais com IP privado (10/8, 172.16/12, 192.168/16) | "Dois roteadores em cascata. Coloque o modem da operadora em modo bridge ou use só um deles" |
+| **UPnP** | Descoberta SSDP (`M-SEARCH` para `239.255.255.250:1900`, `urn:schemas-upnp-org:device:InternetGatewayDevice:1`), depois `AddPortMapping` de teste e `DeletePortMapping` | "UPnP desligado no roteador: os jogos não conseguem abrir portas sozinhos" |
+| **Teredo / rede Xbox** | `netsh interface teredo show state` (estado `qualified` é o bom), serviço `XblAuthManager`/`XboxNetApiSvc`, e a leitura que o Windows mostra em Configurações → Jogos → Rede Xbox | "Teredo bloqueado. Festas e jogos que usam a rede Xbox no PC não vão conectar" |
+| **IPv6** | Interface tem endereço global e `ping -6` para `2606:4700:4700::1111` responde | Informativo: "IPv6 ativo, isso contorna o CGNAT em jogos que suportam" |
+| **Firewall do Windows** | `INetFwPolicy2` (COM) buscando regras para o exe do jogo detectado; verificar perfil ativo (Público vs Privado) | "Sua rede está marcada como Pública e o jogo não tem regra de entrada" |
+| **Wi-Fi** | `WlanQueryInterface`: banda, sinal, canal, taxa de conexão | "Wi-Fi 2,4 GHz com sinal de 40%. Para competitivo, use cabo ou 5 GHz" |
+| **Adaptador** | Velocidade de link (`Win32_NetworkAdapter.Speed`), duplex, driver com mais de 2 anos | "Placa de rede negociou 100 Mbps num plano de 500" |
+| **DNS** | Tempo de resolução com o DNS atual vs Cloudflare/Google/Quad9 | Tabela comparativa, o usuário escolhe |
+| **Banda em uso** | `GetExtendedTcpTable`/`GetExtendedUdpTable` + bytes por processo | "Steam baixando a 45 MB/s enquanto você joga" |
+
+**5.9.4 Correções que o app aplica (todas com snapshot e "Desfazer")**
+
+| Ação | Comando/API | Risco |
+|---|---|---|
+| Ativar Teredo e serviço de rede Xbox | `netsh interface teredo set state type=enterpriseclient servername=win1910.ipv6.microsoft.com` (padrão `default` como primeira tentativa), `Start-Service XboxNetApiSvc` | Baixo |
+| Criar regra de firewall pro jogo detectado (entrada e saída, TCP/UDP) | `INetFwRule` via COM | Baixo |
+| Marcar rede atual como Privada | `Set-NetConnectionProfile -NetworkCategory Private` | Baixo (explicar que não é pra fazer em Wi-Fi público) |
+| Abrir portas via UPnP para o jogo em execução (tabela de portas por jogo em `docs/PORTAS.md`) | `AddPortMapping` com lease de 24 h, removido ao sair do jogo | Baixo |
+| Limpar DNS, renovar IP | `ipconfig /flushdns`, `/release`, `/renew` | Baixo |
+| Resetar Winsock e pilha TCP/IP | `netsh winsock reset`, `netsh int ip reset` (exige reinício) | Médio |
+| Trocar DNS do adaptador | `SetDNSServerSearchOrder` (WMI) | Baixo |
+| Desativar Nagle na interface do jogo | Ver 5.8 | Baixo |
+
+**5.9.5 O que o app não corrige (e como orienta)**
+- **CGNAT**: mostrar o nome da operadora (via ASN do IP público, tabela estática dos principais ASNs BR) e um texto pronto pra copiar no chat de suporte pedindo IP público, além de sugerir IPv6 e, como paliativo, serviços de roteamento (ExitLag, WTFast, GearUP) com a ressalva de que custam por mês e não resolvem CGNAT em todo jogo.
+- **Roteador**: botão "Abrir configuração do roteador" (gateway em `http://` ou `https://`), lista das portas do jogo detectado e passo a passo por marca (TP-Link, Intelbras, Huawei, ZTE, Mercusys, Asus, D-Link) pra ligar UPnP, abrir portas ou DMZ pro IP do PC. Recomendar reservar IP fixo no DHCP antes de abrir porta.
+- **NAT duplo**: instruções de modo bridge por marca e aviso de que isso é feito no modem da operadora.
+
+**UI:** página Rede com três blocos: "Velocidade" (gráfico e histórico), "Posso jogar online?" (NAT com semáforo grande, lista de causas encontradas, botão "Corrigir o que é do Windows" e cartões de orientação pro resto) e "Ajustes" (DNS, firewall, tabela de portas).
+
+**Critérios de aceite:** classificação de NAT bate com o que o Xbox app / Call of Duty mostram na mesma rede; CGNAT detectado corretamente em conexão com IP 100.64.x.x; todas as correções revertem; nenhuma alteração de roteador é tentada além de UPnP com lease.
+
+### 5.10 Drivers de GPU
+
+- Detectar fabricante e versão (`Win32_VideoController.DriverVersion`, `DriverDate`) e traduzir para versão "de marketing" (NVIDIA: últimos 5 dígitos do DriverVersion → `5xx.xx`).
+- Comparar com versão mais recente conhecida via arquivo JSON estático atualizado a cada release do GameBoost e, se web permitida pelo usuário, endpoint oficial (NVIDIA tem API não documentada; AMD/Intel via página). Sem web: só "seu driver tem N meses".
+- **Nunca instalar driver.** Abrir a página oficial. Opcional: link para DDU com explicação de quando usar.
+
+### 5.11 Perfis por jogo
+
+- Perfil = `{ executavel, nome, acoes: [modo game on, plano energia X, prioridade Y, afinidade Z, tweaks por exe, apps a fechar, apps a reabrir], auto: bool }`.
+- Detecção via 5.1. Ao fechar o jogo, reverter automaticamente.
+- Biblioteca: varrer launchers para listar jogos instalados (Steam `libraryfolders.vdf` + `appmanifest_*.acf`; Epic `C:\ProgramData\Epic\EpicGamesLauncher\Data\Manifests\*.item`; GOG registry; Xbox `.GamingRoot`), mostrar tamanho e último jogado (para sugerir desinstalar jogos parados, que é onde estão os GB de verdade).
+
+### 5.12 Relatório de saúde e pontuação
+
+- Executa todas as varreduras em modo leitura e gera nota 0 a 100 por área (Desempenho, Espaço, Inicialização, Configuração para jogos) com os 5 principais `Findings`.
+- Exportar `relatorio.html` (para o usuário mandar para quem dá suporte) e `relatorio.json`.
+- `GameBoost.exe --report saida.html` na CLI.
+
+### 5.13 Ferramentas rápidas (atalhos de coisas que o usuário procura)
+
+- Reiniciar Explorer, reiniciar driver de vídeo (`Win+Ctrl+Shift+B` programático via `SendInput`), limpar cache DNS, esvaziar Lixeira, abrir Limpeza de Disco do Windows, criar ponto de restauração, verificar integridade (`sfc /scannow` e `DISM /RestoreHealth` com console embutido), teste de velocidade de disco (leitura/escrita sequencial 1 GB em arquivo temporário), informações do sistema (CPU, GPU, RAM canais/velocidade, discos e tipo, versão do Windows, BIOS) com botão copiar.
+
+---
+
+## 6. UI / UX
+
+- **Tema escuro padrão**, acento único (manter identidade atual do GameBoost). Fluent-like, sem gradientes exagerados.
+- **Navegação lateral** com ícones: Início (Modo Game + pontuação + findings), Diagnóstico, Limpeza, Espaço, Apps, Inicialização, Jogos (perfis), Tweaks, Rede, Ferramentas, Configurações.
+- **Padrão de tela de módulo:** cabeçalho com botão "Varrer" e resumo (ex.: "12,4 GB podem ser liberados"), lista de `ActionItem` agrupada por categoria com checkbox, badge de risco (verde/amarelo/vermelho), botão "?" que abre painel lateral com "O que faz / Risco / Como desfazer", rodapé fixo com "Aplicar N selecionados" e "Reverter".
+- **Tela de confirmação única e genérica** (reusar a do Modo Game) para tudo que altera o sistema.
+- **Histórico** (Configurações → Histórico): toda ação aplicada, com botão "Desfazer" individual enquanto a reversão for possível.
+- **Bandeja do sistema**: ícone com menu (Ativar Modo Game, Limpar RAM, Abrir, Sair). Opção "iniciar minimizado com o Windows" (desligada por padrão, e o GameBoost aparece na própria lista de inicialização, com honestidade).
+- **Acessibilidade**: fontes escaláveis, navegação por teclado, contraste AA.
+- **Onboarding** na primeira abertura: 3 telas explicando "reversível / sem telemetria / o que faz diferença de verdade" e oferecendo o Relatório de Saúde inicial.
+
+---
+
+## 7. Dados e persistência
+
+Tudo em `%LOCALAPPDATA%\GameBoost\`:
+
+| Arquivo | Conteúdo | Formato |
+|---|---|---|
+| `settings.json` | Preferências, tema, whitelist, essenciais, agendamentos, `schemaVersion` | JSON |
+| `profiles/*.json` | Um perfil por jogo | JSON |
+| `state-backup.json` | Pilha de `ChangeRecord { Id, Modulo, Tipo (Registry/Service/Power/File/Startup), Alvo, ValorAnterior, ValorNovo, Data, Revertido }` | JSON |
+| `session.json` | Sessão do Modo Game | JSON |
+| `history/*.json` | Histórico de ações por dia | JSON |
+| `cache/disk-scan-<volume>.bin` | Último resultado da varredura de disco (para abrir instantâneo) | Binário |
+| `gameboost.log` | Log texto rotacionado (5 MB × 5 arquivos) | Texto |
+| `backups/*.reg` | Export de chaves antes de remover restos | REG |
+
+Migração: ao abrir, se `schemaVersion` < atual, rodar migradores em sequência. Nunca apagar arquivo antigo, renomear para `.bak`.
+
+Modo portátil: se existir `portable.txt` ao lado do exe, usar `.\data\` em vez de `%LOCALAPPDATA%`.
+
+---
+
+## 8. CLI (`GameBoost.Cli` ou argumentos no exe principal)
+
+```
+GameBoost.exe --scan [arquivo]            # relatório de varredura do Modo Game (já existe)
+GameBoost.exe --report saida.html         # relatório de saúde completo
+GameBoost.exe --clean --preset seguro     # limpeza com preset (seguro | completo)
+GameBoost.exe --clean --categorias temp,wu,wer
+GameBoost.exe --revert-all                # reverte tudo do state-backup
+GameBoost.exe --gamemode on|off
+GameBoost.exe --dry-run                   # combina com qualquer comando, não altera nada
+```
+
+Saída em texto e `--json`.
+
+---
+
+## 9. Blindagem (documentar em `docs/PROTECAO.md`)
+
+Aplicada por `SafetyGuard` central, consultado por todos os módulos.
+
+- **Processos:** lista da v1 + anti-cheats (`EasyAntiCheat`, `BEService`, `vgc`, `vgtray` (Vanguard), `FACEIT`, `PnkBstr`, `XignCode`, `GameGuard`, `nProtect`, `Ricochet`, `EAAntiCheat`), launchers nunca pré-marcados, `RTSS`, `MSIAfterburner` (usuário pode querer), overlays de captura (aviso).
+- **Caminhos:** `C:\Windows` (exceto whitelist de limpeza), `Program Files*` (exceto via Desinstalador), pastas de usuário (`Documents`, `Pictures`, `Videos`, `Desktop`, `OneDrive`), qualquer pasta contendo `.git`, `saves`, `Saved Games`, `%APPDATA%` de jogos.
+- **Serviços:** núcleo do Windows, antivírus, `wuauserv` (só pausa), rede (`Dhcp`, `Dnscache`, `nsi`, `NlaSvc`), áudio (`Audiosrv`, `AudioEndpointBuilder`), `Themes`, `DcomLaunch`, `RpcSs`, `Winmgmt`, `EventLog`, `Schedule`, `TrustedInstaller`, `CryptSvc`, `BFE`, `mpssvc`.
+- **Registro:** nunca tocar em `HKLM\SYSTEM\CurrentControlSet\Services\*` além de `Start`, nunca em `Winlogon`, `Image File Execution Options`, `Policies`.
+- **Apps:** ver 5.3.
+- **Tweaks proibidos:** VBS/Core Isolation, mitigações de CPU, Defender, UAC, SmartScreen, assinatura de drivers.
+
+Teste obrigatório: `SafetyGuardTests` com casos para cada lista.
+
+---
+
+## 10. Build, distribuição e atualização
+
+- `dotnet publish -c Release -r win-x64 --self-contained -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true -p:PublishReadyToRun=true` (ReadyToRun reduz tempo de abertura).
+- Trimming: **não** habilitar (WPF e reflexão quebram).
+- Versão semântica em `Directory.Build.props`, propagada para Inno Setup.
+- **Assinatura de código (validado set/2026):**
+  - **Azure Artifact Signing** (ex-Trusted Signing, a partir de US$ 9,99/mês) é a opção barata da Microsoft, mas para **desenvolvedor individual só aceita EUA e Canadá**; organizações precisam estar em EUA/Canadá/UE/UK e outros poucos países. **Brasil está fora**, tanto PF quanto PJ. Não contar com isso.
+  - **Certificado OV** de uma CA (Certum, Sectigo, DigiCert, GlobalSign): caminho viável para o Brasil. Desde jun/2023 a chave privada precisa ficar em token USB ou HSM em nuvem (a CA fornece). Faixa de US$ 70 a 300/ano. Certum costuma ser a mais barata para dev individual.
+  - **EV não pula mais o SmartScreen** desde 2024: OV e EV passam pelo mesmo processo de reputação. Não vale pagar EV.
+  - **Microsoft Store (MSIX)**: a Microsoft reassina o pacote e o SmartScreen nunca aparece. Exige `runFullTrust` e o app precisa passar na certificação (o Modo Game e as ações de sistema podem gerar perguntas). Vale como meta de médio prazo.
+  - Independente da opção: reputação só acumula com downloads, então assinar sempre com a mesma identidade e submeter cada release ao Microsoft Security Intelligence para reduzir falsos positivos.
+- **Auto-update:** Velopack (sucessor do Squirrel, .NET moderno) apontando para GitHub Releases. Checar na abertura, baixar em background, aplicar no próximo início. Configurável. Sem web, apenas mostrar "versão X disponível" se o usuário clicar "Verificar".
+- **Portátil:** o mesmo exe publicado, zipado, com `portable.txt`.
+- **CI:** GitHub Actions `windows-latest`: build, testes, publish, Inno Setup, anexar ao Release. Gerar `SHA256SUMS.txt`.
+- **Instalador:** manter Inno Setup. Adicionar página de opções: atalho na bandeja ao iniciar, associar tarefa de limpeza semanal (desligada por padrão), instalar para todos os usuários vs. só atual.
+
+---
+
+## 11. Testes
+
+- **Unit (xUnit):** `SafetyGuard`, `RollbackEngine` (aplicar → reverter → estado igual), parsers (registro Uninstall, `libraryfolders.vdf`, UserAssist ROT13, versão de driver NVIDIA), regras de `Bottleneck` (dado um snapshot de métricas, gera os Findings esperados), whitelist do Cleaner (todo caminho gerado pertence à whitelist).
+- **Integração (rodam só em Windows, tag `[Trait("Category","Windows")]`):** limpeza real em pasta temp sintética; leitura de MFT em volume real (só leitura); desinstalação de um MSI de teste (criar com WiX ou usar `msiexec` em pacote conhecido); startup toggle em chave `HKCU` fake.
+- **Manual (checklist em `docs/QA.md`):** SmartScreen, antivírus, máquina com 8 GB, notebook com iGPU + dGPU, usuário sem admin, Windows 10 22H2 e Windows 11 24H2+, disco FAT32 externo, jogo com Vanguard rodando (nada pode ser fechado).
+- **Dry-run** em todos os módulos: `--dry-run` produz o mesmo relatório sem tocar em nada; teste garante que `IFileSystem`/`IRegistry` fakes não recebem chamadas de escrita.
+
+---
+
+## 12. Fases de implementação (ordem obrigatória)
+
+Cada fase: branch própria, PR, changelog em `CHANGELOG.md`.
+
+### Fase 0 · Fundação (refatorar sem mudar comportamento)
+- Separar `GameBoost.Core` (sem WPF) de `GameBoost.App`.
+- Extrair `SafetyGuard`, `RollbackEngine`, `Logger`, `Settings` com `schemaVersion`.
+- Criar `IModule` / `ActionItem` e portar o Modo Game para esse contrato.
+- Criar a tela genérica de lista de `ActionItem` + confirmação.
+- Configurar DI, CommunityToolkit.Mvvm, xUnit, GitHub Actions.
+- Gerar `CLAUDE.md` com a seção 2 e o mapa de pastas.
+- **Pronto quando:** app faz exatamente o que a v1 fazia, com testes de `SafetyGuard` e `RollbackEngine` passando.
+
+### Fase 1 · Diagnóstico de gargalos (5.5) + Relatório (5.12)
+Motivo: é o que faz o usuário abrir o app todo dia e entender o valor do resto.
+
+### Fase 2 · Limpeza (5.2) + Ferramentas rápidas (5.13)
+
+### Fase 3 · Analisador de disco (5.4) + Biblioteca de jogos (parte de 5.11)
+
+### Fase 4 · Desinstalador (5.3) + Inicialização (5.6)
+
+### Fase 5 · Tweaks (5.8) + Serviços (5.7) + Rede completa com NAT (5.9) + Drivers (5.10)
+
+### Fase 6 · Perfis por jogo com detecção automática (5.1 + 5.11), bandeja, onboarding
+
+### Fase 7 · Distribuição: Velopack, CI completo, portátil, assinatura, submissão de falsos positivos
+
+### Backlog (depois da v2.0)
+- Overlay de FPS in-game (integração com RTSS via shared memory, ou hook próprio em D3D11/12, que é trabalho grande e risco com anti-cheat; preferir RTSS).
+- Duplicados e arquivos grandes esquecidos com sugestão de compressão NTFS (`compact /c /exe:xpress8k` em pastas de jogos, que economiza 20 a 40% sem perda de FPS em SSD).
+- Curva de ventoinha (fora de escopo, depende de hardware).
+- Versão EN e loja Microsoft Store (MSIX com `runFullTrust`).
+- Benchmark rápido antes/depois (rodar 30 s de carga sintética e comparar) para provar ganho.
+
+---
+
+## 13. Prompts sugeridos para o Claude Code (um por fase)
+
+**Fase 0**
+> Leia `GAMEBOOST_V2_SPEC.md` inteiro. Execute a Fase 0: refatore o projeto para a estrutura da seção 4.1 sem alterar nenhum comportamento visível. Crie `SafetyGuard`, `RollbackEngine`, `Logger` e `Settings` conforme seções 2, 7 e 9. Porte o Modo Game para `IModule`/`ActionItem`. Adicione xUnit com testes para `SafetyGuard` e `RollbackEngine`. Gere `CLAUDE.md` com as regras da seção 2. Ao final, `dotnet build` e `dotnet test` limpos, e liste em `docs/DECISOES.md` qualquer desvio.
+
+**Fase 1**
+> Implemente o módulo `Bottleneck` (seção 5.5) e `HealthReport` (5.12). Coleta a cada 1 s com buffer de 5 min, contadores de CPU/GPU/RAM/disco/rede, LibreHardwareMonitorLib opcional para temperaturas. Implemente todas as regras de diagnóstico da tabela como classes `IFindingRule` testáveis. Tela com 5 medidores, gráfico de 60 s, top 10 processos e lista de Findings. Exporte `relatorio.html`. Meça e garanta < 1,5% CPU.
+
+**Fases seguintes:** mesmo padrão: "Implemente o módulo X conforme seção 5.Y, respeitando seções 2 e 9, com testes das regras, dry-run funcional e entrada no `docs/TWEAKS.md` ou `docs/PROTECAO.md` quando aplicável."
+
+---
+
+## 14. Glossário rápido (para textos da UI)
+
+- **Standby List:** memória que o Windows guarda "por precaução" com dados já usados. Liberar ajuda quando falta RAM, não aumenta FPS por si só.
+- **Shader cache:** arquivos que o jogo gera para não recompilar efeitos. Apagar libera espaço, mas o jogo engasga nas primeiras horas até recriar.
+- **HAGS:** deixa a placa de vídeo gerenciar a própria fila de trabalho. Ajuda em alguns casos, atrapalha em outros. Teste com e sem.
+- **Throttling:** o processador reduz a velocidade para não superaquecer. Sinal de cooler sujo ou pasta térmica velha.
+- **Gargalo de CPU:** o processador não consegue preparar quadros rápido o suficiente; a placa de vídeo fica esperando.
+
+---
+
+*Documento gerado em 13/09/2026 para o projeto GameBoost, com pesquisa de mercado validada por fontes web na mesma data. Autor do produto: Jonathan Vaz.*
diff --git a/GameBoost/GameBoost.sln b/GameBoost/GameBoost.sln
new file mode 100644
index 0000000..7731860
--- /dev/null
+++ b/GameBoost/GameBoost.sln
@@ -0,0 +1,84 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Core", "src\GameBoost.Core\GameBoost.Core.csproj", "{67F62495-3B0A-4309-BC87-D97EABE2D2A7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Cli", "src\GameBoost.Cli\GameBoost.Cli.csproj", "{94138042-896D-4F31-BAED-E287520B18A7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.Tests", "src\GameBoost.Tests\GameBoost.Tests.csproj", "{984E3716-662D-4E8C-8B6F-B81C33CDF790}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameBoost.App", "src\GameBoost.App\GameBoost.App.csproj", "{CAF682AC-B64C-483C-9C80-533990BC4F24}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x64.Build.0 = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Debug|x86.Build.0 = Debug|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x64.ActiveCfg = Release|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x64.Build.0 = Release|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x86.ActiveCfg = Release|Any CPU
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7}.Release|x86.Build.0 = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|x64.Build.0 = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Debug|x86.Build.0 = Debug|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|x64.ActiveCfg = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|x64.Build.0 = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|x86.ActiveCfg = Release|Any CPU
+		{94138042-896D-4F31-BAED-E287520B18A7}.Release|x86.Build.0 = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x64.Build.0 = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Debug|x86.Build.0 = Debug|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|Any CPU.Build.0 = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x64.ActiveCfg = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x64.Build.0 = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x86.ActiveCfg = Release|Any CPU
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790}.Release|x86.Build.0 = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x64.Build.0 = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Debug|x86.Build.0 = Debug|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x64.ActiveCfg = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x64.Build.0 = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x86.ActiveCfg = Release|Any CPU
+		{CAF682AC-B64C-483C-9C80-533990BC4F24}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{67F62495-3B0A-4309-BC87-D97EABE2D2A7} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
+		{94138042-896D-4F31-BAED-E287520B18A7} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
+		{984E3716-662D-4E8C-8B6F-B81C33CDF790} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
+		{CAF682AC-B64C-483C-9C80-533990BC4F24} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
+	EndGlobalSection
+EndGlobal
diff --git a/GameBoost/README.md b/GameBoost/README.md
new file mode 100644
index 0000000..f96a1a1
--- /dev/null
+++ b/GameBoost/README.md
@@ -0,0 +1,199 @@
+# GameBoost
+
+**O booster que mostra o que faz e desfaz tudo.**
+
+Central de otimização e manutenção para PC gamer no Windows 10 e 11. Sem anúncio, sem conta,
+sem telemetria, sem assinatura. PT-BR nativo.
+
+> **Estado:** v2.0.0 em desenvolvimento — Fases 0 a 3 concluídas.
+> Modo Game, diagnóstico, relatório de saúde, limpeza, ferramentas rápidas e analisador de
+> espaço funcionais; os demais módulos chegam nas fases seguintes.
+
+---
+
+## O que faz hoje
+
+**Modo Game.** Encerra os aplicativos que você confirmar, libera memória, aplica o plano de
+energia de alto desempenho, sobe a prioridade do jogo e silencia notificações, gravação em
+segundo plano e Windows Update. Ao desligar, devolve tudo ao estado anterior e reabre os
+apps marcados com ★.
+
+Três coisas que ele não faz, por princípio:
+
+- **Não fecha o jogo nem o anti-cheat.** Vanguard, EasyAntiCheat, BattlEye e companhia nem
+  aparecem selecionáveis.
+- **Não mata nada sem pedir.** Todo app recebe primeiro o pedido de fechamento normal, com
+  3 segundos para salvar. A tela de confirmação aparece antes de qualquer coisa ser fechada.
+- **Não inventa número.** O ganho mostrado é o medido: RAM livre antes e depois, apps
+  fechados, alterações aplicadas.
+
+**Diagnóstico de gargalos.** Cinco medidores ao vivo (CPU, GPU, memória, disco, rede) com
+gráfico dos últimos 60 segundos, os 10 processos que mais consomem, e uma lista de achados
+em português claro: *"Chrome está usando 38% da CPU"*, *"seu monitor de 165 Hz está em
+60 Hz"*, *"a atualização 26H2 desfez 4 ajustes seus"*. A coleta custa 0,1% de CPU.
+
+**Relatório de saúde.** Nota de 0 a 100 por área (Desempenho, Espaço, Inicialização,
+Configuração para jogos) com os cinco principais achados, exportável como página HTML única
+para mandar a quem dá suporte.
+
+**Limpeza.** Vinte alvos, do `%TEMP%` ao shader cache, cada um mostrando quanto ocupa e
+qual o efeito colateral antes de você marcar. Arquivos seus vão para a Lixeira; navegador
+aberto bloqueia o próprio cache; `Downloads` só é listado, nunca tocado.
+
+**Ferramentas rápidas.** Reiniciar o Explorer ou o driver de vídeo, limpar o cache de DNS,
+criar ponto de restauração, rodar `sfc` e `DISM` com a saída ao vivo, medir a velocidade do
+disco e copiar as informações do sistema para mandar a quem dá suporte.
+
+**Onde está o seu espaço.** Varre o disco inteiro em cerca de 20 segundos e mostra num
+treemap onde foram parar os GB. Lista os 100 maiores arquivos, as 50 maiores pastas e a sua
+biblioteca de jogos — com o tamanho de cada um e quando você jogou pela última vez. Explica o
+que são `hiberfil.sys` e `pagefile.sys` em vez de só mostrar o tamanho. Não apaga nada: abre
+no Explorer ou manda para a Lixeira, com confirmação.
+
+**Aplicativos instalados.** Lista tudo que está instalado — registro, Microsoft Store e o
+que o Windows registra de uso — com o tamanho medido de verdade, não o declarado no
+registro, e quando você usou pela última vez. Desinstala em lote, sempre chamando o
+desinstalador do próprio app, e depois procura o que ficou para trás. Uma aba à parte varre
+`%APPDATA%`, `%LOCALAPPDATA%` e `%PROGRAMDATA%` atrás de pastas de programas que você já
+desinstalou. Runtimes, drivers e antivírus aparecem bloqueados, com o motivo. **Nada vem
+marcado** — nem o bloatware mais óbvio, nem o resto mais antigo.
+
+**Atualizações.** Uma aba da mesma tela mostra o que tem versão nova, em cima do winget,
+o gerenciador de pacotes da própria Microsoft — quem baixa e confere assinatura é ela, não
+o GameBoost. Navegador, compactador e Java desatualizados aparecem marcados como
+**atualização de segurança**, porque neles ficar para trás não é questão de conforto.
+Driver aparece bloqueado: o GameBoost não instala driver, nem pelo winget. O que se
+atualiza sozinho (Steam, Discord, navegadores) vem com a tag e a explicação de por que
+forçar pode brigar com o atualizador do próprio app.
+
+**O que abre com o Windows.** Chaves `Run`, pastas Inicializar e o estado real de cada item,
+lido de onde o Gerenciador de Tarefas lê. Mostra o fabricante, se o executável é assinado e
+uma estimativa grosseira do peso no boot — declarada como grosseira, porque vem do tamanho
+do arquivo e não de medição. Desativar grava exatamente o mesmo formato do Gerenciador de
+Tarefas, e dá para reverter aqui, lá ou os dois.
+
+**Ajustes do Windows.** Doze tweaks de jogo e doze serviços do Windows na mesma lista, cada
+um com o efeito real escrito sem promessa: quando um ajuste é marginal, está escrito que é
+marginal. O isolamento de núcleo aparece explicado e **não** é alterado — essa escolha é
+sua, na tela da Microsoft. SysMain, os serviços do Xbox e o Windows Update aparecem
+bloqueados para explicar por que toda lista de otimização da internet erra ao mandar
+desligar. Nada vem marcado, nem o que o próprio GameBoost recomenda.
+
+**Rede.** Responde duas perguntas: "minha internet está boa pra jogar?" e "por que eu não
+entro na partida do meu amigo?". Mede latência, jitter e perda, compara o seu DNS com
+Cloudflare, Google e Quad9, e descobre o tipo do seu NAT com um cliente STUN próprio —
+aberto, moderado ou estrito, no mesmo vocabulário que o jogo usa. Quando é estrito, diz
+**por quê**: CGNAT da operadora, dois roteadores em série, UPnP desligado, Teredo
+desativado ou firewall. Corrige o que é do Windows, com desfazer, e para o resto abre
+[docs/PORTAS.md](docs/PORTAS.md) com as portas de cada jogo e onde fica cada coisa em sete
+marcas de roteador. O teste de velocidade é um botão à parte e desligado por padrão, porque
+gasta 100 MB da sua franquia.
+
+**Perfis por jogo.** O GameBoost reconhece quando um jogo abre e pergunta se quer ativar o
+Modo Game para ele. Cada jogo pode ter o seu perfil — prioridade, núcleos, tweaks, apps a
+fechar — aplicado ao entrar e **desfeito ao sair**, sem exceção. Perfil novo nunca ativa
+sozinho: só passa a agir sem perguntar quem você marcar como automático.
+
+**Bandeja e primeira abertura.** Ícone ao lado do relógio com Ativar Modo Game, Limpar RAM,
+Abrir e Sair. Fechar a janela esconde na bandeja, e ele avisa isso na primeira vez —
+programa que some sem dizer para onde foi é o motivo de as pessoas irem no Gerenciador de
+Tarefas. Na primeira abertura, três telas explicando o contrato: tudo é reversível, nada
+sai daqui, e o que faz diferença de verdade.
+
+## Como instalar
+
+| Arquivo | Para quem |
+|---|---|
+| `GameBoost-Setup-*.exe` | A maioria. Instala, cria atalho e habilita a atualização automática |
+| `GameBoost-*-portatil.zip` | Pen drive ou máquina de terceiro. Guarda os dados ao lado do executável e não se atualiza sozinho |
+| `SHA256SUMS.txt` | Conferir que o download veio inteiro |
+
+O instalador pergunta se quer instalar para todos os usuários ou só para você, e
+oferece — desmarcados — o atalho na área de trabalho, iniciar com o Windows
+minimizado na bandeja, e uma limpeza semanal agendada.
+
+Se o SmartScreen avisar, é porque esta versão pode não estar assinada: **Mais
+informações → Executar assim mesmo**. O porquê está em
+[docs/ASSINATURA.md](docs/ASSINATURA.md), junto com o que foi apurado sobre
+certificado de código para quem está no Brasil.
+
+---
+
+## Reversibilidade
+
+Antes de alterar qualquer coisa, o GameBoost grava o valor anterior em
+`state-backup.json`. Isso vale para registro, serviços e plano de energia.
+
+- O botão **Reverter tudo** está sempre visível.
+- Se o app travar ou o PC reiniciar com o Modo Game ativo, a próxima abertura avisa e
+  oferece a restauração.
+- O desinstalador roda a reversão antes de remover o app.
+
+Sem isso, um travamento com o Windows Update pausado deixaria a máquina sem atualizações
+indefinidamente.
+
+---
+
+## Linha de comando
+
+```
+GameBoost.exe                          abre a interface
+GameBoost.exe --scan [arquivo]         relatório de varredura, não encerra nada
+GameBoost.exe --report saida.html      relatório de saúde completo (HTML ou JSON)
+GameBoost.exe --clean --preset seguro  limpeza                            (Fase 2)
+GameBoost.exe --revert-all             reverte tudo do state-backup
+GameBoost.exe --gamemode on|off        liga ou desliga o Modo Game
+```
+
+Modificadores: `--dry-run` (combina com qualquer comando, não altera nada), `--json`,
+`--help`.
+
+## Onde ficam os dados
+
+`%LOCALAPPDATA%\GameBoost\` — `settings.json`, `session.json`, `state-backup.json`,
+`gameboost.log` (rotacionado, 5 MB × 5).
+
+**Modo portátil:** criando um `portable.txt` ao lado do executável, tudo passa a ficar em
+`.\data\`.
+
+---
+
+## Compilar
+
+Requisitos: .NET 9 SDK e, para o instalador, Inno Setup 6.
+
+```powershell
+dotnet build GameBoost.sln
+dotnet test  GameBoost.sln
+
+# Executável final (self-contained, arquivo único)
+dotnet publish src\GameBoost.App\GameBoost.App.csproj -c Release -o publish
+
+# Instalador
+& "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe" installer\GameBoost.iss
+```
+
+O app exige privilégios de administrador (encerrar processos, controlar serviços e purgar a
+Standby List). Sem elevação ele abre em modo somente leitura: as varreduras funcionam e as
+ações ficam desabilitadas.
+
+## Avisos conhecidos
+
+- **SmartScreen.** O instalador ainda não é assinado. Ver seção 10 do spec para o caminho de
+  assinatura (certificado OV; Azure Artifact Signing não atende o Brasil).
+- **Antivírus.** Encerrar processos e elevar privilégios é o mesmo comportamento que um
+  malware teria — alguns antivírus reclamam de qualquer booster.
+
+## Documentação
+
+| Arquivo | Conteúdo |
+|---|---|
+| [CLAUDE.md](CLAUDE.md) | Regras obrigatórias para código novo |
+| [docs/PROTECAO.md](docs/PROTECAO.md) | Listas de blindagem, documentadas |
+| [docs/TWEAKS.md](docs/TWEAKS.md) | Catálogo de tweaks com efeito real e risco |
+| [docs/DECISOES.md](docs/DECISOES.md) | Decisões que fugiram do spec, com motivo |
+| [docs/QA.md](docs/QA.md) | Checklist de teste manual |
+
+---
+
+Autor: Jonathan Vaz.
diff --git a/GameBoost/docs/ASSINATURA.md b/GameBoost/docs/ASSINATURA.md
new file mode 100644
index 0000000..c621e89
--- /dev/null
+++ b/GameBoost/docs/ASSINATURA.md
@@ -0,0 +1,115 @@
+# Assinatura de código e falso positivo
+
+O que foi apurado em setembro de 2026 sobre assinar o GameBoost, e o que fazer
+enquanto ele não está assinado.
+
+Isto importa mais para este programa do que para a média. Um app que encerra
+processos, mexe no registro, altera serviços e purga a Standby List tem o perfil
+de comportamento que antivírus heurístico marca. Sem assinatura, o SmartScreen
+avisa no primeiro download e uma parte das pessoas desiste ali.
+
+---
+
+## As opções, e por que a escolha é essa
+
+### Azure Artifact Signing (ex-Trusted Signing) — **fora do Brasil**
+
+É a opção barata da Microsoft, a partir de US$ 9,99/mês, e seria a escolha óbvia
+se desse.
+
+Não dá. Para **desenvolvedor individual** a Microsoft só aceita Estados Unidos e
+Canadá. Para **organização**, a lista é maior — EUA, Canadá, União Europeia,
+Reino Unido e mais alguns — e **o Brasil não está nela**, nem como pessoa física
+nem como jurídica.
+
+Não é questão de preço nem de burocracia: é elegibilidade geográfica. Não vale
+gastar tempo tentando.
+
+### Certificado OV de uma CA — **o caminho viável**
+
+Certum, Sectigo, DigiCert, GlobalSign. Faixa de US$ 70 a 300 por ano; a Certum
+costuma ser a mais barata para desenvolvedor individual.
+
+Desde junho de 2023 a chave privada **não pode mais ficar num arquivo `.pfx` no
+seu disco**: ela tem que morar em token USB ou HSM em nuvem, e a CA fornece um
+dos dois. Isso muda o CI — assinar deixa de ser "coloca o segredo e roda" e passa
+a exigir ou um runner com o token plugado, ou a API do HSM da CA.
+
+O `gameboost-release.yml` tem o passo de assinatura preparado para o caso `.pfx`,
+que serve para HSM em nuvem com credencial exportável e para certificado de teste.
+Para token USB físico, o passo precisa ser trocado pelo cliente da CA.
+
+### EV — **não vale mais a pena**
+
+Até 2024 o certificado EV pulava o SmartScreen na hora. **Não pula mais.** Desde
+então OV e EV passam pelo mesmo processo de reputação, e a diferença de preço
+deixou de comprar alguma coisa.
+
+Se alguém sugerir EV "porque tira o aviso", essa informação está desatualizada.
+
+### Microsoft Store (MSIX) — **meta de médio prazo**
+
+A Microsoft reassina o pacote, e o SmartScreen nunca aparece. É o caminho mais
+limpo do ponto de vista do usuário.
+
+Custa passar na certificação, e este app tem tudo para gerar pergunta: o Modo
+Game encerra processos de terceiros, o desinstalador roda executáveis de
+terceiros, e vários módulos escrevem em `HKLM`. Precisa de `runFullTrust`, e
+ainda assim pode receber pedido de justificativa.
+
+Vale tentar depois que a v2 estiver estável, não antes.
+
+---
+
+## Reputação: o que realmente tira o aviso
+
+Assinar não zera o SmartScreen. O que zera é **reputação acumulada**, e ela
+depende de duas coisas:
+
+1. **Sempre a mesma identidade.** Trocar de certificado ou de nome de publicador
+   reinicia a contagem. Se um dia o certificado for renovado, renovar com a mesma
+   entidade, não com outra.
+2. **Volume de downloads sem incidente.** Não há atalho. É tempo.
+
+---
+
+## Submeter falso positivo
+
+Quando um antivírus marcar o GameBoost, o caminho é submeter a amostra, não pedir
+ao usuário para desativar a proteção.
+
+**Microsoft Defender** — [microsoft.com/wdsi/filesubmission](https://www.microsoft.com/en-us/wdsi/filesubmission)
+
+Escolher "Software developer", anexar o `.exe`, e no campo de justificativa
+descrever o que o programa faz e por quê. Vale citar, especificamente:
+
+- Ele encerra processos porque é um otimizador de jogos e essa é a função
+  principal, sempre com confirmação do usuário.
+- Ele grava em `HKLM\SYSTEM\CurrentControlSet\Control\GraphicsDrivers` e chaves
+  vizinhas porque aplica ajustes documentados pela própria Microsoft.
+- Ele chama `NtSetSystemInformation` para purgar a Standby List.
+- Todo o código está aberto em `github.com/jvaz-DEVENG/showcase`.
+
+A resposta costuma vir em 24 a 72 horas.
+
+**Outros antivírus** — cada um tem o próprio formulário. Os mais comuns em
+máquina brasileira, em ordem de aparição: Kaspersky, Avast/AVG, Bitdefender,
+McAfee, Norton. Todos aceitam submissão de desenvolvedor.
+
+**Depois de cada release**, submeter de novo: a assinatura muda a cada build, e o
+hash novo não herda a liberação do anterior.
+
+---
+
+## O que o usuário vê hoje
+
+Sem certificado, no primeiro download:
+
+> O Windows protegeu o computador.
+> O Microsoft Defender SmartScreen impediu a inicialização de um aplicativo não
+> reconhecido.
+
+Para rodar mesmo assim: **Mais informações → Executar assim mesmo**.
+
+O `SHA256SUMS.txt` sai em toda release justamente para isso: quem quiser conferir
+que baixou o arquivo certo tem como, sem depender de assinatura nenhuma.
diff --git a/GameBoost/docs/DECISOES.md b/GameBoost/docs/DECISOES.md
new file mode 100644
index 0000000..70e766d
--- /dev/null
+++ b/GameBoost/docs/DECISOES.md
@@ -0,0 +1,769 @@
+# Decisões de projeto
+
+Registro de toda decisão que fugiu do `GAMEBOOST_V2_SPEC.md`, com data e motivo.
+
+---
+
+## 2026-09-13 — A Fase 0 virou reconstrução, não refatoração
+
+**Contexto.** A Fase 0 do spec diz "refatore o projeto para a estrutura da seção 4.1 **sem
+alterar nenhum comportamento visível**". Isso pressupõe o código-fonte da v1.0.0.
+
+**O que existia.** Apenas o binário: `GameBoost.rar` com `GameBoost.exe` (68 MB,
+self-contained, compilado em 03/09/2026), `LEIA-ME.txt` e o desinstalador Inno. Nenhum
+`.csproj`, `.sln`, `.iss` ou repositório git da v1 em nenhum disco da máquina.
+
+**Decisão.** Reconstruir a v1 do zero já dentro da arquitetura alvo da seção 4.1, usando o
+`LEIA-ME.txt` da v1 e a seção 1 do spec como especificação do comportamento a reproduzir.
+
+**Consequência.** Não há garantia de paridade byte-a-byte com a v1 — só de paridade
+funcional com o que estava documentado. O checklist de QA (`docs/QA.md`) lista o que precisa
+ser validado à mão contra o binário antigo.
+
+---
+
+## 2026-09-13 — CLI é biblioteca, não executável separado
+
+**Spec.** A seção 4.1 lista `GameBoost.Cli/` como projeto; a seção 8 diz
+"`GameBoost.Cli` ou argumentos no exe principal".
+
+**Decisão.** `GameBoost.Cli` é uma **biblioteca** (`CommandLineOptions` + `CommandRunner`)
+consumida pelo `GameBoost.App`. O `App.OnStartup` faz o parse dos argumentos e, se for um
+comando de linha, anexa ao console do processo pai (`AttachConsole(-1)`), executa e sai.
+
+**Motivo.** A v1 expunha `GameBoost.exe --scan relatorio.txt`. Dois executáveis quebrariam
+esse contrato, dobrariam o tamanho do publish self-contained e obrigariam o instalador a
+distribuir os dois. Uma biblioteca preserva o comando da v1 e ainda deixa a lógica testável
+sem levantar processo.
+
+---
+
+## 2026-09-13 — `AppSettings.SchemaVersion` começa em 0, não na versão atual
+
+**Decisão.** O inicializador do campo foi removido; a propriedade começa em `0` e o
+`SettingsStore.Save` carimba `VersaoAtual` na gravação.
+
+**Motivo.** Com `= VersaoAtual` no campo, um `settings.json` da v1 — que não gravava
+`schemaVersion` — desserializava como se já fosse da versão corrente, e o migrador **nunca
+rodava**. O bug foi pego pelo teste
+`Settings_da_v1_sem_schema_version_e_migrado_e_o_original_vira_bak`.
+
+---
+
+## 2026-09-13 — Prioridade do jogo não gera ChangeRecord
+
+**Decisão.** Subir a prioridade do processo do jogo para Alta é registrado no log, mas não
+gera entrada em `state-backup.json`.
+
+**Motivo.** Prioridade de processo é estado volátil: morre junto com o processo e não
+sobrevive a reboot. Um `ChangeRecord` pendente apontando para um PID que não existe mais só
+poluiria a lista de reversão. A regra 1 continua valendo para tudo que **persiste**
+(registro, serviço, plano de energia).
+
+---
+
+## 2026-09-13 — Processos críticos não aparecem na lista da UI
+
+**Spec.** A seção 4.2 prevê itens protegidos aparecendo bloqueados, não selecionáveis.
+
+**Decisão.** Itens protegidos por `ProcessoCritico`, `DentroDoWindows`, `OutraSessao` e
+`ProprioApp` são **omitidos** da lista. Anti-cheats e antivírus **aparecem**, bloqueados,
+com a explicação.
+
+**Motivo.** Incluir todos encheria a tela com dezenas de `svchost` que o usuário nunca deve
+tocar, escondendo o que importa. Anti-cheat e antivírus continuam visíveis de propósito: é
+informação útil ("o Vanguard está rodando"), e ver que o app se recusa a tocar neles é o que
+constrói confiança.
+
+---
+
+## 2026-09-13 — Escrita de arquivo com retry na troca atômica
+
+**Decisão.** `WindowsFileSystem.WriteAllText` grava `.tmp` e faz `File.Move(overwrite)` com
+até 5 tentativas e espera progressiva.
+
+**Motivo.** O antivírus desta máquina segura o handle do `.tmp` por alguns milissegundos
+depois da escrita, fazendo a troca atômica falhar com `IOException` de forma intermitente.
+Sem o retry, `state-backup.json` poderia não ser gravado exatamente no momento mais crítico:
+logo antes de alterar o sistema.
+
+---
+
+## 2026-09-13 — ReadyToRun dobra o tamanho do executável
+
+**Medido.** O publish self-contained single-file da v2 saiu com **138 MB**, contra 68 MB do
+`GameBoost.exe` da v1.0.0.
+
+**Causa.** `PublishReadyToRun=true`, pedido pela seção 10 do spec para reduzir o tempo de
+abertura. Ele embute código nativo pré-compilado junto do IL.
+
+**Decisão.** Manter ligado, como o spec pede, e medir o tempo de abertura com e sem antes de
+decidir de vez. Trimming continua proibido (quebra WPF), então não há como recuperar o
+tamanho por esse caminho.
+
+**A conferir na Fase 7:** se o ganho de abertura não justificar +70 MB de download, desligar
+ReadyToRun é a alternativa óbvia — o instalador comprimido sofre menos com isso que o
+download do portátil.
+
+---
+
+## 2026-09-13 — Fase 1: nada de PerformanceCounter por nome traduzido
+
+**Problema.** A seção 5.5 sugere contadores como `\Processor Information(_Total)\% Processor Performance`.
+Num Windows **pt-BR esse contador não existe** — chama-se "Informações do Processador".
+`PerformanceCounter` exige o nome no idioma do sistema, então o código do spec falharia
+nesta máquina e em qualquer Windows não-inglês.
+
+**Decisão.** Onde há API nativa, usar API nativa: `NtQuerySystemInformation` para CPU,
+Standby List e processos; `GlobalMemoryStatusEx` para memória; `DriveInfo` para disco;
+`System.Net.NetworkInformation` para rede. Todas devolvem números, não texto.
+
+Para GPU não existe equivalente público, então ali se usa PDH — mas via
+`PdhAddEnglishCounter`, que aceita o nome em inglês em qualquer idioma.
+
+---
+
+## 2026-09-13 — A coleta custava 5% de CPU; três correções a levaram a 0,1%
+
+O critério de aceite da seção 5.5 é **menos de 1,5% de CPU**. A primeira versão media
+**5,02%**, com ciclo de **1039 ms** — mais lenta que o próprio intervalo de coleta.
+
+| O que estava errado | Correção | Resultado |
+|---|---|---|
+| Um `PerformanceCounter` por instância de GPU; cada `NextValue()` é uma consulta separada | Uma consulta PDH com curinga cobre todas as instâncias de uma vez | ciclo 1039 ms → 36 ms |
+| `Process.GetProcesses()` + `TotalProcessorTime` abria um handle por processo, ~400 vezes por segundo | `NtQuerySystemInformation(SystemProcessInformation)`: tudo numa chamada, sem handle | — |
+| Detecção de jogo chamava WMI `Win32_Process` a cada 10 s | Detecta pelo nome nos processos que a coleta já leu | — |
+| Interfaces de rede reenumeradas a cada segundo | Lista revalidada a cada 30 s | — |
+
+**Medição final:** 0,115% de CPU, ciclo de 36 ms, app inteiro em 0,61%.
+
+### A medição do custo também estava errada
+
+O primeiro cálculo usava `Stopwatch`, que mede **tempo de parede**: um ciclo parado
+esperando WMI parecia caro sem ter gasto CPU. Foi trocado por `GetThreadTimes`, que mede o
+tempo de CPU realmente consumido.
+
+Isso exigiu tirar o laço do `Task.Delay`: com `await`, a continuação volta em **outra**
+thread do pool e a medição compara threads diferentes. O monitor passou a usar uma thread
+dedicada, com prioridade abaixo do normal — o que também garante que ele ceda lugar ao jogo.
+
+Medir errado o próprio custo é exatamente o tipo de número inventado que a regra 4 proíbe.
+
+---
+
+## 2026-09-13 — Temperaturas ficam indisponíveis nesta fase
+
+**Spec.** A seção 5.5 pede LibreHardwareMonitorLib para temperaturas de CPU e GPU.
+
+**Decisão.** A Fase 1 usa apenas WMI `MSAcpi_ThermalZoneTemperature`, que nesta máquina
+responde "Sem suporte". A UI mostra **"indisponível"**, nunca zero.
+
+**Motivo.** LibreHardwareMonitorLib carrega um driver em modo kernel para ler os sensores.
+Isso é uma decisão de segurança e de distribuição (assinatura, antivírus, SmartScreen) grande
+demais para entrar junto com o resto da Fase 1. A regra de throttling térmico já está escrita
+e testada: ela simplesmente não dispara enquanto não houver leitura.
+
+---
+
+## 2026-09-13 — `AoEntrar` no binding, não no comando de navegação
+
+O menu lateral troca de página pelo binding de `SelectedItem`, que **nunca passa pelo
+comando** `Navegar`. Com o gancho no comando, o Diagnóstico não começava a coletar e o
+Histórico não recarregava. O gancho foi para `OnPaginaAtualChanged`, que roda em qualquer
+caminho de navegação. Descoberto porque o log não registrava o início da coleta.
+
+---
+
+## 2026-09-13 — Fase 3: sem leitura crua da MFT, e não foi preciso
+
+**Spec.** A seção 5.4 pede leitura da MFT via `FSCTL_ENUM_USN_DATA`, com o critério de
+**500 GB e 1 milhão de arquivos em menos de 30 s**.
+
+**Problema com o caminho sugerido.** `FSCTL_ENUM_USN_DATA` devolve `USN_RECORD`, que traz
+nome, referência do pai e atributos — mas **não traz o tamanho do arquivo**. Para os
+tamanhos seria preciso parsear os registros da MFT crus, lendo os atributos `$DATA` a mão. É
+o que o WizTree faz, e é bem mais trabalho e risco do que a seção sugere.
+
+**Decisão.** A alternativa que o próprio spec autoriza: `FindFirstFileEx` com
+`FIND_FIRST_EX_LARGE_FETCH` e `FindExInfoBasic`, paralelizado por subárvore com uma fila de
+trabalho. O tamanho já vem no resultado da enumeração, sem uma chamada extra por arquivo.
+
+**Medido nesta máquina** (disco do sistema, NVMe de 953 GB):
+
+```
+1.548.745 arquivos, 809,5 GB somados, em 20,3 s
+```
+
+**Um milhão e meio de arquivos e 809 GB em 20 s** — acima do volume do critério e abaixo do
+tempo. A MFT crua fica para quando houver uma máquina onde isto não seja suficiente.
+
+### O contador de pastas inacessíveis estava mentindo
+
+A primeira versão contava **40.871 pastas "sem acesso"**. O número real é **543**: eu estava
+contando toda pasta vazia como inacessível, porque `FindFirstFileEx` devolve lista vazia nos
+dois casos. Agora o código separa pelos códigos de erro do Windows
+(`ERROR_FILE_NOT_FOUND`, `ERROR_PATH_NOT_FOUND`, `ERROR_NO_MORE_FILES` não são falta de
+permissão). Reportar 40 mil problemas onde há 543 é exatamente o número inventado que a
+regra 4 proíbe.
+
+### Outras decisões da varredura
+
+- **Reparse points são ignorados.** Junção e link simbólico apontam para outro lugar: segui-los
+  contaria o mesmo espaço duas vezes e pode virar laço infinito.
+- **Prefixo `\?\`** em todo caminho, senão a varredura para nos 260 caracteres — o que
+  acontece em qualquer `node_modules` ou pasta de build.
+- **`Consolidar` é iterativo**, não recursivo: há um teste com 20 mil níveis de profundidade,
+  que estouraria a pilha numa versão recursiva.
+
+---
+
+## 2026-09-14 — A árvore do disco custava 1,1 GB de RAM
+
+Depois da primeira varredura pela interface, o app estava com **1118 MB**. A causa era o
+`DiskNode` guardar o **caminho completo** em cada nó: numa árvore de 1,5 milhão de arquivos,
+com caminhos de 60 a 100 caracteres, isso sozinho passa de 240 MB, mais o overhead de cada
+string.
+
+O caminho já está na estrutura — é a sequência de nomes até a raiz. Agora só a raiz guarda um
+caminho completo, e os demais montam o seu subindo pelos pais.
+
+**Medido: 594 MB**, contra 1118 MB. Redução de 47%.
+
+Ao fazer isso apareceu uma armadilha: o scanner montava o caminho de cada filho a partir de
+`pasta.Caminho`, o que passou a subir a árvore inteira **por arquivo** e tornaria a varredura
+quadrática na profundidade. O caminho da pasta passou a ser calculado uma vez por pasta, não
+por arquivo. O construtor foi separado em dois — um para a raiz, um para filho — para que
+esse erro não seja possível de escrever de novo.
+
+**Ainda são 594 MB** para 1,5 milhão de nós, e não vale esconder isso: uma versão futura pode
+guardar a árvore achatada em arrays em vez de objetos ligados. Por ora o custo aparece só
+enquanto a página de Espaço está aberta.
+
+---
+
+## 2026-09-14 — Fase 4: `Get-AppxPackage` devolvia zero numa máquina com 142 pacotes
+
+Duas causas somadas, e cada uma sozinha já bastava para zerar a lista.
+
+A primeira: `powershell -Command "..."` passa pela análise de linha de comando do próprio
+PowerShell, que reinterpreta pipe e cifrão antes de o script existir. A correção é
+`-EncodedCommand` com o script em Base64 UTF-16LE — o texto chega intacto.
+
+A segunda é mais traiçoeira. O `stderr` estava redirecionado e ninguém lia. O PowerShell
+escreve o progresso ali em CLIXML; o buffer do pipe encheu, o processo parou de escrever à
+espera de alguém ler, e morreu no timeout de 30 s sem uma linha de erro. Agora as **duas**
+saídas são lidas em paralelo, e o script começa com `$ProgressPreference = 'SilentlyContinue'`.
+
+Vale para qualquer processo filho: redirecionar um fluxo obriga a lê-lo.
+
+## 2026-09-14 — O casamento exato de nomes acusava app instalado como resto
+
+A primeira varredura de restos devolveu 53 pastas e 26 GB, e entre elas estavam
+`BraveSoftware`, `EpicGamesLauncher` e uma pasta `Programs` de 9 GB. Os dois primeiros estão
+instalados — só escrevem a pasta sem os espaços do nome. `Programs` é guarda-chuva: tem
+vários apps ativos dentro, não é resto de nada.
+
+A comparação passou a normalizar (fora espaço e pontuação, tudo minúsculo) e a aceitar
+prefixo a partir de 5 caracteres, e as pastas guarda-chuva entraram na lista de ignoradas.
+Caiu para 30 pastas e 3,9 GB.
+
+O corte de 5 caracteres é arbitrário e foi escolhido por um motivo assimétrico: **deixar de
+listar um resto custa espaço em disco; apontar um app ativo como resto custa os dados do
+usuário.** Quando errar é inevitável, errar para o lado barato.
+
+## 2026-09-14 — O resumo dos apps anunciava 1812 GB num disco de 953 GB
+
+A tela ficou pronta, rodou na máquina real e disse "217 aplicativos, 1812,4 GB no total".
+Nenhum teste pegaria: cada tamanho individual estava certo. O que estava errado era somar.
+
+Dois erros diferentes, os dois só visíveis no total:
+
+1. Instalador que grava `InstallLocation` apontando para `C:\Program Files` ou para a raiz
+   do disco. Medir aquela pasta atribui o disco inteiro a um programa só. Agora pasta
+   genérica é recusada e o app fica sem tamanho medido, que é a resposta honesta.
+2. Vários apps declarando a **mesma** pasta — componentes de uma suíte, por exemplo. A soma
+   contava a pasta uma vez por app. Agora agrupa por pasta antes de somar.
+
+Deu 1044 GB para 2145 GB de disco. O teste que trava isso não confere um número exato: ele
+compara o total com a capacidade real dos discos e recusa qualquer app que sozinho responda
+por mais de um terço. É o tipo de invariante que sobrevive à máquina mudar.
+
+No mesmo teste apareceu um terceiro erro. A lista vinha ordenada pelo tamanho **declarado no
+registro**, porque o inventário ordena antes de a medição acontecer. O ARK, com 309 GB
+reais, aparecia atrás do AutoCAD, que declara 4 GB — exatamente o contrário do que a tela
+serve para mostrar.
+
+## 2026-09-14 — "Sem assinatura digital" era acusação falsa
+
+O Teams aparecia na inicialização com a observação "sem assinatura digital". O executável
+dele mora em `WindowsApps`, cuja ACL barra leitura até para o administrador: o
+`WinVerifyTrust` não reprovou a assinatura, ele nunca conseguiu abrir o arquivo.
+
+`Assinado` virou tri-estado (`bool?`): verdadeiro, falso e **não deu para verificar**. São
+coisas diferentes e a tela agora diz qual é qual. Atalho da pasta Inicializar não fala de
+assinatura nenhuma — o `.lnk` aponta para outro lugar e nunca é assinado, então dizer que
+ele não tem assinatura não diria nada sobre o programa.
+
+---
+
+## 2026-09-14 — O spec foi atualizado no meio da Fase 5: o que conflita
+
+O `GAMEBOOST_V2_SPEC.md` foi substituído por uma versão nova enquanto a Fase 5
+estava sendo escrita. Duas seções mudaram de tamanho: a **5.9 (Rede)** virou um
+módulo inteiro com NAT, e a **5.3 (Desinstalador)** ganhou uma aba de
+atualizações via `winget` — esta última atribuída à Fase 4, que já foi entregue.
+
+Antes de tocar em código, o que já existe e diverge do texto novo:
+
+### Onde o arquivo estava
+
+O spec novo não chegou ao repositório: o `GAMEBOOST_V2_SPEC.md` de lá continuava
+sendo o de 13/09, e as duas versões novas estavam em `C:\Users\User\Downloads`
+como `GAMEBOOST_V2_SPEC (1).md` e `(2).md`. A `(2)`, de 14/09 12:20, é a única
+com as duas mudanças (8 menções a `winget`, 4 a `STUN`); foi ela que entrou no
+repositório.
+
+### 5.9 — o que já estava escrito e diverge
+
+| O que existe | O que o spec novo pede | Situação |
+|---|---|---|
+| NAT em 5 categorias próprias (sem NAT, aberto, simétrico, CGNAT, duplo) | 3 categorias no vocabulário do Xbox: **Aberto / Moderado / Estrito** | Corrigido nesta fase |
+| STUN de **uma** porta local para 2 servidores | 2 servidores **por 2 portas locais** | Corrigido nesta fase |
+| Semáforo do ping em 20/50/100 ms | 30 / 80 ms | Corrigido nesta fase |
+| Teste de velocidade: um download de 25 MB | 3 amostras de 10 s, reportar a **mediana** | Corrigido nesta fase |
+| Aviso de jitter a partir de 5 ms no gateway | Finding com jitter > 15 ms e perda > 1% | Os dois convivem: ver nota abaixo |
+| DNS trocado por `netsh` | `SetDNSServerSearchOrder` via WMI | Fica como está: ver nota abaixo |
+| Banda por processo: recusada, mostra contagem de conexões | bytes por processo via `GetExtendedTcpTable`/`GetExtendedUdpTable` | Não é possível como descrito: ver nota abaixo |
+
+**Jitter.** O spec define o Finding em 15 ms, e está certo para a conexão como um
+todo. O aviso de 5 ms que já existia é outra coisa e continua: ele mede o jitter
+até o **próprio roteador**, onde 5 ms já é anormal e aponta problema dentro de
+casa. São duas medidas diferentes com dois limiares diferentes, não uma
+contradição.
+
+**DNS por `netsh`, não por WMI.** `SetDNSServerSearchOrder` pertence à
+`Win32_NetworkAdapterConfiguration`, congelada desde o Windows 8, e falha em
+adaptador configurado por DHCP em parte das máquinas. O `netsh` é o caminho que o
+próprio Windows usa, e é ele que permite voltar ao estado "automático (DHCP)" —
+que o método WMI não expressa. A reversão para automático é justamente o caso
+mais fácil de perder.
+
+**Bytes por processo.** `GetExtendedTcpTable` devolve **conexões com o PID dono**,
+não contadores de tráfego. Não existe contador por processo de rede no Windows
+sem ETW, e um consumidor de ETW rodando continuamente estoura o teto de 1,5% de
+CPU da regra 9. O que a tela faz é o que dá para afirmar: quantas conexões cada
+processo mantém e para onde. O texto na tela diz isso com todas as letras, em vez
+de apresentar contagem de conexão como se fosse velocidade.
+
+### 5.9 — o que o spec novo pede e ainda não existe
+
+Fica como pendência declarada desta fase, não como coisa feita:
+
+- Histórico em `network-history.json` ("sua conexão piorou à noite").
+- Ping para servidores de jogo por região (Riot, Valve, Blizzard, Epic, EA em
+  São Paulo).
+- UPnP hoje é só descoberta SSDP. O `AddPortMapping` de teste, e a abertura de
+  porta com lease de 24 h removida ao sair do jogo, dependem do detector de jogo
+  em execução, que é da Fase 6.
+- Firewall: hoje lê o estado dos perfis pelo registro. `INetFwPolicy2` via COM
+  para procurar regra do executável do jogo, e `Set-NetConnectionProfile` para
+  marcar a rede como Privada, também dependem do jogo detectado.
+- Checagem de IPv6 e de velocidade de link do adaptador.
+- Tabela de ASN para nomear a operadora, texto pronto para o suporte e passo a
+  passo por marca de roteador.
+
+### 5.3 — a aba "Atualizações" (winget) é da Fase 4, que já foi entregue
+
+O spec novo põe a aba de atualizações via `winget` na seção 5.3, e a seção 12
+mantém a 5.3 na **Fase 4**, que foi fechada e commitada antes desta versão do
+documento existir.
+
+Ela **não** foi feita, e não vai ser embutida na Fase 5 fingindo que sempre
+esteve lá. Entra como a primeira coisa depois que a Fase 5 fechar, com o commit
+dizendo que é complemento retroativo da Fase 4. Misturar as duas deixaria o
+histórico mentindo sobre o que cada fase entregou.
+
+Na mesma seção 5.3 há outros dois pontos ainda não atendidos:
+
+- A varredura de restos cobre pastas, mas não as chaves `HKCU\Software\<Nome>` e
+  `HKLM\Software\<Nome>`, nem a exportação para `.reg` antes de apagar.
+- O ponto de restauração antes de um lote grande existe em Ferramentas, mas não é
+  oferecido dentro do fluxo de desinstalação.
+
+---
+
+## 2026-09-14 — A saída do winget não tem formato para máquina ler
+
+`winget upgrade` não tem `--output json`, nem XML, nem nada estruturado. O que
+existe é uma tabela de largura fixa desenhada para humano.
+
+O jeito óbvio de ler seria procurar a coluna "Available". Ele quebra na primeira
+máquina em outro idioma: em português o cabeçalho é "Disponível", e nesta máquina
+o winget imprimiu os cabeçalhos em inglês enquanto traduzia os **nomes** dos
+pacotes ("Subsistema do Windows para Linux"). Depender de qualquer palavra seria
+depender de uma combinação que nem é consistente dentro da mesma saída.
+
+A leitura é por **posição de coluna**: acha-se a régua de tracinhos, o cabeçalho é
+a linha acima dela, e as colunas começam onde há caractere visível logo depois de
+um espaço. Nenhuma palavra é lida. Sobre isso vêm duas defesas: id com espaço no
+meio é descartado (sinal de que a fatia caiu errado), e a fonte precisa ser uma
+das que o winget conhece.
+
+O teste que trava isso passa a mesma tabela com cabeçalho em português. Se o
+parser voltar a depender de idioma, ele devolve zero e o teste falha.
+
+## 2026-09-14 — Um template de TabControl apagou a árvore de acessibilidade
+
+As abas da página de Apps saíram ilegíveis no tema escuro: o `TabItem` padrão do
+WPF ainda usa o visual do Windows Classic, com fundo claro e texto escuro. Reescrevi
+o `ControlTemplate` do `TabItem` e do `TabControl`.
+
+O script de captura de tela parou de achar os botões. A investigação mostrou algo
+pior que um problema de teste: **a automação não enxergava nenhum controle dentro
+das abas**. As três abas apareciam; da aba para dentro, árvore vazia.
+
+A causa é que o `TabControlAutomationPeer` do WPF procura um `ContentPresenter`
+chamado exatamente `PART_SelectedContentHost` para expor o conteúdo da aba
+selecionada. O meu tinha `ContentSource="SelectedContent"` e nenhum nome, então
+renderizava certo e sumia da automação.
+
+Isso vale registrar por dois motivos. O primeiro é que um leitor de tela não
+alcançaria botão nenhum dessa página — regra de acessibilidade da seção 6.
+O segundo é o método: o defeito só apareceu porque **a mesma automação que um
+leitor de tela usa** é a que dirige os testes de tela. Um teste que clicasse por
+coordenada teria passado.
+
+## 2026-09-14 — Prefixo de id não é fronteira
+
+A classificação das atualizações casava o id do winget por prefixo cru. Na tela
+real, "Chrome Remote Desktop Host" apareceu marcado como **atualização de
+segurança** e como navegador que se atualiza sozinho: o id dele é
+`Google.ChromeRemoteDesktopHost`, e `StartsWith("Google.Chrome")` é verdadeiro.
+
+O id do winget é hierárquico e separado por ponto. O casamento passou a exigir
+fronteira: ou igualdade, ou o caractere seguinte é um ponto. Padrão terminado em
+ponto (`AMD.`, `Intel.`, `RiotGames.`) continua valendo para a família inteira, e
+isso é proposital.
+
+O mesmo erro pegaria `Git.GitLFS` como se fosse o `Git.Git`, e
+`Microsoft.EdgeWebView2Runtime` como se fosse o navegador Edge. Os três casos
+estão no teste.
+
+---
+
+## 2026-09-14 — Detecção de jogo por polling, não por WMI
+
+A seção 5.1 sugere `Win32_ProcessStartTrace`, que entrega o evento no instante em
+que o processo nasce. A alternativa é listar processos de tempos em tempos.
+
+Ficou o polling de 2 segundos, e o motivo é medido, não teórico: na Fase 1 a
+coleta de métricas chegou a **5,02% de CPU**, e o WMI era a maior parcela
+daquilo. O `ProcessStartTrace` exige uma consulta WMI viva o tempo todo — é
+exatamente a forma que saiu de lá. Listar processos por
+`NtQuerySystemInformation` custa microssegundos.
+
+Dois segundos de atraso não importam para isto. O que acontece ao detectar é uma
+pergunta num diálogo; ninguém percebe a diferença entre responder no segundo 0 e
+no segundo 2. Se um dia houver um caso que precise do instante exato, o
+argumento muda.
+
+## 2026-09-14 — `UseWindowsForms` contaminou a aplicação inteira
+
+O WPF não tem ícone de bandeja. O caminho normal é o `NotifyIcon` do WinForms,
+que exige `<UseWindowsForms>true</UseWindowsForms>` no csproj.
+
+O que esse switch faz, além de referenciar a biblioteca, é injetar `global using
+System.Windows.Forms` e `global using System.Drawing` em **todo arquivo do
+projeto**. `Control`, `Application`, `Brush` e `MouseEventArgs` existem nos dois
+mundos, então metade da aplicação parou de compilar por ambiguidade — inclusive
+o `Treemap` e o `MiniGrafico`, que não têm nada a ver com bandeja.
+
+A correção é remover só os usings implícitos, mantendo a referência:
+
+```xml
+<ItemGroup>
+  <Using Remove="System.Windows.Forms" />
+  <Using Remove="System.Drawing" />
+</ItemGroup>
+```
+
+O arquivo da bandeja declara os dele explicitamente. O resto da aplicação
+continua vendo só o WPF.
+
+## 2026-09-14 — O timer de 0,5 ms não faz o que dizem que faz
+
+`NtSetTimerResolution(0.5 ms)` é receita fixa de todo guia de otimização. Desde o
+Windows 10 2004 o pedido é **por processo**: o GameBoost pedir 0,5 ms afeta o
+GameBoost, não o jogo. O que sobra é o sistema honrar a menor resolução pedida
+por alguém para temporizadores globais, e é daí que vem o ganho residual que
+ainda aparece no Windows 10.
+
+Ele entrou no perfil porque é reversível e não custa nada, fica **desligado por
+padrão**, e o texto na tela não promete FPS. É o mesmo tratamento dado ao
+`SystemResponsiveness` e ao `NetworkThrottlingIndex` na Fase 5: marginal escrito
+como marginal.
+
+---
+
+## 2026-09-14 — Assinatura de código: o Brasil está fora da opção barata
+
+O caminho óbvio seria o Azure Artifact Signing, ex-Trusted Signing, a US$ 9,99
+por mês. Ele não está disponível aqui: para desenvolvedor individual a Microsoft
+só aceita Estados Unidos e Canadá, e para organização a lista maior também não
+inclui o Brasil. Não é preço nem papelada, é elegibilidade geográfica.
+
+Sobra o certificado OV de uma CA — Certum, Sectigo, DigiCert —, entre US$ 70 e
+300 por ano. Desde junho de 2023 a chave privada precisa ficar em token USB ou
+HSM em nuvem, o que muda o CI: assinar deixa de ser "põe o segredo e roda".
+
+O que **não** vale é EV. Até 2024 ele pulava o SmartScreen na hora; desde então
+OV e EV passam pelo mesmo processo de reputação, e a diferença de preço parou de
+comprar alguma coisa. É informação que ainda circula desatualizada.
+
+Por isso o passo de assinatura do workflow é **condicional**. Sem o segredo, a
+release sai sem assinatura e o CI emite um aviso visível. Falhar a build inteira
+por falta de um certificado que ainda não existe impediria de publicar qualquer
+coisa. Detalhes em docs/ASSINATURA.md.
+
+## 2026-09-14 — A here-string do PowerShell é incompatível com bloco YAML
+
+O passo que monta o `portable.txt` usava uma here-string (`@'...'@`). O
+PowerShell exige o terminador `'@` no começo da linha, sem espaço antes. O YAML
+exige que todo conteúdo de um bloco `run: |` fique indentado.
+
+As duas regras não coexistem: o `'@` em coluna 0 encerra o bloco YAML no meio do
+script, e o arquivo deixa de ser YAML válido. O erro não aparece ao escrever —
+aparece quando o GitHub recusa o workflow.
+
+Trocado por um array de strings passado ao `Set-Content`, que faz o mesmo e
+respeita a indentação. Vale como regra geral para qualquer script PowerShell
+dentro de workflow.
+
+Vale registrar também **como** isso foi pego: validando o YAML com um parser
+antes do commit, e não confiando na leitura. O mesmo cuidado achou que o
+`build.yml` continuava válido.
+
+---
+
+## 2026-09-14 — Seis bugs em três passos de QA manual
+
+A primeira rodada de QA à mão, com o binário elevado na máquina real, achou seis
+problemas nos três primeiros passos do checklist. Nenhum deles tinha aparecido em
+304 testes automatizados nem nas capturas de tela.
+
+Os dois piores eram de **ciclo de vida**, não de lógica:
+
+**A sessão nunca era encerrada.** `ReverterTudo` desfazia tudo e limpava a tela,
+mas não tocava no `session.json`. O arquivo continuava dizendo `Ativo: true` para
+sempre, e o aviso de "fechado com o Modo Game ainda ativo" voltava em toda
+abertura — com zero pendências. Nenhum teste pegaria: o estado do registro estava
+perfeito, e é isso que os testes conferem.
+
+**`Dispose` chamado duas vezes.** O `App.OnExit` descartava o `GameWatcher`, e o
+`ServiceProvider.Dispose()` logo abaixo descartava de novo, porque o container
+descarta todo singleton `IDisposable`. A segunda chamada caía num
+`CancellationTokenSource` já descartado. A exceção escapava porque o
+`ServiceProvider.Dispose()` estava **fora** do `try`.
+
+A lição que fica: quem escreve `Dispose` não controla quantas vezes ele é chamado.
+Aguentar a segunda chamada em silêncio é obrigação, não gentileza.
+
+Os outros quatro eram de **interface dizendo uma coisa e fazendo outra**:
+
+- O rodapé anunciava "N aguardando na lista de restauração" sem existir lista.
+- O resumo dizia "38 apps marcados" com um único item marcado, porque era o texto
+  da varredura e não acompanhava a seleção.
+- Faltava marcar/desmarcar todos na tela Início.
+- Faltava busca em qualquer lista.
+
+Os dois últimos vieram como sugestão de quem estava testando, não como defeito. A
+busca, em particular, já estava na seção 5.3 do spec e tinha passado despercebida
+por sete fases.
+
+**O que isso diz sobre o método.** As capturas de tela das fases anteriores
+mostravam cada tela funcionando, e todas estavam certas. O que elas não mostram é
+a **sequência**: abrir, agir, fechar, reabrir. Foi aí que os seis apareceram.
+
+---
+
+## 2026-09-14 — Medir banda por tamanho fixo mede a rajada, não a linha
+
+O spec pedia "3 amostras de 10 s". Eu troquei por 25 MB de transferência
+cronometrada, achando que era equivalente e mais previsível para quem tem
+franquia. Deixei isso escrito como se fosse uma melhoria.
+
+Não é equivalente. Numa fibra doméstica a operadora deixa passar bem acima do
+contratado por um ou dois segundos. Uma transferência que termina em 0,6 segundo
+mede **só essa rajada**.
+
+O sinal de que algo estava errado foi o número não bater com um teste dedicado.
+A investigação mostrou o problema de forma direta — mesma linha, mesmo minuto:
+
+| Tamanho | Tempo | Upload medido |
+|---|---|---|
+| 8 MB | 0,51 s | 131,5 Mbps |
+| 25 MB | 0,59 s | 354,7 Mbps |
+| 50 MB | 1,53 s | 274,9 Mbps |
+
+Três respostas diferentes para a mesma pergunta. Um teste cujo resultado depende
+do tamanho escolhido não está medindo a linha.
+
+A correção é medir por **tempo** (8 s) e descartar os 2 primeiros segundos, onde
+moram a rajada e o slow start do TCP. O teto de 120 MB por amostra continua
+protegendo a franquia.
+
+### E um erro meu de leitura, no meio disso
+
+Ao comparar com o Speedtest, eu vi 380 Mbps de upload contra 73 e afirmei que 380
+era impossível e 73 era o número real. Estava errado: aquele servidor específico
+(em Cotia) é que limitava. Trocando de servidor, o mesmo Speedtest deu **264
+Mbps**, e o ping caiu de 361 ms para 4 ms.
+
+A medição corrigida dá 224 Mbps — 15% abaixo dos 264, que é o esperado para um
+teste de um servidor só e uma conexão só.
+
+A lição vale para o texto da tela, e ela foi escrita lá: **um teste dedicado
+também erra** quando o servidor escolhido está congestionado. Dizer "o Speedtest
+é a verdade" seria tão impreciso quanto o defeito original.
+
+## 2026-09-14 — A tela mostrava o estado de antes depois de agir
+
+Quem testava perguntou se estava certo o badge de um serviço dizer "automático"
+depois da reversão. Estava — mas a pergunta revelou o problema: logo **depois de
+aplicar**, com o serviço já em Manual, o badge também dizia "automático".
+
+A lista guarda o resultado da varredura e não é refeita depois de agir. Na
+prática: a pessoa aplica, olha a linha, e parece que nada aconteceu.
+
+Refazer a varredura sozinho resolve onde ela é barata. Em Tweaks são
+milissegundos, e passou a ser automático. Na lista de apps instalados leva quase
+um minuto, e revarrer sozinho travaria a tela logo depois de uma ação — ali a
+tela avisa que a lista mostra o estado de antes.
+
+A regra que fica: **ou a tela mostra o estado atual, ou diz que não está
+mostrando.** O que não pode é apresentar um estado velho como se fosse o de
+agora.
+
+---
+
+## 2026-09-14 — Um `Pack = 1` apagou a Lixeira do aplicativo inteiro
+
+Ao confirmar o envio de uma pasta para a Lixeira, o GameBoost fechou. Sem caixa
+de erro, sem exceção no log — o log simplesmente parava na linha anterior. O
+Visualizador de Eventos do Windows mostrou o motivo:
+
+```
+Código de exceção: 0xc0000005
+Nome do módulo com falha: GameBoost.exe
+```
+
+Violação de acesso. Crash nativo, não exceção .NET — por isso os três handlers
+globais não pegaram nada.
+
+A causa estava numa linha:
+
+```csharp
+[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
+private struct SHFILEOPSTRUCT
+```
+
+Em x64 os campos dessa struct são alinhados em 8 bytes. Com `Pack = 1` o .NET
+remove o preenchimento, e o `pFrom` passa a ficar no deslocamento 12. O `shell32`
+continua lendo do 16 — pega a metade alta de um ponteiro colada na metade baixa
+do seguinte, e usa aquilo como endereço de memória.
+
+### O que isso diz sobre o que não foi testado
+
+**A Lixeira nunca funcionou.** Limpeza, Espaço e Restos chamam a mesma função.
+Três módulos, três fases, e em todos eles a ação de "mandar para a Lixeira"
+derrubaria o aplicativo.
+
+O `docs/QA.md` tinha o item desde a Fase 2:
+
+```
+- [ ] Enviar um arquivo para a Lixeira pela página e conferir que dá para restaurar
+```
+
+Ficou sem marcar por três fases. E não era um detalhe cosmético esperando na
+fila: era a única forma de descobrir um crash garantido.
+
+Marshalling de P/Invoke não quebra a compilação e não aparece em teste que use
+fake. O teste novo chama a função de verdade, com um arquivo de verdade. É o
+único jeito.
+
+---
+
+## 2026-09-14 — A detecção funcionava; era tudo depois dela que não
+
+O QA do bloco de perfis achou seis problemas, e o padrão entre eles diz mais que
+cada um isolado.
+
+A **detecção** estava certa desde a Fase 6. O log registrava exatamente o que o
+spec pede:
+
+```
+Watcher | Warframe.x64 | executavel dentro de uma pasta de launcher,
+                         confiança 80, tela cheia True
+```
+
+O que não existia era o resto do caminho:
+
+1. O convite era disparado num evento **sem nenhum assinante**. Nascia e morria
+   na mesma linha.
+2. Aceitar o convite só navegava para outra tela. O `ProfileRunner` — a classe
+   inteira escrita para aplicar o perfil — nunca era chamada por ninguém.
+3. Fechar o jogo também não chamava o `ProfileRunner`, mas a mensagem afirmava
+   que "tudo o que o GameBoost alterou foi desfeito".
+
+Três elos de uma corrente de quatro. O primeiro funcionava perfeitamente e os
+outros três não existiam — e nada disso aparece em teste unitário, porque cada
+peça isolada faz o que promete. O `ProfileRunner` tem teste e passa. O que não
+tinha teste era **alguém chamando o ProfileRunner**.
+
+### O falso positivo, e por que o filtro de memória não bastou
+
+Numa sessão real o app anunciou "Agent está rodando. Ativar o Modo Game?".
+
+`Agent.exe` é o atualizador do Battle.net, e mora em
+`C:\ProgramData\Battle.net\Agent\Agent.9775\`. A pasta bate com a lista de
+launchers, o que dá confiança 80.
+
+Existia um filtro: dentro de pasta de launcher, só conta como jogo quem usa mais
+de 300 MB. Parecia suficiente — o Agent usa 32 MB parado. Só que ele **engorda
+enquanto baixa atualização**, e naquele momento passou do limite.
+
+Filtro de memória não distingue jogo de instalador; distingue processo grande de
+processo pequeno. O que separa de verdade é o nome: jogo tem nome próprio,
+infraestrutura tem nome de função. "Agent", "Launcher", "Updater" e "Helper"
+descrevem o que o programa faz — e dentro da pasta de um launcher, isso é sempre
+a maquinaria dele.
+
+O teste novo passa 2 GB de RAM de propósito, para provar que o filtro de nome
+vale mesmo quando o processo está gordo.
+
+### Um texto que negava o que tinha acontecido
+
+Quando o jogo fecha antes de o Desfazer rodar, não sobra prioridade para
+restaurar: ela morre junto com o processo. Isso é o esperado.
+
+Mas o aviso dizia **"Não havia perfil aplicado"** — e havia. A frase negava um
+fato para descrever uma consequência. Agora ela explica o que aconteceu de
+verdade: o perfil saiu junto com o jogo.
+
+---
+
+## Pendências conhecidas desta fase
+
+- `--clean` (seção 5.2) responde com "chega na Fase 2" e código de saída 3. Está no parser
+  porque a superfície da CLI da seção 8 precisa existir inteira desde já.
+  `--report` foi implementado na Fase 1.
+- `Resources/Strings.pt-BR.resx` ainda não existe: as strings estão no código. A regra 7 diz
+  que devem sair para recurso; fica para quando houver a segunda tela, para não criar um
+  arquivo de recursos com meia dúzia de entradas.
+- Detecção automática de jogo por `Win32_ProcessStartTrace` (seção 5.1) não foi feita: a
+  detecção atual é sob demanda, durante a varredura. Entra na Fase 6, junto com os perfis.
+- Findings de uso de disco e rede **por processo** (seção 5.5) dependem de ETW e ficaram de
+  fora; as regras que existem usam CPU, memória e os fatos do sistema.
+- Latência DPC/ISR, marcada como experimental no spec, não foi implementada.
+- Timer resolution: o P/Invoke existe (`NativeMethodsBridge.SetTimerResolution`) mas não é
+  chamado pelo Modo Game ainda. Entra na Fase 6.
diff --git a/GameBoost/docs/PORTAS.md b/GameBoost/docs/PORTAS.md
new file mode 100644
index 0000000..55070fc
--- /dev/null
+++ b/GameBoost/docs/PORTAS.md
@@ -0,0 +1,213 @@
+# Portas por jogo e por launcher
+
+Referência usada pela página **Rede** quando o diagnóstico encontra NAT estrito e
+o roteador não tem UPnP. É a lista que o usuário precisa ter na mão para abrir
+porta à mão, e o texto de cada seção diz o que abrir e o que **não** adianta
+abrir.
+
+> **Antes de abrir qualquer porta:** reserve um IP fixo para este PC no DHCP do
+> roteador. Sem isso o endereço muda no próximo boot e a regra passa a apontar
+> para outra máquina da casa — normalmente a TV.
+
+> **Abrir porta não resolve CGNAT nem NAT duplo.** Se o diagnóstico apontou um
+> desses, a porta aberta no seu roteador morre no equipamento de cima. Veja as
+> seções no fim deste arquivo.
+
+---
+
+## O que o GameBoost faz e o que ele não faz
+
+| | |
+|---|---|
+| Detecta o tipo de NAT (STUN) | Sim |
+| Detecta CGNAT, NAT duplo, UPnP, Teredo e firewall | Sim |
+| Reativa o Teredo (reversível) | Sim |
+| Abre porta via UPnP com prazo de 24 h | Previsto para a Fase 6, junto com o detector de jogo |
+| Configura o roteador | **Não.** O roteador não é dele; uma regra escrita lá não tem como ser desfeita se o app sumir |
+| Coloca o modem em bridge | **Não.** Isso derruba a internet da casa até a nova configuração subir |
+
+---
+
+## Launchers e plataformas
+
+Estas são as portas que valem para **todos** os jogos da plataforma. Abrir só
+estas já resolve boa parte dos casos de "não entro na festa".
+
+### Steam
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 27015 – 27030 | UDP | Tráfego de jogo e consulta de servidor |
+| 27015 – 27030 | TCP | Servidor dedicado |
+| 27036 – 27037 | UDP e TCP | Remote Play e transmissão na rede local |
+| 4380 | UDP | Tráfego de jogo antigo (Source) |
+| 3478, 4379, 4380 | UDP | Voz do Steam |
+
+### Epic Games
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 5222 | TCP | Presença e convite de amigo |
+| 5795 – 5847 | UDP | Tráfego de jogo (Fortnite e outros) |
+| 443, 80 | TCP | Download e autenticação |
+
+### Battle.net (Blizzard)
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 1119 | TCP e UDP | Battle.net (chat, grupo, presença) |
+| 3724 | TCP | World of Warcraft |
+| 6112 – 6114 | TCP e UDP | Jogos antigos e Overwatch |
+| 80, 443 | TCP | Cliente e download |
+
+### Xbox / Game Pass no PC
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 3074 | UDP e TCP | Rede Xbox Live |
+| 88 | UDP | Autenticação |
+| 500, 3544, 4500 | UDP | **Teredo** — sem estas, festa e multiplayer não conectam |
+| 53 | UDP e TCP | DNS |
+
+> O caso do Game Pass é o mais comum de todos: o multiplayer não conecta porque
+> alguém desativou o Teredo seguindo um tutorial de "otimização de rede". O
+> GameBoost detecta isso e reativa, com desfazer. Não precisa abrir porta
+> nenhuma para resolver esse caso.
+
+### Riot (League of Legends, Valorant)
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 5000 – 5500 | UDP | Tráfego de partida |
+| 8393 – 8400 | TCP | Cliente |
+| 2099, 5222, 5223 | TCP | Chat e plataforma |
+
+### EA / Origin / EA App
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 3659 | UDP | Tráfego de jogo |
+| 9988, 20000 – 20100 | UDP | Matchmaking |
+| 42127 | TCP | Cliente |
+| 1024 – 1124 | TCP | Download |
+
+### GOG Galaxy
+
+Não exige porta aberta: usa relay por padrão. Se um jogo específico da GOG pedir
+porta, ela é do jogo, não da plataforma.
+
+### Discord
+
+| Porta | Protocolo | Para quê |
+|---|---|---|
+| 50000 – 65535 | UDP | Voz |
+| 443, 80 | TCP | Aplicativo |
+
+> Discord com voz falhando e NAT estrito no diagnóstico são o mesmo problema.
+> Quando não dá para abrir porta, a opção "Qualidade de serviço com prioridade
+> alta" **desligada** nas configurações de voz do Discord costuma ajudar, porque
+> alguns roteadores tratam mal o pacote marcado.
+
+---
+
+## Jogos com porta própria
+
+Abrir a porta do launcher normalmente basta. Estes pedem porta própria quando
+você quer **hospedar**.
+
+| Jogo | Portas | Protocolo |
+|---|---|---|
+| Minecraft (Java, servidor) | 25565 | TCP e UDP |
+| Minecraft (Bedrock) | 19132 – 19133 | UDP |
+| Terraria | 7777 | TCP |
+| ARK: Survival Evolved | 7777 – 7778, 27015 | UDP |
+| Valheim | 2456 – 2458 | UDP |
+| Rust | 28015 – 28016 | UDP |
+| Call of Duty (Warzone, MW) | 3074, 27014 – 27050 | UDP e TCP |
+| Counter-Strike 2 | 27015 – 27020, 27031 – 27036 | UDP |
+| Palworld | 8211 | UDP |
+| Satisfactory | 7777, 15000, 15777 | UDP |
+
+---
+
+## CGNAT: por que abrir porta não adianta
+
+A operadora divide um endereço público entre vários assinantes. O NAT que
+atrapalha está no equipamento dela, e você não tem acesso a ele. O sinal é o IP
+de WAN do seu roteador estar na faixa `100.64.x.x` a `100.127.x.x`, ou ser
+diferente do IP que a internet enxerga.
+
+O que funciona, em ordem de esforço:
+
+1. **Pedir IP público à operadora.** Em várias é gratuito e resolve por telefone;
+   em outras é um adicional mensal. O nome varia: "IP público", "IP fixo", "IP
+   válido", "saída do CGNAT".
+2. **IPv6.** Jogos que suportam IPv6 passam por cima do CGNAT, porque cada
+   máquina tem endereço próprio. A maioria das operadoras brasileiras já entrega
+   IPv6; verifique se está ligado no roteador.
+3. **Serviço de roteamento** (ExitLag, WTFast, GearUP). Custa por mês, e não
+   resolve em todo jogo — só nos que aceitam o túnel. É paliativo, não solução.
+
+O que **não** funciona: abrir porta, ligar UPnP, DMZ, trocar de DNS, resetar o
+Winsock, trocar o cabo. Nenhum deles toca no equipamento da operadora.
+
+---
+
+## NAT duplo: dois roteadores em série
+
+Acontece quando o modem da operadora também roteia e você ligou o seu roteador
+nele. O `tracert` mostra dois ou mais saltos com IP privado antes do primeiro
+público.
+
+Três saídas, da melhor para a pior:
+
+1. **Modo bridge no modem da operadora.** Ele passa a ser só modem e o seu
+   roteador recebe o IP público direto. É a solução correta. Feito na
+   configuração do modem, e às vezes só o suporte da operadora consegue ligar.
+2. **DMZ no modem apontando para o IP do seu roteador.** Todo tráfego de entrada
+   passa a ir para o seu roteador. Funciona, mas expõe o seu roteador inteiro.
+3. **Usar só um dos dois.** Se o modem da operadora tem Wi-Fi decente, desligar o
+   seu roteador resolve o NAT duplo de graça.
+
+---
+
+## Marcas de roteador: onde fica cada coisa
+
+O endereço é quase sempre `192.168.0.1`, `192.168.1.1` ou `192.168.15.1` — a
+página Rede mostra o do seu. O usuário e a senha padrão costumam estar numa
+etiqueta embaixo do aparelho.
+
+| Marca | UPnP | Redirecionamento de porta |
+|---|---|---|
+| TP-Link | Avançado → NAT Forwarding → UPnP | Avançado → NAT Forwarding → Virtual Servers |
+| Intelbras | Avançado → Encaminhamento → UPnP | Avançado → Encaminhamento → Servidores Virtuais |
+| Huawei | Avançado → NAT → UPnP | Avançado → NAT → Mapeamento de Portas |
+| ZTE | Aplicação → UPnP | Aplicação → Encaminhamento de Portas |
+| Mercusys | Avançado → NAT Forwarding → UPnP | Avançado → NAT Forwarding → Servidores Virtuais |
+| Asus | WAN → Internet Connection → Enable UPnP | WAN → Virtual Server / Port Forwarding |
+| D-Link | Advanced → Advanced Network → UPnP | Advanced → Port Forwarding |
+
+---
+
+## Quando o problema é o firewall do Windows, não o roteador
+
+Dois casos, e os dois aparecem no diagnóstico:
+
+- **Rede marcada como Pública.** O Windows bloqueia entrada por padrão em rede
+  pública. Em casa, a rede deve estar como Privada.
+- **O jogo não tem regra de entrada.** Acontece quando o jogo foi instalado
+  copiando a pasta, ou quando alguém clicou em "Cancelar" no aviso do firewall
+  na primeira execução.
+
+O GameBoost hoje lê e informa os dois. Criar a regra do jogo e trocar o perfil da
+rede dependem de saber qual jogo está aberto, o que entra na Fase 6 junto com o
+detector de jogo.
+
+---
+
+## Fontes
+
+As portas vêm da documentação de suporte de cada plataforma (Steam, Epic,
+Blizzard, Riot, EA, Xbox) consultadas em setembro de 2026. Elas mudam pouco, mas
+mudam: quando um jogo parar de bater com esta tabela, a fonte é a página de
+suporte do próprio jogo, não um fórum.
diff --git a/GameBoost/docs/PROTECAO.md b/GameBoost/docs/PROTECAO.md
new file mode 100644
index 0000000..bd5a0db
--- /dev/null
+++ b/GameBoost/docs/PROTECAO.md
@@ -0,0 +1,228 @@
+# Blindagem
+
+Documentação das listas de proteção da seção 9 do spec. Toda lista aqui tem teste
+correspondente em `SafetyGuardTests`. **Se algum desses testes cair, o app não pode ser
+publicado.**
+
+Ponto único de consulta: `ISafetyGuard`, implementado por
+[`SafetyGuard`](../src/GameBoost.Core/Safety/SafetyGuard.cs). Nenhum módulo decide sozinho o
+que pode tocar.
+
+---
+
+## 1. Processos
+
+### 1.1 Núcleo do Windows — omitidos da lista
+
+`ProtectedProcesses.Criticos`. Encerrar qualquer um derruba a sessão ou o sistema.
+
+`system`, `idle`, `registry`, `memory compression`, `secure system`, `smss`, `csrss`,
+`wininit`, `winlogon`, `services`, `lsass`, `lsaiso`, `svchost`, `spoolsv`, `dwm`,
+`explorer`, `fontdrvhost`, `sihost`, `taskhostw`, `ctfmon`, `runtimebroker`,
+`shellexperiencehost`, `startmenuexperiencehost`, `searchhost`, `searchindexer`, `audiodg`,
+`conhost`, `dllhost`, `wudfhost`, `wmiprvse`, `trustedinstaller`, `tiworker`, `logonui`,
+`userinit`, `dashost`, `applicationframehost`, `textinputhost`, `systemsettings`,
+`backgroundtaskhost`
+
+Além da lista: **qualquer PID ≤ 4** e **qualquer executável dentro de `C:\Windows`**.
+
+> A comparação de caminho é por segmento. `C:\WindowsApps` **não** conta como dentro de
+> `C:\Windows` — há teste para isso.
+
+### 1.2 Anti-cheats — aparecem bloqueados
+
+`ProtectedProcesses.AntiCheats`. Fechar derruba o jogo e pode gerar banimento.
+
+`easyanticheat` (+ `_eos`, `_setup`), `beservice`, `bedaisy`, `battleye`, `vgc`, `vgtray`,
+`vgk` (Vanguard), `faceitservice`, `faceit`, `pnkbstra/b/k` (PunkBuster), `xigncode`,
+`xhunter1`, `gameguard`, `gamemon`, `npggnt`, `nprotect`, `ricochet`, `eaanticheat`,
+`anticheatexpert`, `ace-base`, `ace-guard`, `mhyprot`, `sgguard`, `steamservice`
+
+### 1.3 Antivírus e EDR — aparecem bloqueados
+
+Detecção em duas camadas:
+
+1. **WMI** `root\SecurityCenter2` (`AntiVirusProduct`, `AntiSpywareProduct`,
+   `FirewallProduct`) → nome do executável assinado. É a fonte de verdade.
+2. **Lista estática** `ProtectedProcesses.Seguranca`, rede de segurança para quando o WMI
+   falhar ou o produto não se registrar: Defender, Kaspersky, Avast/AVG, Bitdefender,
+   McAfee, Norton, ESET, Sophos, Carbon Black, CrowdStrike, SentinelOne, Cylance, Trend
+   Micro, Webroot, Malwarebytes.
+
+### 1.4 Nunca pré-marcados — aparecem desmarcados (regra 3)
+
+`ProtectedProcesses.NuncaPreMarcados`. O usuário pode marcar à mão; o app nunca marca por
+ele.
+
+| Grupo | Exemplos |
+|---|---|
+| Launchers | Steam, Epic, Battle.net, Riot Client, GOG Galaxy, EA Desktop, Origin, Ubisoft Connect, Xbox |
+| Overlay e monitoramento | RTSS, RivaTuner, MSI Afterburner |
+| Gravação e streaming | OBS, Streamlabs, XSplit, NVIDIA Share, Radeon Software |
+| IDEs e editores | Visual Studio, VS Code, Rider, IntelliJ, PyCharm, WebStorm |
+| Criação | Photoshop, Illustrator, Premiere, After Effects |
+| Office | Excel, Word, PowerPoint, Outlook |
+| Virtualização | VMware, VirtualBox, Docker Desktop |
+| Sincronização de nuvem | OneDrive, OneDrive.Sync.Service, FileCoAuth, Dropbox, Google Drive, MEGAsync, Syncthing, Nextcloud |
+
+**Instaladores e atualizadores em execução** também nunca vêm marcados. A detecção é por
+padrão de nome (`setup`, `install`, `updater`, `update`, `upgrade`, `patch`, `msiexec`,
+`redist`, `unins`, ou terminando em `.tmp`), e não por lista: instalador novo aparece toda
+semana. Encerrar um no meio do trabalho corrompe a instalação.
+
+Além da lista: **qualquer executável dentro de pasta de jogo** —
+`\steamapps\common\`, `\Epic Games\`, `\Riot Games\`, `\Battle.net\`,
+`\GOG Galaxy\Games\`, `\XboxGames\`, `\EA Games\`, `\Origin Games\`, `\Ubisoft\`.
+
+### 1.5 Listas do usuário
+
+`settings.json` aceita `NuncaEncerrar` e `SempreEncerrar`.
+
+**`SempreEncerrar` não vence a blindagem.** Colocar `lsass` nessa lista não libera nada — há
+teste garantindo. Ela só supera a lista de "nunca pré-marcados": quem quer que a Steam venha
+marcada pode pedir isso.
+
+---
+
+## 2. Caminhos
+
+`CheckPath(caminho, whitelist)` só libera se o caminho estiver **dentro** de algum item da
+whitelist do módulo. **Whitelist vazia não libera nada.** O caminho é normalizado com
+`Path.GetFullPath` antes de qualquer comparação, então `..\` não escapa.
+
+Bloqueados mesmo dentro da whitelist — se o segmento aparecer em **qualquer nível**:
+
+`.git`, `onedrive`, `dropbox`, `google drive`, `icloud`, `saves`, `savegames`,
+`saved games`, `savedgames`, `my games`
+
+Pastas pessoais (`Documentos`, `Imagens`, `Vídeos`, `Música`, `Área de Trabalho`,
+`Favoritos`) são bloqueadas a menos que a própria whitelist do módulo aponte para dentro
+delas — o que exige decisão explícita de quem escreveu o módulo.
+
+Pastas de sistema (`C:\Windows`, `Program Files`, `Program Files (x86)`, `System32`,
+`SysWOW64`) só são alcançáveis pela whitelist explícita de limpeza da seção 5.2, e
+`Program Files` só via Desinstalador.
+
+---
+
+## 3. Serviços
+
+`ProtectedServices.Intocaveis` — não podem ser parados nem ter o `StartType` alterado:
+
+| Grupo | Serviços |
+|---|---|
+| Núcleo | `DcomLaunch`, `RpcSs`, `RpcEptMapper`, `Winmgmt`, `EventLog`, `Schedule`, `TrustedInstaller`, `CryptSvc`, `PlugPlay`, `Power`, `ProfSvc`, `SamSs`, `LSM`, `Themes`, `UserManager`, `gpsvc`, `BrokerInfrastructure`, `SystemEventsBroker` |
+| Rede | `Dhcp`, `Dnscache`, `nsi`, `NlaSvc`, `netprofm`, `WlanSvc`, `LanmanWorkstation` |
+| Áudio | `Audiosrv`, `AudioEndpointBuilder` |
+| Segurança | `WinDefend`, `SecurityHealthService`, `wscsvc`, `Sense`, `mpssvc`, `BFE` |
+| Update | `wuauserv` |
+
+`ProtectedServices.PausaveisTemporariamente` — podem ser **parados** durante o Modo Game,
+nunca desabilitados: `wuauserv`, `UsoSvc`, `DoSvc`, `BITS`.
+
+A parada grava `ChangeRecord` com `estavaRodando=true`, então o serviço volta no
+desligamento do Modo Game, no "Reverter tudo", na próxima abertura após um travamento e no
+desinstalador.
+
+---
+
+## 4. Registro
+
+- Nunca tocar em `HKLM\SYSTEM\CurrentControlSet\Services\*` além de `Start`.
+- Nunca tocar em `Winlogon`, `Image File Execution Options`, `Policies`.
+- Toda escrita passa por `ChangeRecord` com `root`, `kind` e `ValorAnteriorExistia`. Quando
+  o valor **não existia**, reverter significa **apagar**, não gravar zero — há teste.
+
+---
+
+## 5. Tweaks proibidos
+
+Nunca alterados pelo GameBoost, em nenhuma fase:
+
+- **VBS / Core Isolation (Memory Integrity)** — só informar e medir, com link para as
+  Configurações do Windows. É segurança contra malware de kernel; a decisão é do usuário.
+- **Mitigações de Spectre/Meltdown**
+- **Windows Defender**, **UAC**, **SmartScreen**, **assinatura de drivers**
+- **Limpeza de registro** — sem ganho mensurável, risco puro (regra 4)
+
+---
+
+## 6. O que **não** é jogo, mesmo morando na pasta da Steam
+
+`GameDetector.NaoSaoJogos`. Sem esta lista, o Wallpaper Engine era eleito "o jogo" só por
+estar em `steamapps\common` — e o Modo Game subia a prioridade de CPU do papel de parede em
+vez da do jogo de verdade. Foi encontrado no primeiro teste com privilégios numa máquina real.
+
+`wallpaper64`, `wallpaper32`, `wallpaperservice64`, `webwallpaper32`, `vrmonitor`,
+`vrserver`, `vrcompositor`, `vrdashboard`, `steamvr`, `aseprite`, `blender`, `krita`,
+`obs64`, `3dsmax`, `unity`, `unityhub`, `rpcs3`, `pcsx2`, `dolphin`, `retroarch`,
+`steamwebhelper`, `gameoverlayui`, `steamerrorreporter`
+
+Além da lista, a heurística de pasta ficou mais exigente: um executável desconhecido dentro
+de pasta de launcher só é considerado jogo se ocupar **mais de 300 MB** de memória.
+Utilitário não tem porte de jogo.
+
+---
+
+## 7. Desinstalador: o que nunca sai
+
+`UninstallerProtection`. Um app que case com qualquer destes trechos de nome aparece na lista
+**bloqueado**, com o motivo visível.
+
+| Grupo | Por quê |
+|---|---|
+| Visual C++ Redistributable, `vc_redist` | Outros programas param de abrir sem o runtime |
+| .NET Runtime, Desktop Runtime, ASP.NET Core, .NET SDK | Programas em .NET param de abrir |
+| DirectX | Jogos param de abrir |
+| Microsoft Edge, WebView2 | Muitos aplicativos usam o WebView2 para desenhar a interface |
+| Xbox Identity Provider, Gaming Services | Game Pass e anti-cheats da Microsoft dependem |
+| NVIDIA, AMD Software, Radeon, Intel, Realtek, chipset, áudio | Componentes de driver |
+| Windows SDK, Visual Studio | Remova pelo instalador oficial |
+| Atualizações e componentes de sistema | Não são aplicativos |
+| **Antivírus** (Kaspersky, Avast, AVG, Bitdefender, McAfee, Norton, ESET, Sophos, Malwarebytes, Trend Micro, F-Secure, Panda, CrowdStrike, SentinelOne, Webroot, Carbon Black) | Remover daqui deixaria a máquina desprotegida |
+| Pacotes da Store marcados `NonRemovable` pelo Windows | O próprio Windows recusa |
+
+**Bloatware conhecido** (Candy Crush, Solitaire, 3D Viewer, Clipchamp, LinkedIn, TikTok,
+Feedback Hub, Get Help, Your Phone, utilitários OEM e afins) aparece **sugerido**, com a caixa
+**vazia**. O que é bloat para um é ferramenta para outro — a decisão é do usuário (regra 3).
+
+---
+
+## 8. Restos de apps antigos: pastas nunca listadas
+
+`LeftoverScanner.Ignoradas`. A varredura de `%APPDATA%`, `%LOCALAPPDATA%` e `%PROGRAMDATA%`
+nunca inclui estas pastas, mesmo sem app correspondente:
+
+**Microsoft e Windows:** `Microsoft`, `MicrosoftEdge`, `Microsoft Corporation`, `Windows`,
+`WindowsApps`, `OneDrive`, `Microsoft OneDrive`, `Packages`, `Temp`, `Tmp`, `Cache`, `Comms`,
+`ConnectedDevicesPlatform`, `D3DSCache`, `ElevatedDiagnostics`, `Publisher Cache`,
+`VirtualStore`, `WebCacheLock`, `IconCache`, `Package Cache`, `Installer`, `Assembly`,
+`Diagnostics`, `History`, `Application Data`, `AppData`, `ProgramData`, `UsoShared`,
+`UsoPrivate`, `WindowsHolographicDevices`, `Desktop`, `Start Menu`, `ssh`
+
+**Guarda-chuva** (contêm vários apps ativos dentro): `Programs`, `Apps`, `Local`, `Roaming`,
+`LowLevel`, `Virtual Machines`
+
+**Hardware e driver:** `NVIDIA`, `NVIDIA Corporation`, `AMD`, `ATI`, `Intel`,
+`IntelGraphicsProfiles`, `Realtek`, `Logishrd`, `Logitech`, `Razer`, `Corsair`, `SteelSeries`,
+`Synaptics`, `ELAN`, `Qualcomm`, `Broadcom`
+
+**Compartilhadas:** `Adobe`, `Common Files`, `Oracle`, `Java`, `Sun`, `Mozilla`, `Google`,
+`Chromium`, `Chrome`, `CrashDumps`, `crashpad`, `CrashReports`, `Sentry`, `SquirrelTemp`,
+`node`, `npm`, `npm-cache`, `yarn`, `pip`, `nuget`, `.nuget`, `dotnet`, `JetBrains`,
+`VisualStudio`, `VSCode`, `Code`, `GitHub`, `Git`, `Docker`, `Kaspersky Lab`, `ESET`,
+`Avast Software`
+
+Além da lista: pastas começando com ponto, e qualquer pasta abaixo de 1 MB.
+
+### Por que o casamento não é só exato
+
+A primeira versão comparava nomes exatos e acusou `BraveSoftware` e `EpicGamesLauncher` como
+restos — os dois **estão instalados**, só escrevem a pasta sem os espaços do nome. A
+comparação passou a normalizar espaços e pontuação e a aceitar prefixo a partir de 5
+caracteres. Isso derrubou o resultado de **53 pastas e 26 GB** para **30 pastas e 3,9 GB**
+nesta máquina.
+
+**Falso positivo aqui é pior que falso negativo:** deixar de listar um resto custa espaço,
+apontar um app ativo como resto custa os dados do usuário. Por isso, e porque a heurística
+nunca será perfeita, **nada é pré-marcado e a remoção vai para a Lixeira**.
diff --git a/GameBoost/docs/QA.md b/GameBoost/docs/QA.md
new file mode 100644
index 0000000..e6fb1f0
--- /dev/null
+++ b/GameBoost/docs/QA.md
@@ -0,0 +1,270 @@
+# Checklist de QA manual
+
+O que os testes automatizados não cobrem. Nenhuma release sai sem isto.
+
+Legenda: `[ ]` não testado · `[x]` passou · `[!]` falhou, ver observação.
+
+---
+
+## Fase 0 — paridade com a v1.0.0
+
+A v1 foi reconstruída a partir do `LEIA-ME.txt` (ver `DECISOES.md`), então a paridade
+funcional precisa ser conferida à mão contra o binário antigo.
+
+- [x] `GameBoost.exe --scan relatorio.txt` gera relatório e **não encerra nada**
+- [x] `GameBoost.exe --scan` sem argumento imprime no terminal que chamou
+- [x] Ativar o Modo Game abre a tela de confirmação **antes** de fechar qualquer coisa,
+      e lista só o que está marcado
+- [x] Um app com trabalho não salvo (Bloco de Notas com texto) não perde nada. O Bloco de
+      Notas do Windows 11 persiste sozinho e por isso não pergunta; o texto volta intacto
+- [x] Apps marcados com ★ reabrem sozinhos ao desligar
+- [x] Apps não marcados aparecem na lista de restauração com botão individual
+- [x] Plano de energia volta ao anterior ao desligar
+- [x] Windows Update volta a rodar ao desligar (`Get-Service wuauserv`)
+- [x] Game DVR e Game Bar voltam aos valores originais (conferir no `regedit`)
+
+## Reversão e recuperação
+
+- [x] Ativar o Modo Game, **matar o GameBoost pelo Gerenciador de Tarefas**, reabrir:
+      aparece o aviso "foi fechado com o Modo Game ainda ativo" com o botão Restaurar agora
+- [ ] Ativar o Modo Game, **reiniciar o PC**, abrir: mesmo aviso
+- [ ] "Reverter tudo" funciona a qualquer momento, mesmo sem Modo Game ativo
+- [ ] Rodar o desinstalador com o Modo Game ativo reverte antes de remover
+- [ ] Reverter duas vezes seguidas não reaplica nada
+- [ ] Ativar e desativar **10 vezes seguidas** sem vazar estado
+      (`state-backup.json` termina sem pendências)
+
+## Blindagem — o teste que não pode falhar
+
+- [ ] **Com Valorant aberto (Vanguard rodando)**: nem `vgc`, nem `vgtray`, nem `vgk`
+      aparecem selecionáveis. Ativar o Modo Game **não derruba o jogo**
+- [ ] Com jogo da Steam aberto: o jogo aparece na categoria "Jogo", bloqueado
+- [ ] Steam, Epic e Battle.net aparecem **desmarcados**
+- [ ] OBS gravando aparece desmarcado
+- [ ] Nenhum processo do antivírus aparece selecionável
+
+## Fase 1 — diagnóstico e relatório
+
+- [x] Página Diagnóstico: os cinco medidores se movem e o gráfico de 60 s preenche
+- [x] GPU aparece com valor numa máquina com placa dedicada (medido: 14%, 1,9 GB de VRAM)
+- [x] Temperatura aparece como "indisponível", nunca como 0 °C
+- [ ] Sair da página Diagnóstico para a coleta (conferir no log a linha de custo)
+- [ ] Achados não piscam: um que apareceu continua na tela por pelo menos 30 s
+- [ ] Botão de ação de cada achado leva ao lugar certo (Segurança do Windows, vídeo, energia)
+- [x] `--report saida.html` gera arquivo que abre em qualquer navegador, sem link externo
+- [x] `--report saida.json` gera JSON válido
+- [x] Custo da coleta abaixo de 1,5% de CPU em máquina fraca (medido: 0,115% com 20 núcleos)
+- [ ] Numa máquina bem cuidada, a nota fica acima de 90 e quase não há achados
+
+## Fase 2 — limpeza e ferramentas
+
+- [x] Varredura de limpeza mede o disco real (medido: 22,3 GB encontrados, 4,8 GB no preset seguro)
+- [x] Shader cache e prefetch aparecem desmarcados, com a advertência visível
+- [x] `Downloads` aparece bloqueado, com "o GameBoost nunca remove arquivo daqui"
+- [x] Cache de navegador aberto aparece bloqueado, pedindo para fechar
+- [x] `--clean --preset seguro --dry-run` não remove nada
+- [x] Teste de velocidade de disco apaga o arquivo de 1 GB, inclusive se falhar
+- [x] Informações do sistema leem dados reais da máquina
+- [ ] Limpeza real: rodar duas vezes seguidas, segunda libera ~0
+- [ ] Reiniciar o Explorer devolve a barra de tarefas
+- [ ] Reiniciar o driver de vídeo não derruba jogo aberto
+- [ ] Ponto de restauração aparece na Restauração do Sistema do Windows
+- [ ] `sfc /scannow` mostra a saída ao vivo e não parece travado
+
+## Fase 3 — analisador de espaço
+
+- [x] Varredura do disco do sistema (medido: 1.548.745 arquivos, 809,5 GB, em 18 a 20 s)
+- [x] Soma bate com o espaço ocupado, e o que falta é declarado no rodapé
+- [x] Treemap desenha proporcional e colorido por categoria
+- [x] Biblioteca lê Steam e Epic com tamanho e último jogo (14 jogos, 974 GB)
+- [x] Contador de pastas inacessíveis reporta o número real (543, não 40.871)
+- [x] Memória com a árvore aberta (medido: 594 MB para 1,5 milhão de nós)
+- [ ] Clicar num bloco do treemap desce um nível, e Subir volta
+- [x] Enviar um arquivo para a Lixeira pela página e conferir que dá para restaurar
+- [ ] Varredura de um segundo volume (D:)
+- [ ] Cancelar a varredura no meio deixa a interface utilizável
+
+## Fase 4 — desinstalador e inicialização
+
+- [x] Inventário lê a máquina real (medido: 217 apps, 113 da Store, 78 protegidos)
+- [x] Nada vem pré-marcado, nem o bloatware mais óbvio (rodapé abre em "Aplicar 0 selecionados")
+- [x] IDEs e apps de desenvolvimento aparecem na lista e **nunca** pré-marcados (regra 3)
+- [x] Runtimes, drivers e antivírus aparecem bloqueados com o motivo visível
+- [x] Total declarado é plausível (1044 GB para 2145 GB de disco; antes dizia 1812 GB)
+- [x] Lista ordenada pelo tamanho **medido**, não pelo declarado no registro
+- [x] Aba "Restos de apps antigos" sem falso positivo óbvio (30 pastas, 3,9 GB)
+- [x] Inicialização lê registro e pastas (medido: 26 entradas, 4 bloqueadas, 8 sugeridas)
+- [x] O número bate com o que o módulo de Diagnóstico informa
+- [x] Dry-run da inicialização não escreve `ChangeRecord` nenhum
+- [x] App da Store em WindowsApps não é acusado de "sem assinatura digital"
+- [x] Desinstalar um app de verdade (medido: Call of Duty, 180,3 GB; 217→216 apps, 1044→863,7 GB)
+- [ ] Desinstalar um app da Store (`Remove-AppxPackage`)
+- [x] Desinstalar um app cujo desinstalador abre janela própria (o GameBoost espera, não trava)
+- [x] Desativar um item e conferir no Gerenciador de Tarefas (medido: WallpaperEngine,
+      byte 0x03 + FILETIME, "Desabilitado" nos dois lados)
+- [x] Reverter a desativação e conferir que o programa volta a abrir no boot
+- [x] Enviar uma pasta de resto para a Lixeira (medido: qwen-updater, 119 MB, restaurável)
+
+## Complemento da Fase 4 — aba Atualizações (winget)
+
+- [x] winget detectado e versão lida (medido: 1.29.290)
+- [x] Tabela lida por posição, não por idioma (teste com cabeçalho em português)
+- [x] Lista bate com `winget upgrade` rodado à mão (medido: 35 atualizações)
+- [x] Nenhum id sai com espaço no meio; toda fonte é winget ou msstore
+- [x] Driver aparece bloqueado com o motivo
+- [x] Runtime e "atualiza sozinho" aparecem com risco médio e explicação
+- [x] Atualização de segurança marcada só em quem abre arquivo da internet
+- [x] "Chrome Remote Desktop Host" **não** é marcado como navegador
+- [x] App aberto é detectado e a linha avisa "feche antes"
+- [x] Nada pré-marcado, nem a atualização de segurança
+- [x] Abas legíveis no tema escuro
+- [x] Controles dentro das abas visíveis para a automação (leitor de tela)
+- [x] Aba "Restos de apps antigos" na interface (medido: 30 pastas, 3,8 GB)
+- [x] Atualizar um app de verdade (medido: 7-Zip 24.09 → 26.03)
+- [ ] Atualizar um app que está aberto e conferir a mensagem de erro
+- [ ] Atualizar um app que falha e conferir o código traduzido e o link do log
+- [x] Conferir o `updates-history.json` depois de uma atualização real
+- [ ] Máquina sem winget: conferir o cartão e o botão da Store
+- [ ] Windows em inglês: conferir que a tabela continua sendo lida
+
+## Fase 5 — tweaks, serviços, rede e drivers
+
+- [x] Catálogo lê o estado real de cada ajuste (medido: 24 itens, 1 já ativo)
+- [x] Nada pré-marcado, nem o que está marcado como recomendado
+- [x] VBS aparece bloqueado e só informativo
+- [x] Windows Update e Defender aparecem bloqueados com o motivo
+- [x] Ajuste que só precisa de elevação diz "Precisa de admin", não "Protegido"
+- [x] Estado da hibernação lido do registro, correto sem elevação
+- [x] Dry-run dos tweaks não escreve ChangeRecord nenhum
+- [x] NAT classificado como aberto/moderado/estrito (medido: aberto, semáforo verde)
+- [x] STUN devolve endereço público de verdade, nunca um privado
+- [x] CGNAT, NAT duplo, UPnP, Teredo e firewall detectados e explicados
+- [x] Teste de velocidade recusa sair para a rede sem a permissão, e diz por quê
+- [x] Driver de vídeo lido com versão de marketing (medido: GTX 1660 Ti, 616.64, 0 meses)
+- [x] Adaptador virtual do Hyper-V não entra na lista de placas
+- [x] Aplicar um tweak de HKCU elevado e conferir a chave (mouse: 1/6/10 viraram 0/0/0)
+- [x] Reverter tweak cujo valor **não existia**: `VisualFXSetting` foi apagado, não zerado
+- [x] Mudar um serviço para Manual e conferir (WSearch: Automatic → Manual)
+- [x] Reverter o serviço e conferir que o estado de execução também volta
+- [ ] Trocar o DNS do adaptador e reverter para automático (DHCP)
+- [ ] Reativar o Teredo numa máquina onde ele está desligado e conferir `netsh interface teredo show state`
+- [x] Teste de velocidade comparado com teste dedicado (medido: -15%, dentro do esperado)
+- [ ] Máquina em CGNAT: conferir que o diagnóstico acusa e não sugere abrir porta
+- [ ] Máquina com NAT duplo: conferir a contagem de saltos privados
+- [ ] Comparar a classificação de NAT com o que o app do Xbox mostra na mesma rede
+- [ ] Máquina no Wi-Fi: conferir SSID, padrão e banda
+
+## Fase 6 — perfis, bandeja e onboarding
+
+- [x] Perfil grava e lê de volta, com afinidade e timer
+- [x] Perfil novo nunca vem com "ativa sozinho" marcado
+- [x] Afinidade recusa índice de núcleo que não existe na máquina (medido: 20 núcleos)
+- [x] Afinidade com lista vazia devolve todos os núcleos
+- [x] Varredura de janelas para tela cheia responde rápido (medido: 3 ms)
+- [x] Biblioteca cruza com perfis (medido: 14 jogos, 974,2 GB, 0 com perfil)
+- [x] Ícone na bandeja aparece e o vigia inicia (confirmado no log)
+- [x] Onboarding aparece na primeira abertura e é alcançável pela automação
+- [x] Abrir um jogo de verdade e conferir o convite (medido: Warframe, confiança 80, tela cheia)
+- [x] Aceitar o convite e conferir que o perfil é aplicado (prioridade Normal → AboveNormal)
+- [x] Fechar o jogo e conferir o comportamento (prioridade morre com o processo; o texto diz isso)
+- [ ] Marcar "ativa sozinho" e conferir que o próximo boot do jogo não pergunta
+- [x] Recusar o convite e conferir que ele não volta na mesma sessão
+- [ ] Matar o GameBoost com perfil aplicado e conferir o aviso na reabertura
+- [x] Fechar a janela e conferir que o app fica na bandeja, com o aviso uma vez só
+- [x] "Sair" da bandeja encerra o processo de verdade
+- [ ] "Limpar RAM" pela bandeja com o app minimizado
+- [ ] Onboarding marcado como concluído não volta na segunda abertura
+- [x] Anti-cheat: o jogo aparece na lista do Modo Game como **Protegido**, com "Este parece
+      ser o jogo", risco Alto e caixa desabilitada
+- [x] Atualizador de launcher (Agent do Battle.net) **não** é detectado como jogo
+- [ ] Perfil com afinidade num jogo real: conferir no Gerenciador de Tarefas
+
+## Fase 7 — distribuição
+
+- [x] Modo portátil grava tudo em `.\data\` ao lado do exe (medido com o binário real)
+- [x] Modo portátil não deixa nada em `%LOCALAPPDATA%\GameBoost`
+- [x] Serviço de atualização sempre explica por que não pode verificar
+- [x] YAML do workflow de release é válido (14 passos)
+- [x] `#ifndef AppVersion` deixa o CI passar a versão
+- [ ] Rodar o workflow de release por `workflow_dispatch` e conferir os artefatos
+- [ ] Instalar pelo `.exe` gerado e conferir o atalho e a entrada em Programas
+- [ ] Instalar "só para o usuário atual" sem senha de administrador
+- [ ] Instalar "para todos" e conferir que o autostart foi para HKLM
+- [ ] Desinstalar e conferir que não sobra chave de autostart
+- [ ] Marcar a limpeza semanal e conferir a tarefa em `taskschd.msc`
+- [ ] Publicar uma release e conferir que o auto-update encontra a versão nova
+- [ ] Aplicar a atualização e conferir que a versão mudou
+- [ ] Anotar exatamente o que o SmartScreen diz no primeiro download
+- [ ] Conferir se o Defender bloqueia o instalador ou a execução
+- [ ] Submeter ao Microsoft Security Intelligence se houver falso positivo
+
+## Ambiente
+
+- [x] **Usuário sem admin**: varreduras funcionam, botões de ação desabilitados com aviso
+      visível de modo somente leitura
+- [ ] Windows 10 22H2
+- [ ] Windows 11 24H2 ou mais novo
+- [ ] Máquina com 8 GB de RAM (é onde a limpeza de RAM rende de verdade)
+- [ ] Notebook com iGPU + dGPU
+- [ ] Dois usuários logados: processos da outra sessão não aparecem
+- [ ] Monitor 4K e escala de 150% (DPI per-monitor v2)
+
+## Distribuição
+
+- [ ] SmartScreen: anotar exatamente o que aparece no primeiro download
+- [ ] Windows Defender não bloqueia o instalador nem a execução
+- [ ] Submeter ao Microsoft Security Intelligence se houver falso positivo
+- [ ] Instalação limpa em máquina sem .NET instalado (publish é self-contained)
+- [ ] Desinstalação não deixa `%LOCALAPPDATA%\GameBoost` com dados do usuário sem avisar
+
+## Desempenho
+
+- [ ] Varredura completa em menos de 5 s numa máquina com ~250 processos
+- [ ] A UI não congela durante a varredura (o botão Cancelar responde)
+- [ ] O app ocioso consome menos de 60 MB de RAM
+
+---
+
+## Observações de execução
+
+| Data | Item | Resultado |
+|---|---|---|
+| 14/09/2026 | QA manual bloco 6 (perfis, deteccao, bandeja) | **6 bugs achados**: a deteccao funcionava, o resto nao |
+| 14/09/2026 | QA manual bloco 5 (inicializacao) | **1 bug achado**: o Reverter nao revertia |
+| 14/09/2026 | QA manual bloco 4 (apps, restos, winget) | **1 crash achado e corrigido**: a Lixeira derrubava o app |
+| 14/09/2026 | QA manual blocos 2 e 3 (tweaks, servicos, rede) | **4 bugs achados e corrigidos**, depois passou |
+| 14/09/2026 | QA manual bloco 1 (reversibilidade) elevado, na maquina real | **6 bugs achados e corrigidos**, depois passou |
+| 14/09/2026 | Modo portatil com o binario real: data\ ao lado do exe | Passou |
+| 14/09/2026 | Perfis, afinidade, tela cheia, bandeja e onboarding | Passou apos 2 correcoes |
+| 14/09/2026 | Telas de Jogos e onboarding renderizadas | Passou |
+| 14/09/2026 | winget: 35 atualizacoes lidas e classificadas | Passou apos 3 correcoes |
+| 14/09/2026 | Abas de Apps (Instalados, Atualizacoes, Restos) renderizadas | Passou |
+| 14/09/2026 | Tweaks, servicos, NAT, velocidade e driver de video (nao elevado) | Passou apos 4 correcoes |
+| 14/09/2026 | Telas de Tweaks e Rede renderizadas e conferidas | Passou |
+| 14/09/2026 | Inventario de apps, restos, inicializacao (nao elevado) | Passou. 217 apps, 30 restos, 26 entradas |
+| 14/09/2026 | Telas de Apps e Inicializacao renderizadas e conferidas | Passou apos 4 correcoes |
+| 13/09/2026 | Ciclo real ativar → desligar, com privilégios | **Passou.** Ver detalhe abaixo |
+| 13/09/2026 | `--scan`, `--report` (HTML, JSON e texto) no binário de produção | Passou |
+| 13/09/2026 | Custo da coleta | 0,115% de CPU, ciclo de 36 ms, em 20 núcleos |
+| 13/09/2026 | Telas Início e Diagnóstico | Passou, depois de corrigir um crash de XAML |
+
+### Ciclo real de reversibilidade — 13/09/2026
+
+Executado com o binário de produção (`requireAdministrator`), com todos os 129 processos da
+máquina em `NuncaEncerrar` e um único alvo descartável compilado para o teste.
+
+| Item | Antes | Com o Modo Game ativo | Depois de desligar |
+|---|---|---|---|
+| `GameDVR_Enabled` | `1` | `0` | `1` |
+| `UseNexusForGameBarEnabled` | não existia | `0` | **apagado** |
+| `ShowStartupPanel` | não existia | `0` | **apagado** |
+| `ToastEnabled` | não existia | `0` | **apagado** |
+| Plano de energia | Equilibrado | Alto desempenho | Equilibrado |
+| `wuauserv` | parado | parado (não foi tocado) | parado |
+| App marcado com ★ | rodando | encerrado | **reaberto** |
+
+Os três valores que **não existiam** foram apagados na reversão, não zerados — que é a
+diferença entre reverter e deixar um rastro. `state-backup.json` terminou com **0 pendências**.
+
+Ganho medido na ativação: RAM livre de 1,3 GB para 3,9 GB, com 13,2 GB retirados do working
+set de 462 processos.
diff --git a/GameBoost/docs/TWEAKS.md b/GameBoost/docs/TWEAKS.md
new file mode 100644
index 0000000..374e412
--- /dev/null
+++ b/GameBoost/docs/TWEAKS.md
@@ -0,0 +1,174 @@
+# Catálogo de tweaks
+
+Cada tweak: chave, valor, efeito real, evidência, risco e reversão. Todos desligados por
+padrão, aplicados individualmente, sempre com snapshot em `state-backup.json`.
+
+**A coluna "efeito real" é honesta por obrigação (regra 4).** Se um tweak é marginal, está
+escrito que é marginal.
+
+---
+
+## Implementados na Fase 5 (página Tweaks)
+
+Catálogo completo da seção 5.8, aplicado item a item, cada um com ChangeRecord
+antes da escrita. **Nada vem pré-marcado**, nem o que está marcado como
+recomendado: recomendação é informação, não consentimento.
+
+### Jogos
+
+| Tweak | Chave | Valor | Efeito real | Risco |
+|---|---|---|---|---|
+| Agendamento de GPU por hardware (HAGS) | `HKLM\SYSTEM\CurrentControlSet\Control\GraphicsDrivers` → `HwSchMode` | `2` | Obrigatório para o Frame Generation do DLSS 3. Em RTX 30+ e RX 6000+ com driver atual costuma melhorar a regularidade dos quadros; em CPU antiga pode piorar. Usa até 1 GB de VRAM. **Exige reinício** | Médio |
+| Modo Jogo do Windows | `HKCU\Software\Microsoft\GameBar` → `AutoGameModeEnabled` | `1` | No 22H2+ segura o Windows Update e a instalação de driver durante o jogo, que é o ganho concreto. Recomendado | Baixo |
+| Gravação em segundo plano (Game DVR) | `HKCU\System\GameConfigStore` → `GameDVR_Enabled` e `HKCU\Software\Microsoft\GameBar` → `UseNexusForGameBarEnabled` | `0` | Desliga a gravação contínua. Ganho real em máquina modesta, pequeno em PC forte. Perde o atalho de gravar os últimos 30 s | Baixo |
+| Prioridade da categoria Jogos | `HKLM\...\SystemProfile\Tasks\Games` → `GPU Priority`=8, `Priority`=6, `Scheduling Category`=High | — | **Marginal.** Nenhuma medição pública consistente mostra ganho em hardware atual. Está no catálogo por ser reversível e sem custo, não por render FPS | Baixo |
+| Desativar Multi-Plane Overlay (MPO) | `HKLM\SOFTWARE\Microsoft\Windows\Dwm` → `OverlayTestMode` | `5` | Só vale com o sintoma: piscada preta, tremulação ou stutter na área de trabalho, comum em NVIDIA com dois monitores. **Não dá FPS.** Exige reinício | Médio |
+
+### Sistema
+
+| Tweak | Chave | Valor | Efeito real | Risco |
+|---|---|---|---|---|
+| Reserva de CPU para tarefas de fundo | `HKLM\...\SystemProfile` → `SystemResponsiveness` | `0` | **Marginal.** Devolve ao primeiro plano os 20% que o Windows reserva para multimídia de fundo. Pode causar engasgo em gravação e transmissão — o padrão 20 existe para proteger áudio | Baixo |
+| Efeitos visuais no melhor desempenho | `HKCU\...\Explorer\VisualEffects` → `VisualFXSetting` | `2` | Ajuda só em máquina fraca ou sem GPU dedicada. Não afeta jogo em tela cheia, que nem passa pelo DWM | Baixo |
+
+### Rede
+
+| Tweak | Chave | Valor | Efeito real | Risco |
+|---|---|---|---|---|
+| Desativar limite de tráfego multimídia | `HKLM\...\SystemProfile` → `NetworkThrottlingIndex` | `0xFFFFFFFF` | **Marginal.** O limite de 10 pacotes/ms foi criado para placas de rede de 2007 e praticamente não morde em hardware atual | Baixo |
+
+### Mouse e teclado
+
+| Tweak | Chave | Valor | Efeito real | Risco |
+|---|---|---|---|---|
+| Desativar aceleração do mouse | `HKCU\Control Panel\Mouse` → `MouseSpeed`, `MouseThreshold1`, `MouseThreshold2` | `0` | Consistência de mira, não desempenho. Jogos que usam Raw Input já ignoram isto. Vai atrapalhar quem está acostumado com a aceleração ligada | Baixo |
+
+### Energia
+
+| Tweak | Onde | Efeito real | Risco |
+|---|---|---|---|
+| Desativar limitação de energia do processador | `HKLM\SYSTEM\CurrentControlSet\Control\Power\PowerThrottling` → `PowerThrottlingOff` = 1 | Faz diferença em notebook, onde a limitação é agressiva. Em desktop na tomada, quase nada. Custa consumo e temperatura | Baixo |
+| Desativar hibernação | `powercfg /h off` | Libera em disco o equivalente à RAM instalada. Perde hibernação e Inicialização Rápida, e o boot fica alguns segundos mais lento. Vale por espaço, não por desempenho | Médio |
+
+### Segurança: aparece, explica e não mexe
+
+| Item | Por quê |
+|---|---|
+| Isolamento de núcleo (VBS) | Aparece **só de leitura**. As medições da comunidade põem o custo entre 5% e 15% em jogos limitados por CPU, e em troca é o que impede um driver malicioso de ler a memória do sistema. Num PC que também é banco e trabalho, desligar é troca ruim; num PC só de jogo é escolha defensável — do dono, na tela da Microsoft. O botão abre Segurança do Windows |
+| Mitigações de Spectre/Meltdown | **Não estão no catálogo, nem bloqueadas.** Item na tela vira ideia na cabeça de alguém. Desligar rende alguns por cento em CPU antiga e abre um buraco de segurança real |
+
+### Como o estado é lido
+
+Um tweak "desligado" quase nunca significa valor zero: na maioria das chaves
+significa **valor ausente**, com o Windows assumindo o padrão. Por isso a
+reversão apaga o valor quando ele não existia antes, em vez de gravar zero —
+confundir os dois é o que faz ferramenta de tweak deixar lixo que nunca sai.
+
+A hibernação é lida do registro (`HibernateEnabled`, com `HibernateEnabledDefault`
+como fallback), não pela existência de `C:\hiberfil.sys`: aquele arquivo é de
+sistema e `File.Exists` devolve falso sem elevação, o que faria o app dizer "já
+desligada" para quem abriu sem ser administrador.
+
+---
+
+## Serviços do Windows (seção 5.7, Fase 5)
+
+Régua diferente da dos tweaks: um serviço desligado por engano não tira alguns
+FPS, tira a impressora, a busca ou o Game Pass.
+
+### Dá para desativar
+
+| Serviço | Sugestão | O que você perde |
+|---|---|---|
+| `DiagTrack` | Desativado | Nada de sistema. O motivo de desligar é privacidade, não FPS |
+| `MapsBroker` | Desativado | Mapas offline do aplicativo Mapas |
+| `RemoteRegistry` | Desativado | Nada. Já vem desativado no Windows doméstico |
+| `WMPNetworkSvc` | Desativado | Compartilhar a biblioteca do Media Player na rede |
+| `Fax` | Desativado | Fax por modem |
+| `WSearch` | Manual | A busca do Iniciar e do Explorer fica lenta. Vale em HDD; em SSD o índice compensa |
+| `Spooler` | Manual | Impressão, **inclusive salvar em PDF** |
+
+### Aparece para explicar por que **não** mexer
+
+| Serviço | Por quê |
+|---|---|
+| `SysMain` | Toda lista de otimização manda desligar, e está errada. Em SSD ele quase não faz leitura antecipada; o que faz hoje é gerenciar memória. Desligar não devolve RAM, devolve cache — e o Windows usa RAM livre para cache de qualquer jeito |
+| `XblAuthManager`, `XboxNetApiSvc` | Sem eles o Game Pass não abre e alguns anti-cheat falham. Parados não custam nada; desligados quebram o Game Pass |
+| `wuauserv` | Nunca desativar. Máquina sem atualização de segurança é problema maior que qualquer FPS. O Modo Game já pausa o Update durante o jogo e religa depois |
+| `WinDefend`, `SecurityHealthService` | O GameBoost não desliga antivírus, nem o do Windows nem o de terceiros |
+
+---
+
+## Implementados na Fase 0 (Modo Game)
+
+Aplicados em bloco pelo Modo Game, revertidos no desligamento. Ver
+[`SystemSilencer`](../src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs).
+
+| Tweak | Chave | Valor | Efeito real | Risco |
+|---|---|---|---|---|
+| Notificações do Windows | `HKCU\Software\Microsoft\Windows\CurrentVersion\PushNotifications` → `ToastEnabled` | `0` | Impede notificação aparecendo sobre o jogo em tela cheia. Efeito de conforto, não de FPS | Baixo |
+| Game DVR | `HKCU\System\GameConfigStore` → `GameDVR_Enabled` | `0` | Desliga gravação contínua em segundo plano. Ganho real em máquina fraca; em PC forte é pequeno | Baixo |
+| Overlay da Game Bar | `HKCU\Software\Microsoft\GameBar` → `UseNexusForGameBarEnabled` | `0` | Evita a injeção do overlay em todo jogo aberto | Baixo |
+| Painel da Game Bar | `HKCU\Software\Microsoft\GameBar` → `ShowStartupPanel` | `0` | Só evita o painel aparecer ao abrir o jogo | Baixo |
+
+**Reversão:** cada um grava o valor anterior e o flag `ValorAnteriorExistia`. Quando a chave
+não existia, a reversão **apaga** o valor em vez de gravar zero.
+
+### Plano de energia
+
+Aplica **Desempenho Máximo** se existir, senão **Alto desempenho**; guarda o GUID do plano
+anterior e restaura no desligamento.
+
+| Plano | GUID |
+|---|---|
+| Balanceado | `381b4222-f694-41f0-9685-ff5bb260df2e` |
+| Alto desempenho | `8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c` |
+| Desempenho Máximo | `e9a42b02-d5df-448d-aa00-03f14749eb61` |
+| Economia de energia | `a1841308-3541-4fab-bc81-f71556f20b4a` |
+
+**Evidência:** é o item nº 1 do consenso técnico de 2026 (seção 3.4 do spec) — evita que a
+CPU baixe o clock no meio do jogo. Junto com a poda da inicialização, é o ajuste de maior
+valor e o mais fácil de reverter.
+
+### Pausa do Windows Update
+
+Para o serviço `wuauserv` (só para, nunca altera `StartType`). Grava `ChangeRecord` com
+`estavaRodando=true`.
+
+**Por que importa reverter:** um travamento com o Update pausado deixaria a máquina sem
+atualizações indefinidamente. Por isso a reversão acontece no desligamento, no "Reverter
+tudo", na próxima abertura após travamento **e** no desinstalador.
+
+---
+
+## Do catálogo da seção 5.8, o que ficou de fora
+
+Três itens do spec não entraram na Fase 5, e cada um tem um motivo diferente.
+
+| Tweak | Por que não entrou |
+|---|---|
+| Fullscreen Optimizations por executável | `GameDVR_FSEBehaviorMode` e `DISABLEDXMAXIMIZEDWINDOWEDMODE` são ajustes **por jogo**, não globais. O spec já diz "oferecer por perfil", e perfil por jogo é a Fase 6 |
+| Nagle (`TcpAckFrequency`, `TCPNoDelay`) | A chave fica em `...\Tcpip\Parameters\Interfaces\<GUID>`, uma por adaptador, e o ganho é marginal mesmo no melhor caso: a maioria dos jogos usa UDP, onde Nagle não existe. Entra junto com o perfil por jogo, que sabe qual jogo justifica mexer |
+| Timer resolution | O P/Invoke existe em `NativeMethodsBridge`, mas a resolução de timer só vale enquanto o processo que pediu está vivo. Faz sentido dentro da sessão do Modo Game, não como um botão que liga e desliga sozinho. Fase 6 |
+
+### Nunca alterados
+
+| Item | Por quê |
+|---|---|
+| **VBS / Core Isolation (Memory Integrity)** | Custo medido pela comunidade de 5 a 15% em jogos CPU-bound (até 25% em casos extremos), mas é proteção contra malware de kernel. O GameBoost **informa e mede, não desliga**: mostra o estado via WMI `Win32_DeviceGuard`, o impacto estimado e o caminho nas Configurações do Windows. Trade-off de PC exclusivo de jogo vs. máquina de trabalho/banco é decisão do usuário |
+| **Mitigações de Spectre/Meltdown** | Troca segurança real por poucos % |
+| **Defender, UAC, SmartScreen, assinatura de drivers** | Fora de escopo, sempre |
+| **Limpeza de registro** | Sem ganho mensurável. Risco puro (regra 4) |
+| **Desfragmentação de SSD** | Placebo, desgasta a unidade |
+| **Atualização automática de driver** | Instalar driver sozinho é risco. O GameBoost só detecta a idade e abre a página oficial |
+
+---
+
+## Detector de reset pós-update
+
+Atualizações grandes do Windows (24H2, 26H2) **resetam** Game Mode, HAGS, plano de energia,
+efeitos visuais e Game Bar. Nenhum concorrente avisa disso.
+
+Planejado para a Fase 1 como `Finding`: guardar a build do Windows junto do perfil aplicado
+e, quando a build mudar e os valores não baterem mais, mostrar *"a atualização 26H2 desfez 4
+ajustes seus"* com o botão de reaplicar.
diff --git a/GameBoost/installer/GameBoost.iss b/GameBoost/installer/GameBoost.iss
new file mode 100644
index 0000000..f88987c
--- /dev/null
+++ b/GameBoost/installer/GameBoost.iss
@@ -0,0 +1,100 @@
+; Instalador do GameBoost (Inno Setup 6).
+; Compilar com:  ISCC.exe installer\GameBoost.iss
+; Antes, publicar:  dotnet publish src\GameBoost.App\GameBoost.App.csproj -c Release -o publish
+
+#define AppName    "GameBoost"
+; O CI passa a versao com /DAppVersion=X.Y.Z. O valor abaixo so vale quando
+; o ISCC e chamado a mao, sem o parametro.
+#ifndef AppVersion
+  #define AppVersion "2.0.0"
+#endif
+#define AppAutor   "Jonathan Vaz"
+#define AppExe     "GameBoost.exe"
+
+[Setup]
+AppId={{7C3F9A21-4E8B-4A6D-9F2C-8B1D5E7A3C90}
+AppName={#AppName}
+AppVersion={#AppVersion}
+AppVerName={#AppName} {#AppVersion}
+AppPublisher={#AppAutor}
+DefaultDirName={autopf}\{#AppName}
+DefaultGroupName={#AppName}
+OutputDir=Output
+OutputBaseFilename={#AppName}-Setup-{#AppVersion}
+Compression=lzma2/max
+SolidCompression=yes
+WizardStyle=modern
+ArchitecturesAllowed=x64compatible
+ArchitecturesInstallIn64BitMode=x64compatible
+; O app encerra processos, controla servicos e purga a Standby List, entao
+; precisa de admin para RODAR. Instalar, porem, pode ser so para o usuario
+; atual: quem nao tem a senha de administrador da maquina ainda consegue
+; instalar em %LOCALAPPDATA% e usar o app em modo somente leitura.
+;
+; "dialog" faz o Inno perguntar na primeira tela. A resposta muda {autopf}
+; entre "Program Files" e a pasta local do usuario.
+PrivilegesRequired=lowest
+PrivilegesRequiredOverridesAllowed=dialog commandline
+UninstallDisplayIcon={app}\{#AppExe}
+MinVersion=10.0.17763
+
+[Languages]
+Name: "brazilianportuguese"; MessagesFile: "compiler:Languages\BrazilianPortuguese.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "Criar atalho na area de trabalho"; GroupDescription: "Atalhos:"
+Name: "startminimized"; Description: "Iniciar o GameBoost junto com o Windows, minimizado na bandeja"; GroupDescription: "Inicializacao:"; Flags: unchecked
+; Desligada por padrao de proposito: agendamento so com escolha explicita do usuario.
+Name: "limpezasemanal"; Description: "Agendar limpeza semanal com o preset seguro"; GroupDescription: "Manutencao:"; Flags: unchecked
+
+[Files]
+Source: "..\publish\{#AppExe}"; DestDir: "{app}"; Flags: ignoreversion
+Source: "..\README.md";         DestDir: "{app}"; DestName: "LEIA-ME.txt"; Flags: ignoreversion isreadme
+
+[Icons]
+Name: "{group}\{#AppName}";                 Filename: "{app}\{#AppExe}"
+Name: "{group}\Desinstalar {#AppName}";     Filename: "{uninstallexe}"
+Name: "{autodesktop}\{#AppName}";           Filename: "{app}\{#AppExe}"; Tasks: desktopicon
+
+[Registry]
+; HKA resolve para HKCU numa instalacao so do usuario e para HKLM numa
+; instalacao para todos. Fixar HKCU faria a opcao "todos os usuarios" gravar
+; o autostart so para quem rodou o instalador.
+Root: HKA; Subkey: "Software\Microsoft\Windows\CurrentVersion\Run"; ValueType: string; \
+    ValueName: "GameBoost"; ValueData: """{app}\{#AppExe}"" --minimizado"; \
+    Flags: uninsdeletevalue; Tasks: startminimized
+
+[Run]
+Filename: "{app}\{#AppExe}"; Description: "Abrir o {#AppName}"; Flags: nowait postinstall skipifsilent
+
+; Tarefa semanal opcional, aos domingos as 10h.
+Filename: "{sys}\schtasks.exe"; \
+    Parameters: "/Create /F /TN ""GameBoost - Limpeza semanal"" /SC WEEKLY /D SUN /ST 10:00 /RL HIGHEST /TR ""\""{app}\{#AppExe}\"" --clean --preset seguro"""; \
+    Flags: runhidden; Tasks: limpezasemanal
+
+[UninstallRun]
+; Regra 1: o desinstalador desfaz as alteracoes de sistema ANTES de remover o app.
+; Sem isto, desinstalar com o Modo Game ativo deixaria o Windows Update pausado
+; e o plano de energia trocado para sempre.
+Filename: "{app}\{#AppExe}"; Parameters: "--revert-all"; Flags: runhidden waituntilterminated; RunOnceId: "ReverterTudo"
+Filename: "{sys}\schtasks.exe"; Parameters: "/Delete /F /TN ""GameBoost - Limpeza semanal"""; Flags: runhidden; RunOnceId: "RemoverTarefa"
+
+[UninstallDelete]
+Type: filesandordirs; Name: "{app}\data"
+
+[Code]
+// Os dados do usuario (preferencias, historico, log) ficam fora de {app} e nao sao
+// apagados sem pergunta.
+procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
+var
+  Dados: String;
+begin
+  if CurUninstallStep = usPostUninstall then
+  begin
+    Dados := ExpandConstant('{localappdata}\GameBoost');
+    if DirExists(Dados) then
+      if MsgBox('Remover tambem suas preferencias, historico e log?' + #13#10 + #13#10 + Dados,
+                mbConfirmation, MB_YESNO) = IDYES then
+        DelTree(Dados, True, True, True);
+  end;
+end;
diff --git a/GameBoost/installer/NOTAS-DA-RELEASE.md b/GameBoost/installer/NOTAS-DA-RELEASE.md
new file mode 100644
index 0000000..48a6123
--- /dev/null
+++ b/GameBoost/installer/NOTAS-DA-RELEASE.md
@@ -0,0 +1,36 @@
+## O que baixar
+
+| Arquivo | Para quem |
+|---|---|
+| `GameBoost-Setup-*.exe` | A maioria. Instala, cria atalho e habilita a atualização automática |
+| `GameBoost-*-portatil.zip` | Pen drive, máquina de terceiro, ou quem não quer instalar nada. Guarda os dados ao lado do executável e **não** se atualiza sozinho |
+| `GameBoost.exe` | O executável solto, para quem sabe o que quer |
+| `SHA256SUMS.txt` | Conferir que o download veio inteiro |
+
+Os arquivos `.nupkg` e `*-full.nupkg` são do mecanismo de atualização. Não
+precisam ser baixados à mão.
+
+## Aviso do SmartScreen
+
+Esta versão pode não estar assinada. Se aparecer *"O Windows protegeu o
+computador"*, o caminho é **Mais informações → Executar assim mesmo**.
+
+Antes disso, se quiser conferir que o arquivo é o mesmo que saiu daqui:
+
+```powershell
+Get-FileHash .\GameBoost-Setup-2.0.0.exe -Algorithm SHA256
+```
+
+e comparar com a linha correspondente do `SHA256SUMS.txt`.
+
+O porquê de não estar assinado, e o que está sendo feito a respeito, está em
+[docs/ASSINATURA.md](../docs/ASSINATURA.md).
+
+## O que ele faz
+
+Todo o resto está no [README](../README.md). O resumo em três linhas:
+
+- Tudo o que ele altera, ele desfaz. O valor anterior vai para o histórico antes
+  da escrita, e cada ação tem botão de desfazer.
+- Não tem telemetria. Nenhum dado sai da máquina.
+- Quando um ajuste é marginal, está escrito que é marginal.
diff --git a/GameBoost/src/GameBoost.App/App.xaml b/GameBoost/src/GameBoost.App/App.xaml
new file mode 100644
index 0000000..2a3fac4
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/App.xaml
@@ -0,0 +1,64 @@
+<Application x:Class="GameBoost.App.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="clr-namespace:GameBoost.App.ViewModels"
+             xmlns:views="clr-namespace:GameBoost.App.Views">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="Themes/Dark.xaml" />
+                <!-- Conversores antes de Controles.xaml: os templates de la usam estes recursos. -->
+                <ResourceDictionary Source="Themes/Conversores.xaml" />
+                <ResourceDictionary Source="Themes/Controles.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+
+            <!--
+              Mapeamento pagina -> view. O shell so guarda ViewModels; o WPF
+              escolhe a tela. Um modulo novo que herde de ModulePageViewModel
+              cai automaticamente no template generico de ModuloPage.
+            -->
+            <DataTemplate DataType="{x:Type vm:InicioPageViewModel}">
+                <views:InicioPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:DiagnosticoPageViewModel}">
+                <views:DiagnosticoPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:EspacoPageViewModel}">
+                <views:EspacoPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:FerramentasPageViewModel}">
+                <views:FerramentasPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:PlaceholderPageViewModel}">
+                <views:PlaceholderPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:ConfiguracoesPageViewModel}">
+                <views:ConfiguracoesPage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:JogosPageViewModel}">
+                <views:JogosPage />
+            </DataTemplate>
+
+            <!-- A pagina de Apps tem tres abas, entao tem tela propria. -->
+            <DataTemplate DataType="{x:Type vm:AppsPageViewModel}">
+                <views:AppsPage />
+            </DataTemplate>
+
+            <!-- A Rede vem antes do generico: ela tem tela propria, com as
+                 tabelas de medicao acima da lista de acoes. -->
+            <DataTemplate DataType="{x:Type vm:RedePageViewModel}">
+                <views:RedePage />
+            </DataTemplate>
+
+            <DataTemplate DataType="{x:Type vm:ModulePageViewModel}">
+                <views:ModuloPage />
+            </DataTemplate>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/GameBoost/src/GameBoost.App/App.xaml.cs b/GameBoost/src/GameBoost.App/App.xaml.cs
new file mode 100644
index 0000000..59fd2bb
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/App.xaml.cs
@@ -0,0 +1,235 @@
+using System.Windows;
+using GameBoost.App.ViewModels;
+using GameBoost.App.Views;
+using GameBoost.Core;
+using GameBoost.Core.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GameBoost.App;
+
+/// <summary>
+/// Caminho grafico. Os comandos de linha nunca chegam aqui: Program os trata
+/// antes de o WPF existir.
+/// </summary>
+public partial class App : Application
+{
+    private IServiceProvider? _services;
+
+    public static IServiceProvider Services =>
+        ((App)Current)._services ?? throw new InvalidOperationException("Container ainda nao inicializado.");
+
+    protected override void OnStartup(StartupEventArgs e)
+    {
+        base.OnStartup(e);
+
+        // Sem isto o app morre com APPCRASH e nao deixa rastro nenhum: o log
+        // para na ultima acao bem-sucedida e nao ha stack trace em lugar algum.
+        DispatcherUnhandledException += AoFalharNaUi;
+        AppDomain.CurrentDomain.UnhandledException += AoFalharForaDaUi;
+        TaskScheduler.UnobservedTaskException += AoFalharEmTask;
+
+        var colecao = new ServiceCollection();
+        colecao.AddGameBoostCore();
+        colecao.AddSingleton<InicioPageViewModel>();
+        colecao.AddSingleton<DiagnosticoPageViewModel>();
+        colecao.AddSingleton<LimpezaPageViewModel>();
+        colecao.AddSingleton<EspacoPageViewModel>();
+        colecao.AddSingleton<AppsPageViewModel>();
+        colecao.AddSingleton<InicializacaoPageViewModel>();
+        colecao.AddSingleton<TweaksPageViewModel>();
+        colecao.AddSingleton<RedePageViewModel>();
+        colecao.AddSingleton<FerramentasPageViewModel>();
+        colecao.AddSingleton<JogosPageViewModel>();
+        colecao.AddSingleton<ConfiguracoesPageViewModel>();
+        colecao.AddSingleton<Services.BandejaDoSistema>();
+        colecao.AddSingleton<ShellViewModel>();
+        _services = colecao.BuildServiceProvider();
+
+        _services.GetRequiredService<IGameBoostLogger>().Info("App", "Startup", null,
+            $"v{typeof(App).Assembly.GetName().Version} admin={CoreServices.RodandoComoAdministrador()}");
+
+        var janela = new ShellWindow { DataContext = _services.GetRequiredService<ShellViewModel>() };
+        MainWindow = janela;
+        janela.Show();
+
+        // A bandeja vem primeiro: o vigia liga o convite nela.
+        LigarBandeja(janela);
+        LigarVigiaDeJogos();
+        MostrarOnboarding(janela);
+    }
+
+    // ==================================================================
+    // Bandeja (secao 6)
+    // ==================================================================
+
+    private Services.BandejaDoSistema? _bandeja;
+
+    private void LigarBandeja(ShellWindow janela)
+    {
+        var settings = _services!.GetRequiredService<Core.Settings.ISettingsStore>().Load();
+
+        if (!settings.MostrarNaBandeja)
+            return;
+
+        _bandeja = _services!.GetRequiredService<Services.BandejaDoSistema>();
+        var shell = _services!.GetRequiredService<ShellViewModel>();
+
+        _bandeja.AoAbrir += () => Dispatcher.Invoke(() =>
+        {
+            janela.Show();
+            janela.WindowState = WindowState.Normal;
+            janela.Activate();
+        });
+
+        _bandeja.AoSair += () => Dispatcher.Invoke(() =>
+        {
+            // Sair pela bandeja sai de verdade. Um programa que so finge
+            // fechar e continua rodando escondido e queixa legitima.
+            _saindoDeVez = true;
+            Shutdown();
+        });
+
+        _bandeja.AoAlternarModoGame += () => Dispatcher.Invoke(shell.AlternarModoGamePelaBandeja);
+        _bandeja.AoLimparRam += () => Dispatcher.Invoke(shell.LimparRamPelaBandeja);
+
+        _bandeja.Mostrar();
+        janela.Bandeja = _bandeja;
+    }
+
+    private bool _saindoDeVez;
+
+    /// <summary>True enquanto fechar a janela deve so esconder.</summary>
+    public bool EsconderEmVezDeFechar => _bandeja is { Visivel: true } && !_saindoDeVez;
+
+    // ==================================================================
+    // Deteccao automatica de jogo (secao 5.1)
+    // ==================================================================
+
+    private void LigarVigiaDeJogos()
+    {
+        var settings = _services!.GetRequiredService<Core.Settings.ISettingsStore>().Load();
+
+        if (!settings.DetectarJogosAutomaticamente)
+            return;
+
+        var vigia = _services!.GetRequiredService<Core.Modules.Profiles.GameWatcher>();
+        var shell = _services!.GetRequiredService<ShellViewModel>();
+
+        vigia.AoAbrir += evento => Dispatcher.Invoke(() => shell.JogoDetectado(evento));
+        vigia.AoFechar += evento => Dispatcher.Invoke(() => shell.JogoEncerrado(evento));
+
+        // Sem isto o convite morre no lugar onde nasce: o shell dispara o
+        // evento e ninguem escuta. O jogo era detectado, o log registrava a
+        // deteccao, e o usuario nao via nada em lugar nenhum.
+        //
+        // Balao E faixa, nao um ou outro: com o jogo em tela cheia o Windows
+        // engole o balao, e a faixa fica esperando na janela. Sem tela cheia,
+        // o balao chega primeiro.
+        shell.AoPedirAviso += (titulo, texto) => Dispatcher.Invoke(() =>
+            _bandeja?.Avisar(titulo, texto));
+
+        vigia.Iniciar();
+    }
+
+    // ==================================================================
+    // Onboarding (secao 6)
+    // ==================================================================
+
+    private void MostrarOnboarding(ShellWindow janela)
+    {
+        var store = _services!.GetRequiredService<Core.Settings.ISettingsStore>();
+        var settings = store.Load();
+
+        if (settings.OnboardingConcluido)
+            return;
+
+        var vm = new OnboardingViewModel();
+        var dialogo = new OnboardingWindow { DataContext = vm, Owner = janela };
+
+        vm.AoTerminar += abrirRelatorio =>
+        {
+            settings.OnboardingConcluido = true;
+            store.Save(settings);
+
+            dialogo.Close();
+
+            if (abrirRelatorio)
+                _services!.GetRequiredService<ShellViewModel>().AbrirRelatorioInicial();
+        };
+
+        dialogo.ShowDialog();
+    }
+
+    protected override void OnExit(ExitEventArgs e)
+    {
+        // Sair sem desfazer o perfil aplicado deixaria prioridade e tweaks de
+        // pe depois que o app sumiu. Isso e o oposto da regra 1.
+        //
+        // O GameWatcher NAO e descartado aqui: ele e singleton IDisposable, e o
+        // proprio container o descarta logo abaixo. Chamar nos dois lugares e o
+        // que fazia a excecao aparecer em toda saida.
+        try
+        {
+            _services?.GetService<Core.Modules.Profiles.ProfileRunner>()?.Desfazer();
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or ObjectDisposedException)
+        {
+            Registrar("Exit", ex);
+        }
+
+        try
+        {
+            _bandeja?.Dispose();
+            (_services as ServiceProvider)?.Dispose();
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or ObjectDisposedException)
+        {
+            // Falhar ao fechar nao pode virar caixa de erro: o app ja esta
+            // saindo e nao ha nada que o usuario possa fazer a respeito.
+            Registrar("Exit", ex);
+        }
+
+        base.OnExit(e);
+    }
+
+    private void AoFalharNaUi(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
+    {
+        Registrar("UI", e.Exception);
+
+        MessageBox.Show(
+            "O GameBoost encontrou um erro inesperado e registrou os detalhes no log."
+            + Environment.NewLine + Environment.NewLine
+            + e.Exception.Message,
+            "GameBoost", MessageBoxButton.OK, MessageBoxImage.Error);
+
+        // A janela continua de pe: um erro numa tela nao precisa derrubar o app.
+        e.Handled = true;
+    }
+
+    private void AoFalharForaDaUi(object sender, UnhandledExceptionEventArgs e)
+    {
+        if (e.ExceptionObject is Exception ex)
+            Registrar("Dominio", ex);
+    }
+
+    private void AoFalharEmTask(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        Registrar("Task", e.Exception);
+        e.SetObserved();
+    }
+
+    private void Registrar(string origem, Exception ex)
+    {
+        try
+        {
+            _services?.GetRequiredService<IGameBoostLogger>()
+                .Error("App", $"Excecao nao tratada ({origem})", ex.GetType().Name,
+                    ex.ToString().Replace(Environment.NewLine, " | "), ex);
+        }
+        catch (Exception)
+        {
+            // Falhar ao registrar a falha nao pode virar uma segunda falha.
+        }
+    }
+
+}
diff --git a/GameBoost/src/GameBoost.App/Controls/MiniGrafico.cs b/GameBoost/src/GameBoost.App/Controls/MiniGrafico.cs
new file mode 100644
index 0000000..0d19fe3
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Controls/MiniGrafico.cs
@@ -0,0 +1,126 @@
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace GameBoost.App.Controls;
+
+/// <summary>
+/// Grafico dos ultimos 60 segundos (secao 5.5).
+///
+/// Desenha em OnRender em vez de montar uma Polyline com centenas de pontos:
+/// a serie e trocada inteira a cada segundo, e recriar objetos visuais nesse
+/// ritmo apareceria no orcamento de CPU da propria coleta.
+/// </summary>
+public sealed class MiniGrafico : Control
+{
+    public static readonly DependencyProperty ValoresProperty = DependencyProperty.Register(
+        nameof(Valores), typeof(IReadOnlyList<double>), typeof(MiniGrafico),
+        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public static readonly DependencyProperty MaximoProperty = DependencyProperty.Register(
+        nameof(Maximo), typeof(double), typeof(MiniGrafico),
+        new FrameworkPropertyMetadata(100.0, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public static readonly DependencyProperty CorDaLinhaProperty = DependencyProperty.Register(
+        nameof(CorDaLinha), typeof(Brush), typeof(MiniGrafico),
+        new FrameworkPropertyMetadata(Brushes.Teal, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public static readonly DependencyProperty RotuloProperty = DependencyProperty.Register(
+        nameof(Rotulo), typeof(string), typeof(MiniGrafico),
+        new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public IReadOnlyList<double>? Valores
+    {
+        get => (IReadOnlyList<double>?)GetValue(ValoresProperty);
+        set => SetValue(ValoresProperty, value);
+    }
+
+    public double Maximo
+    {
+        get => (double)GetValue(MaximoProperty);
+        set => SetValue(MaximoProperty, value);
+    }
+
+    public Brush CorDaLinha
+    {
+        get => (Brush)GetValue(CorDaLinhaProperty);
+        set => SetValue(CorDaLinhaProperty, value);
+    }
+
+    public string Rotulo
+    {
+        get => (string)GetValue(RotuloProperty);
+        set => SetValue(RotuloProperty, value);
+    }
+
+    protected override void OnRender(DrawingContext dc)
+    {
+        base.OnRender(dc);
+
+        var largura = ActualWidth;
+        var altura = ActualHeight;
+
+        if (largura <= 1 || altura <= 1)
+            return;
+
+        // Linhas de grade em 25, 50 e 75%.
+        var grade = new Pen(new SolidColorBrush(Color.FromArgb(30, 255, 255, 255)), 1);
+        grade.Freeze();
+
+        for (var i = 1; i < 4; i++)
+        {
+            var y = altura * i / 4.0;
+            dc.DrawLine(grade, new Point(0, y), new Point(largura, y));
+        }
+
+        var valores = Valores;
+        if (valores is null || valores.Count < 2)
+        {
+            DesenharRotulo(dc, "aguardando dados", largura, altura);
+            return;
+        }
+
+        var maximo = Maximo <= 0 ? 1 : Maximo;
+        var passo = largura / Math.Max(valores.Count - 1, 1);
+
+        var linha = new Pen(CorDaLinha, 1.6) { LineJoin = PenLineJoin.Round };
+        linha.Freeze();
+
+        var geometria = new StreamGeometry();
+        using (var ctx = geometria.Open())
+        {
+            var primeiro = new Point(0, Y(valores[0], maximo, altura));
+            ctx.BeginFigure(primeiro, isFilled: false, isClosed: false);
+
+            for (var i = 1; i < valores.Count; i++)
+                ctx.LineTo(new Point(i * passo, Y(valores[i], maximo, altura)), isStroked: true, isSmoothJoin: false);
+        }
+
+        geometria.Freeze();
+        dc.DrawGeometry(null, linha, geometria);
+
+        if (!string.IsNullOrEmpty(Rotulo))
+            DesenharRotulo(dc, Rotulo, largura, altura);
+    }
+
+    private static double Y(double valor, double maximo, double altura)
+    {
+        var proporcao = Math.Clamp(valor / maximo, 0, 1);
+        return altura - proporcao * altura;
+    }
+
+    private void DesenharRotulo(DrawingContext dc, string texto, double largura, double altura)
+    {
+        var formatado = new FormattedText(
+            texto,
+            CultureInfo.CurrentUICulture,
+            FlowDirection.LeftToRight,
+            new Typeface("Segoe UI"),
+            10,
+            new SolidColorBrush(Color.FromArgb(140, 255, 255, 255)),
+            VisualTreeHelper.GetDpi(this).PixelsPerDip);
+
+        dc.DrawText(formatado, new Point(largura - formatado.Width - 2, altura - formatado.Height - 1));
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Controls/Treemap.cs b/GameBoost/src/GameBoost.App/Controls/Treemap.cs
new file mode 100644
index 0000000..b237b7c
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Controls/Treemap.cs
@@ -0,0 +1,293 @@
+using System.Globalization;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using GameBoost.Core.Modules.DiskAnalyzer;
+
+namespace GameBoost.App.Controls;
+
+/// <summary>Um retângulo desenhado, guardado para achar o nó sob o mouse.</summary>
+internal sealed record Bloco(DiskNode No, Rect Area);
+
+/// <summary>
+/// Treemap da seção 5.4: retângulos proporcionais ao tamanho, coloridos por
+/// categoria.
+///
+/// Usa o algoritmo "squarified": em vez de fatiar sempre na mesma direção, ele
+/// escolhe a cada passo a direção que deixa os retângulos mais próximos de
+/// quadrados. Fatias compridas e finas são impossíveis de clicar e não deixam
+/// comparar áreas a olho, que é justamente para o que o treemap serve.
+///
+/// Desenha em OnRender: um disco cheio tem milhares de blocos por nível, e
+/// criar objetos visuais para cada um travaria a navegação.
+/// </summary>
+public sealed class Treemap : Control
+{
+    private readonly List<Bloco> _blocos = new();
+    private DiskNode? _sobMouse;
+
+    public static readonly DependencyProperty RaizProperty = DependencyProperty.Register(
+        nameof(Raiz), typeof(DiskNode), typeof(Treemap),
+        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public static readonly DependencyProperty MaximoDeBlocosProperty = DependencyProperty.Register(
+        nameof(MaximoDeBlocos), typeof(int), typeof(Treemap),
+        new FrameworkPropertyMetadata(120, FrameworkPropertyMetadataOptions.AffectsRender));
+
+    public DiskNode? Raiz
+    {
+        get => (DiskNode?)GetValue(RaizProperty);
+        set => SetValue(RaizProperty, value);
+    }
+
+    /// <summary>Acima disso os retângulos ficam menores que o clique.</summary>
+    public int MaximoDeBlocos
+    {
+        get => (int)GetValue(MaximoDeBlocosProperty);
+        set => SetValue(MaximoDeBlocosProperty, value);
+    }
+
+    /// <summary>Disparado ao clicar num bloco que é pasta: o shell desce um nível.</summary>
+    public event Action<DiskNode>? AoEntrarNaPasta;
+
+    public event Action<DiskNode?>? AoPassarOMouse;
+
+    public Treemap()
+    {
+        ClipToBounds = true;
+        Cursor = Cursors.Hand;
+    }
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        base.OnMouseMove(e);
+
+        var no = Encontrar(e.GetPosition(this));
+        if (ReferenceEquals(no, _sobMouse))
+            return;
+
+        _sobMouse = no;
+        AoPassarOMouse?.Invoke(no);
+        InvalidateVisual();
+    }
+
+    protected override void OnMouseLeave(MouseEventArgs e)
+    {
+        base.OnMouseLeave(e);
+
+        _sobMouse = null;
+        AoPassarOMouse?.Invoke(null);
+        InvalidateVisual();
+    }
+
+    protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
+    {
+        base.OnMouseLeftButtonUp(e);
+
+        var no = Encontrar(e.GetPosition(this));
+
+        // Só pasta desce um nível: clicar num arquivo não leva a lugar nenhum.
+        if (no is { EhPasta: true, Filhos.Count: > 0 })
+            AoEntrarNaPasta?.Invoke(no);
+    }
+
+    private DiskNode? Encontrar(Point ponto)
+    {
+        for (var i = _blocos.Count - 1; i >= 0; i--)
+        {
+            if (_blocos[i].Area.Contains(ponto))
+                return _blocos[i].No;
+        }
+
+        return null;
+    }
+
+    protected override void OnRender(DrawingContext dc)
+    {
+        base.OnRender(dc);
+
+        _blocos.Clear();
+
+        var largura = ActualWidth;
+        var altura = ActualHeight;
+
+        if (largura <= 4 || altura <= 4)
+            return;
+
+        var fundo = new SolidColorBrush(Color.FromRgb(0x1C, 0x1F, 0x26));
+        fundo.Freeze();
+        dc.DrawRectangle(fundo, null, new Rect(0, 0, largura, altura));
+
+        var raiz = Raiz;
+        if (raiz is null || raiz.Tamanho <= 0)
+        {
+            Texto(dc, "Varra um disco para ver onde está o espaço", largura / 2, altura / 2, centralizado: true);
+            return;
+        }
+
+        var filhos = raiz.Filhos
+            .Where(f => f.Tamanho > 0)
+            .OrderByDescending(f => f.Tamanho)
+            .Take(MaximoDeBlocos)
+            .ToList();
+
+        if (filhos.Count == 0)
+        {
+            Texto(dc, "Pasta vazia", largura / 2, altura / 2, centralizado: true);
+            return;
+        }
+
+        Espalhar(dc, filhos, new Rect(1, 1, largura - 2, altura - 2));
+    }
+
+    /// <summary>
+    /// Coração do squarified: acumula itens numa faixa enquanto isso melhora a
+    /// proporção média dos retângulos, e fecha a faixa quando começa a piorar.
+    /// </summary>
+    private void Espalhar(DrawingContext dc, List<DiskNode> itens, Rect area)
+    {
+        var total = itens.Sum(i => (double)i.Tamanho);
+        if (total <= 0)
+            return;
+
+        var restantes = new List<DiskNode>(itens);
+
+        while (restantes.Count > 0 && area is { Width: > 1, Height: > 1 })
+        {
+            var somaRestante = restantes.Sum(i => (double)i.Tamanho);
+            var horizontal = area.Width >= area.Height;
+            var ladoFixo = horizontal ? area.Height : area.Width;
+
+            var faixa = new List<DiskNode>();
+            double somaFaixa = 0;
+            var melhorProporcao = double.MaxValue;
+
+            foreach (var item in restantes)
+            {
+                var candidata = somaFaixa + item.Tamanho;
+                var proporcao = PiorProporcao(faixa, item, candidata, somaRestante, area, ladoFixo);
+
+                if (faixa.Count > 0 && proporcao > melhorProporcao)
+                    break;
+
+                faixa.Add(item);
+                somaFaixa = candidata;
+                melhorProporcao = proporcao;
+            }
+
+            var fracao = somaFaixa / somaRestante;
+            var espessura = (horizontal ? area.Width : area.Height) * fracao;
+
+            var posicao = horizontal ? area.Top : area.Left;
+
+            foreach (var item in faixa)
+            {
+                var parte = somaFaixa <= 0 ? 0 : item.Tamanho / somaFaixa * ladoFixo;
+
+                var retangulo = horizontal
+                    ? new Rect(area.Left, posicao, espessura, parte)
+                    : new Rect(posicao, area.Top, parte, espessura);
+
+                Desenhar(dc, item, retangulo);
+                posicao += parte;
+            }
+
+            area = horizontal
+                ? new Rect(area.Left + espessura, area.Top, Math.Max(0, area.Width - espessura), area.Height)
+                : new Rect(area.Left, area.Top + espessura, area.Width, Math.Max(0, area.Height - espessura));
+
+            foreach (var item in faixa)
+                restantes.Remove(item);
+        }
+    }
+
+    private static double PiorProporcao(
+        List<DiskNode> faixa, DiskNode candidato, double somaComCandidato,
+        double somaRestante, Rect area, double ladoFixo)
+    {
+        if (somaComCandidato <= 0 || somaRestante <= 0)
+            return double.MaxValue;
+
+        var comprimento = (area.Width >= area.Height ? area.Width : area.Height)
+                        * (somaComCandidato / somaRestante);
+
+        if (comprimento <= 0)
+            return double.MaxValue;
+
+        var pior = 0.0;
+
+        foreach (var item in faixa.Append(candidato))
+        {
+            var lado = item.Tamanho / somaComCandidato * ladoFixo;
+            if (lado <= 0)
+                continue;
+
+            pior = Math.Max(pior, Math.Max(comprimento / lado, lado / comprimento));
+        }
+
+        return pior == 0 ? double.MaxValue : pior;
+    }
+
+    private void Desenhar(DrawingContext dc, DiskNode no, Rect area)
+    {
+        if (area.Width < 1 || area.Height < 1)
+            return;
+
+        _blocos.Add(new Bloco(no, area));
+
+        var cor = (Color)ColorConverter.ConvertFromString(DiskCategories.Cor(no.Categoria));
+        var destacado = ReferenceEquals(no, _sobMouse);
+
+        var preenche = new SolidColorBrush(cor) { Opacity = destacado ? 1.0 : 0.78 };
+        preenche.Freeze();
+
+        var borda = new Pen(new SolidColorBrush(Color.FromArgb(destacado ? (byte)255 : (byte)60, 20, 22, 26)),
+            destacado ? 2 : 1);
+        borda.Freeze();
+
+        // Deflate evita que bordas vizinhas se sobreponham e engrossem.
+        var desenho = Rect.Inflate(area, -0.5, -0.5);
+        if (desenho.Width <= 0 || desenho.Height <= 0)
+            desenho = area;
+
+        dc.DrawRectangle(preenche, borda, desenho);
+
+        // Rótulo só cabe em bloco grande; abaixo disso vira borrão.
+        if (area.Width > 64 && area.Height > 26)
+        {
+            Texto(dc, no.Nome, area.Left + 5, area.Top + 3, centralizado: false, maximo: area.Width - 10);
+
+            if (area.Height > 42)
+            {
+                Texto(dc, Core.Modules.GameMode.GameModeModule.Formatar(no.Tamanho),
+                    area.Left + 5, area.Top + 19, centralizado: false, maximo: area.Width - 10, opaco: true);
+            }
+        }
+    }
+
+    private void Texto(
+        DrawingContext dc, string texto, double x, double y,
+        bool centralizado, double maximo = double.MaxValue, bool opaco = false)
+    {
+        var formatado = new FormattedText(
+            texto,
+            CultureInfo.CurrentUICulture,
+            FlowDirection.LeftToRight,
+            new Typeface("Segoe UI"),
+            11.5,
+            new SolidColorBrush(Color.FromArgb(opaco ? (byte)190 : (byte)255, 13, 17, 23)),
+            VisualTreeHelper.GetDpi(this).PixelsPerDip)
+        {
+            MaxLineCount = 1,
+            Trimming = TextTrimming.CharacterEllipsis
+        };
+
+        if (maximo < double.MaxValue)
+            formatado.MaxTextWidth = Math.Max(10, maximo);
+
+        dc.DrawText(formatado, centralizado
+            ? new Point(x - formatado.Width / 2, y - formatado.Height / 2)
+            : new Point(x, y));
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Converters/Converters.cs b/GameBoost/src/GameBoost.App/Converters/Converters.cs
new file mode 100644
index 0000000..8b541b4
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Converters/Converters.cs
@@ -0,0 +1,107 @@
+using System.Globalization;
+using System.Windows;
+using System.Windows.Data;
+using System.Windows.Media;
+using GameBoost.Core.Modules;
+
+namespace GameBoost.App.Converters;
+
+/// <summary>Badge de risco: verde, amarelo, vermelho (secao 6 do spec).</summary>
+public sealed class RiscoParaCorConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        var chave = (value as RiskLevel?) switch
+        {
+            RiskLevel.Alto => "RiscoAlto",
+            RiskLevel.Medio => "RiscoMedio",
+            _ => "RiscoBaixo"
+        };
+
+        return Application.Current?.TryFindResource(chave) as Brush ?? Brushes.Gray;
+    }
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
+
+public sealed class BoolParaVisibilidadeConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        var visivel = value is true;
+        if (parameter as string == "inverter")
+            visivel = !visivel;
+
+        return visivel ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
+
+public sealed class InverterBoolConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => value is not true;
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => value is not true;
+}
+
+/// <summary>Mostra o elemento apenas quando o texto existe e nao esta vazio.</summary>
+public sealed class TextoParaVisibilidadeConverter : IValueConverter
+{
+    /// <summary>
+    /// Com ConverterParameter="inverter", aparece quando o texto esta VAZIO.
+    /// E o que faz o texto-fantasma de uma caixa de busca sumir assim que a
+    /// pessoa comeca a digitar.
+    /// </summary>
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        var vazio = string.IsNullOrWhiteSpace(value as string);
+
+        if (string.Equals(parameter as string, "inverter", StringComparison.OrdinalIgnoreCase))
+            return vazio ? Visibility.Visible : Visibility.Collapsed;
+
+        return vazio ? Visibility.Collapsed : Visibility.Visible;
+    }
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
+
+/// <summary>
+/// True vira negrito. Serve para destacar a linha "em uso agora" na tabela de
+/// DNS sem precisar de uma cor a mais na paleta.
+/// </summary>
+public sealed class BoolParaPesoConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => value is true ? FontWeights.Bold : FontWeights.Normal;
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
+
+/// <summary>
+/// Semaforo do NAT e da latencia: verde, amarelo, vermelho, cinza.
+///
+/// Usa as MESMAS cores do badge de risco, de proposito. Um verde aqui e um
+/// verde la precisam ser o mesmo verde, senao o usuario aprende duas escalas
+/// de cor no mesmo aplicativo.
+/// </summary>
+public sealed class SemaforoParaCorConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => (value as string) switch
+        {
+            "verde" => new SolidColorBrush(Color.FromRgb(0x3F, 0xB9, 0x50)),
+            "amarelo" => new SolidColorBrush(Color.FromRgb(0xE3, 0xB3, 0x41)),
+            "vermelho" => new SolidColorBrush(Color.FromRgb(0xE0, 0x5B, 0x4F)),
+            _ => new SolidColorBrush(Color.FromRgb(0x7A, 0x7A, 0x7A))
+        };
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
diff --git a/GameBoost/src/GameBoost.App/GameBoost.App.csproj b/GameBoost/src/GameBoost.App/GameBoost.App.csproj
new file mode 100644
index 0000000..8e9fd6f
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/GameBoost.App.csproj
@@ -0,0 +1,73 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net9.0-windows</TargetFramework>
+    <UseWPF>true</UseWPF>
+    <!--
+      WinForms entra so pelo NotifyIcon: o WPF nao tem icone de bandeja
+      proprio, e a alternativa seria uma dependencia externa so para isso.
+    -->
+    <UseWindowsForms>true</UseWindowsForms>
+    <!--
+      WFO0003 manda tirar a configuracao de DPI do manifesto e usar
+      Application.SetHighDpiMode. E um analisador do WinForms, e aqui o app e
+      WPF: o manifesto e o caminho correto para declarar PerMonitorV2, e o
+      SetHighDpiMode nem se aplica. O analisador so apareceu porque o
+      UseWindowsForms entrou por causa do NotifyIcon.
+
+      Sem isto, o `-warnaserror` do CI quebra a build inteira.
+    -->
+    <NoWarn>$(NoWarn);WFO0003</NoWarn>
+    <RootNamespace>GameBoost.App</RootNamespace>
+    <AssemblyName>GameBoost</AssemblyName>
+    <!-- ReadyToRun reduz o tempo de abertura do single-file (secao 10). -->
+    <PublishReadyToRun>true</PublishReadyToRun>
+    <SelfContained>true</SelfContained>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <PublishSingleFile>true</PublishSingleFile>
+    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+    <SatelliteResourceLanguages>pt-BR</SatelliteResourceLanguages>
+    <!-- Main proprio: o modo CLI precisa rodar sem inicializar o WPF. -->
+    <StartupObject>GameBoost.App.Program</StartupObject>
+  </PropertyGroup>
+
+  <!--
+    Elevacao. O padrao e o manifesto de producao (requireAdministrator).
+    Passar -p:SemElevacao=true numa build de desenvolvimento troca para o
+    manifesto asInvoker, que abre sem UAC no modo somente leitura. Serve para
+    rodar e inspecionar o app numa sessao nao elevada.
+  -->
+  <PropertyGroup>
+    <SemElevacao Condition="'$(SemElevacao)' == ''">false</SemElevacao>
+    <ApplicationManifest Condition="'$(SemElevacao)' != 'true'">app.manifest</ApplicationManifest>
+    <ApplicationManifest Condition="'$(SemElevacao)' == 'true'">app-dev.manifest</ApplicationManifest>
+    <AssemblyName Condition="'$(SemElevacao)' == 'true'">GameBoost-dev</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Uma build sem elevacao nunca pode virar release por engano. -->
+  <Target Name="ConferirElevacaoNoRelease" BeforeTargets="Build"
+          Condition="'$(SemElevacao)' == 'true' AND '$(Configuration)' == 'Release'">
+    <Error Text="SemElevacao=true e so para desenvolvimento. O Release precisa do manifesto requireAdministrator." />
+  </Target>
+
+  <!--
+    WinForms entra so pelo NotifyIcon, mas o SDK dele injeta using global de
+    System.Windows.Forms e System.Drawing em TODO arquivo. Isso torna Control,
+    Application, Brush e MouseEventArgs ambiguos com os tipos do WPF na
+    aplicacao inteira. Os usings saem daqui; o arquivo da bandeja declara os
+    dele explicitamente.
+  -->
+  <ItemGroup>
+    <Using Remove="System.Windows.Forms" />
+    <Using Remove="System.Drawing" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GameBoost.Core\GameBoost.Core.csproj" />
+    <ProjectReference Include="..\GameBoost.Cli\GameBoost.Cli.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/GameBoost/src/GameBoost.App/Program.cs b/GameBoost/src/GameBoost.App/Program.cs
new file mode 100644
index 0000000..9fa68fb
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Program.cs
@@ -0,0 +1,118 @@
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using GameBoost.Cli;
+using GameBoost.Core;
+using GameBoost.Core.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GameBoost.App;
+
+/// <summary>
+/// Ponto de entrada do GameBoost.exe. Decide antes de qualquer coisa se a
+/// execucao e de linha de comando ou grafica.
+///
+/// O caminho CLI **nao** inicializa o WPF. A primeira tentativa chamava
+/// Application.Shutdown() dentro de OnStartup e o processo ficava pendurado:
+/// um app WPF que nunca abriu janela mantem o loop de mensagens vivo, e
+/// Environment.Exit no meio da inicializacao arrisca travar. Separar o Main
+/// resolve na origem: em `--scan` nem existe Application.
+/// </summary>
+internal static class Program
+{
+    [STAThread]
+    public static int Main(string[] args)
+    {
+        // Antes de qualquer outra coisa, inclusive de ler argumentos.
+        //
+        // O Velopack usa o proprio executavel para instalar, atualizar e
+        // desinstalar: ele roda o exe com argumentos proprios e espera que esta
+        // chamada os intercepte e encerre o processo. Se ela vier depois de
+        // qualquer inicializacao, a instalacao abre a janela do app no meio do
+        // processo de update — ou trava.
+        //
+        // Em build de desenvolvimento, sem pacote Velopack por perto, isto e
+        // uma chamada que nao faz nada.
+        Velopack.VelopackApp.Build().Run();
+
+        var opcoes = CommandLineOptions.Parse(args);
+
+        if (!opcoes.EhCli)
+        {
+            App.Main();
+            return 0;
+        }
+
+        return ExecutarCli(opcoes);
+    }
+
+    private static int ExecutarCli(CommandLineOptions opcoes)
+    {
+        // Sendo WinExe, o processo nao tem console proprio.
+        //
+        // Quando a saida ja vem redirecionada (`--scan > arquivo.txt`, um pipe,
+        // ou um script), o handle padrao ja e valido e basta usa-lo. So quando
+        // nao ha redirecionamento e preciso anexar ao console de quem chamou,
+        // para que o comando imprima no terminal como na v1.
+        //
+        // A primeira versao so olhava o AttachConsole e descartava a saida
+        // inteira quando ele falhava, entao redirecionar para arquivo produzia
+        // um arquivo vazio.
+        var redirecionado = Console.IsOutputRedirected;
+        var anexou = !redirecionado && AttachConsole(AttachParentProcess);
+        var temSaida = redirecionado || anexou;
+
+        ServiceProvider? provider = null;
+
+        try
+        {
+            var colecao = new ServiceCollection();
+            colecao.AddGameBoostCore();
+            provider = colecao.BuildServiceProvider();
+
+            provider.GetRequiredService<IGameBoostLogger>()
+                .Info("Cli", opcoes.Comando.ToString(), null,
+                    $"admin={CoreServices.RodandoComoAdministrador()} dryRun={opcoes.DryRun}");
+
+            using var saida = temSaida
+                ? new StreamWriter(Console.OpenStandardOutput(), new UTF8Encoding(false)) { AutoFlush = true }
+                : TextWriter.Null;
+
+            return new CommandRunner(provider, saida).ExecutarAsync(opcoes).GetAwaiter().GetResult();
+        }
+        catch (Exception ex)
+        {
+            try
+            {
+                provider?.GetRequiredService<IGameBoostLogger>()
+                    .Error("Cli", opcoes.Comando.ToString(), null, "falha nao tratada", ex);
+            }
+            catch (InvalidOperationException)
+            {
+                // Container nao chegou a subir: nao ha onde registrar.
+            }
+
+            if (temSaida)
+                Console.Error.WriteLine($"Erro: {ex.Message}");
+
+            return 1;
+        }
+        finally
+        {
+            provider?.Dispose();
+
+            if (anexou)
+                FreeConsole();
+        }
+    }
+
+    private const int AttachParentProcess = -1;
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool AttachConsole(int processId);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool FreeConsole();
+}
diff --git a/GameBoost/src/GameBoost.App/Services/BandejaDoSistema.cs b/GameBoost/src/GameBoost.App/Services/BandejaDoSistema.cs
new file mode 100644
index 0000000..ac6d05e
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Services/BandejaDoSistema.cs
@@ -0,0 +1,167 @@
+using System.Drawing;
+using System.Windows.Forms;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.App.Services;
+
+/// <summary>
+/// Ícone na bandeja com o menu da seção 6: Ativar Modo Game, Limpar RAM, Abrir,
+/// Sair.
+///
+/// Duas decisões que valem ser ditas:
+///
+/// - **Fechar a janela não fecha o app quando a bandeja está ligada**, mas o
+///   menu tem "Sair" e ele sai de verdade. Programa que só finge fechar e fica
+///   rodando escondido é queixa legítima; o caminho para sair existe e está
+///   visível.
+/// - **O ícone é desenhado em código**, não carregado de arquivo. Num publish
+///   single-file, um `.ico` solto ao lado do exe não existe, e embutir recurso
+///   para dezesseis pixels não vale.
+/// </summary>
+public sealed class BandejaDoSistema : IDisposable
+{
+    private readonly IGameBoostLogger _log;
+    private NotifyIcon? _icone;
+    private ToolStripMenuItem? _itemModoGame;
+
+    public BandejaDoSistema(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public event Action? AoAbrir;
+    public event Action? AoAlternarModoGame;
+    public event Action? AoLimparRam;
+    public event Action? AoSair;
+
+    public bool Visivel => _icone is { Visible: true };
+
+    public void Mostrar()
+    {
+        if (_icone is not null)
+        {
+            _icone.Visible = true;
+            return;
+        }
+
+        try
+        {
+            var menu = new ContextMenuStrip();
+
+            _itemModoGame = new ToolStripMenuItem("Ativar Modo Game");
+            _itemModoGame.Click += (_, _) => AoAlternarModoGame?.Invoke();
+            menu.Items.Add(_itemModoGame);
+
+            var limpar = new ToolStripMenuItem("Limpar RAM");
+            limpar.Click += (_, _) => AoLimparRam?.Invoke();
+            menu.Items.Add(limpar);
+
+            menu.Items.Add(new ToolStripSeparator());
+
+            var abrir = new ToolStripMenuItem("Abrir GameBoost");
+            abrir.Click += (_, _) => AoAbrir?.Invoke();
+            menu.Items.Add(abrir);
+
+            var sair = new ToolStripMenuItem("Sair");
+            sair.Click += (_, _) => AoSair?.Invoke();
+            menu.Items.Add(sair);
+
+            _icone = new NotifyIcon
+            {
+                Icon = Desenhar(false),
+                Text = "GameBoost",
+                Visible = true,
+                ContextMenuStrip = menu
+            };
+
+            _icone.DoubleClick += (_, _) => AoAbrir?.Invoke();
+
+            _log.Info("bandeja", "Mostrar", null, "ícone na bandeja");
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or ArgumentException)
+        {
+            _log.Error("bandeja", "Mostrar", null, ex.Message, ex);
+        }
+    }
+
+    public void Esconder()
+    {
+        if (_icone is not null)
+            _icone.Visible = false;
+    }
+
+    /// <summary>Muda o texto do menu e a cor do ícone conforme o Modo Game.</summary>
+    public void AtualizarModoGame(bool ativo)
+    {
+        if (_itemModoGame is not null)
+            _itemModoGame.Text = ativo ? "Desligar Modo Game" : "Ativar Modo Game";
+
+        if (_icone is null)
+            return;
+
+        var antigo = _icone.Icon;
+        _icone.Icon = Desenhar(ativo);
+        _icone.Text = ativo ? "GameBoost — Modo Game ativo" : "GameBoost";
+
+        // O handle do ícone antigo não sai sozinho: trocar o ícone a cada
+        // sessão vazaria um handle por vez.
+        antigo?.Dispose();
+    }
+
+    /// <summary>Balão da bandeja. Usado para o convite de Modo Game.</summary>
+    public void Avisar(string titulo, string texto)
+    {
+        if (_icone is null)
+            return;
+
+        try
+        {
+            _icone.BalloonTipTitle = titulo;
+            _icone.BalloonTipText = texto;
+            _icone.BalloonTipIcon = ToolTipIcon.Info;
+            _icone.ShowBalloonTip(8000);
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or ArgumentException)
+        {
+            _log.Warn("bandeja", "Avisar", titulo, ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// Desenha um ícone de 16×16: um quadrado arredondado com a inicial. Verde
+    /// quando o Modo Game está ativo, cinza quando não.
+    /// </summary>
+    private static Icon Desenhar(bool ativo)
+    {
+        using var bitmap = new Bitmap(16, 16);
+        using var g = Graphics.FromImage(bitmap);
+
+        g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+        g.Clear(Color.Transparent);
+
+        var cor = ativo
+            ? Color.FromArgb(0x2E, 0xC4, 0x9A)
+            : Color.FromArgb(0x8A, 0x90, 0x99);
+
+        using var pincel = new SolidBrush(cor);
+        g.FillEllipse(pincel, 1, 1, 14, 14);
+
+        using var fonte = new Font("Segoe UI", 8, FontStyle.Bold, GraphicsUnit.Pixel);
+        using var texto = new SolidBrush(Color.FromArgb(0x10, 0x12, 0x16));
+
+        g.DrawString("G", fonte, texto, new PointF(4, 3));
+
+        return Icon.FromHandle(bitmap.GetHicon());
+    }
+
+    public void Dispose()
+    {
+        if (_icone is null)
+            return;
+
+        _icone.Visible = false;
+        _icone.Icon?.Dispose();
+        _icone.Dispose();
+        _icone = null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Themes/Controles.xaml b/GameBoost/src/GameBoost.App/Themes/Controles.xaml
new file mode 100644
index 0000000..ad91ee0
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Themes/Controles.xaml
@@ -0,0 +1,134 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!--
+      Template unico do ActionItem. Toda pagina de modulo usa este mesmo bloco,
+      entao a lista da Limpeza, do Desinstalador e da Inicializacao vao sair
+      identicas a do Modo Game sem nenhuma tela nova.
+    -->
+
+    <Style x:Key="ItemDeAcao" TargetType="ListBoxItem">
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="Padding" Value="0" />
+        <Setter Property="Focusable" Value="False" />
+        <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+    </Style>
+
+    <DataTemplate x:Key="TemplateDeActionItem">
+        <Border Background="{StaticResource SuperficieAlta}" CornerRadius="6" Padding="12,10" Margin="4,3">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+
+                <CheckBox Grid.Column="0" IsChecked="{Binding Selecionado}"
+                          IsEnabled="{Binding PodeSelecionar}" Margin="0,0,12,0"
+                          ToolTip="{Binding MotivoBloqueio}" />
+
+                <StackPanel Grid.Column="1">
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock Text="{Binding Titulo}" FontWeight="SemiBold" />
+                        <Border Background="{StaticResource Borda}" CornerRadius="3" Padding="6,1" Margin="8,0,0,0"
+                                VerticalAlignment="Center"
+                                Visibility="{Binding Bloqueado, Converter={StaticResource BoolParaVisibilidade}}">
+                            <TextBlock Text="{Binding RotuloBloqueio}" FontSize="10" Foreground="{StaticResource TextoSecundario}" />
+                        </Border>
+                    </StackPanel>
+                    <TextBlock Text="{Binding Descricao}" Foreground="{StaticResource TextoSecundario}" FontSize="12" />
+                </StackPanel>
+
+                <StackPanel Grid.Column="2" VerticalAlignment="Center" Margin="12,0">
+                    <TextBlock Text="{Binding GanhoEstimado}" HorizontalAlignment="Right" FontSize="12" />
+                    <Border CornerRadius="4" Padding="7,2" HorizontalAlignment="Right" Margin="0,3,0,0"
+                            Background="{Binding Risco, Converter={StaticResource RiscoParaCor}}">
+                        <TextBlock Text="{Binding TextoDeRisco}" FontSize="11"
+                                   Foreground="#FF0D1117" FontWeight="SemiBold" />
+                    </Border>
+                </StackPanel>
+
+                <Button Grid.Column="3" Content="?" Width="30" Height="30"
+                        Style="{StaticResource BotaoBase}" Padding="0"
+                        Command="{Binding ExplicarCommand}"
+                        ToolTip="O que faz, qual o risco, como desfazer" />
+            </Grid>
+        </Border>
+    </DataTemplate>
+
+
+    <!--
+      Abas no tema escuro. O TabItem padrao do WPF ainda usa o visual do
+      Windows Classic: fundo claro e texto escuro. Sobre a superficie escura
+      do GameBoost o rotulo fica branco no branco e a aba some.
+    -->
+    <Style TargetType="TabItem">
+        <Setter Property="Foreground" Value="{StaticResource TextoSecundario}" />
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="Padding" Value="16,9" />
+        <Setter Property="Margin" Value="0,0,4,0" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabItem">
+                    <Border x:Name="Fundo"
+                            Background="{TemplateBinding Background}"
+                            CornerRadius="6,6,0,0"
+                            Padding="{TemplateBinding Padding}">
+                        <ContentPresenter ContentSource="Header"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center" />
+                    </Border>
+
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsSelected" Value="True">
+                            <Setter TargetName="Fundo" Property="Background" Value="{StaticResource Superficie}" />
+                            <Setter Property="Foreground" Value="{StaticResource Texto}" />
+                            <Setter Property="FontWeight" Value="SemiBold" />
+                        </Trigger>
+
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter Property="Foreground" Value="{StaticResource Texto}" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style TargetType="TabControl">
+        <Setter Property="Background" Value="Transparent" />
+        <Setter Property="BorderThickness" Value="0" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TabControl">
+                    <Grid>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="*" />
+                        </Grid.RowDefinitions>
+
+                        <TabPanel Grid.Row="0" IsItemsHost="True" Panel.ZIndex="1" />
+
+                        <!--
+                          O nome PART_SelectedContentHost nao e decoracao: o
+                          TabControlAutomationPeer do WPF procura exatamente por
+                          ele para expor o conteudo da aba selecionada. Sem o
+                          nome, a arvore de automacao fica vazia da aba para
+                          dentro: leitor de tela nao alcanca nenhum controle, e
+                          a navegacao por teclado entre abas perde o destino.
+                          Foi o que aconteceu aqui, e so apareceu porque o
+                          script de captura parou de achar os botoes.
+                        -->
+                        <Border Grid.Row="1" Background="Transparent">
+                            <ContentPresenter x:Name="PART_SelectedContentHost"
+                                              ContentSource="SelectedContent" />
+                        </Border>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+</ResourceDictionary>
diff --git a/GameBoost/src/GameBoost.App/Themes/Conversores.xaml b/GameBoost/src/GameBoost.App/Themes/Conversores.xaml
new file mode 100644
index 0000000..df21c23
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Themes/Conversores.xaml
@@ -0,0 +1,26 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:conv="clr-namespace:GameBoost.App.Converters">
+
+    <!--
+      Os conversores moram num dicionario proprio, e nao soltos no App.xaml,
+      por causa da ordem de carga do WPF: MergedDictionaries sao processados
+      ANTES das entradas do dicionario que os mescla. Com os conversores
+      declarados direto no App.xaml, o Controles.xaml era lido antes deles
+      existirem, e todo StaticResource de conversor dentro de um DataTemplate
+      falhava.
+
+      O erro nao aparecia na abertura: DataTemplate resolve tarde, entao a
+      excecao so estourava ao renderizar o primeiro item de uma lista, e
+      derrubava o app inteiro.
+
+      Este arquivo precisa ser mesclado ANTES de Controles.xaml.
+    -->
+    <conv:RiscoParaCorConverter x:Key="RiscoParaCor" />
+    <conv:BoolParaVisibilidadeConverter x:Key="BoolParaVisibilidade" />
+    <conv:InverterBoolConverter x:Key="InverterBool" />
+    <conv:TextoParaVisibilidadeConverter x:Key="TextoParaVisibilidade" />
+    <conv:BoolParaPesoConverter x:Key="BoolParaPeso" />
+    <conv:SemaforoParaCorConverter x:Key="SemaforoParaCor" />
+
+</ResourceDictionary>
diff --git a/GameBoost/src/GameBoost.App/Themes/Dark.xaml b/GameBoost/src/GameBoost.App/Themes/Dark.xaml
new file mode 100644
index 0000000..13c9af2
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Themes/Dark.xaml
@@ -0,0 +1,80 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!-- Tema escuro padrao, acento unico. Fluent-like, sem gradiente (secao 6). -->
+    <Color x:Key="FundoColor">#FF14161A</Color>
+    <Color x:Key="SuperficieColor">#FF1C1F26</Color>
+    <Color x:Key="SuperficieAltaColor">#FF242830</Color>
+    <Color x:Key="AcentoColor">#FF00C2A8</Color>
+
+    <SolidColorBrush x:Key="Fundo" Color="{StaticResource FundoColor}" />
+    <SolidColorBrush x:Key="Superficie" Color="{StaticResource SuperficieColor}" />
+    <SolidColorBrush x:Key="SuperficieAlta" Color="{StaticResource SuperficieAltaColor}" />
+    <SolidColorBrush x:Key="Borda" Color="#FF2E333D" />
+
+    <SolidColorBrush x:Key="Acento" Color="{StaticResource AcentoColor}" />
+    <SolidColorBrush x:Key="AcentoEscuro" Color="#FF00947F" />
+
+    <SolidColorBrush x:Key="Texto" Color="#FFEDEFF2" />
+    <SolidColorBrush x:Key="TextoSecundario" Color="#FF9AA3B0" />
+    <SolidColorBrush x:Key="TextoDesabilitado" Color="#FF5E6672" />
+
+    <!-- Badges de risco: verde, amarelo, vermelho (secao 6). -->
+    <SolidColorBrush x:Key="RiscoBaixo" Color="#FF3FB950" />
+    <SolidColorBrush x:Key="RiscoMedio" Color="#FFD29922" />
+    <SolidColorBrush x:Key="RiscoAlto" Color="#FFF85149" />
+
+    <Style x:Key="BotaoBase" TargetType="Button">
+        <Setter Property="Background" Value="{StaticResource SuperficieAlta}" />
+        <Setter Property="Foreground" Value="{StaticResource Texto}" />
+        <Setter Property="BorderBrush" Value="{StaticResource Borda}" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Padding" Value="16,9" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="Cursor" Value="Hand" />
+        <Setter Property="SnapsToDevicePixels" Value="True" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="Button">
+                    <Border x:Name="Fundo"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            CornerRadius="6">
+                        <ContentPresenter HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"
+                                          Margin="{TemplateBinding Padding}" />
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="Fundo" Property="BorderBrush" Value="{StaticResource Acento}" />
+                        </Trigger>
+                        <Trigger Property="IsEnabled" Value="False">
+                            <Setter Property="Foreground" Value="{StaticResource TextoDesabilitado}" />
+                            <Setter Property="Cursor" Value="Arrow" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="BotaoPrimario" TargetType="Button" BasedOn="{StaticResource BotaoBase}">
+        <Setter Property="Background" Value="{StaticResource Acento}" />
+        <Setter Property="Foreground" Value="#FF08121A" />
+        <Setter Property="BorderBrush" Value="{StaticResource Acento}" />
+        <Setter Property="FontWeight" Value="SemiBold" />
+    </Style>
+
+    <Style TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{StaticResource Texto}" />
+        <Setter Property="FontSize" Value="13" />
+        <Setter Property="TextWrapping" Value="Wrap" />
+    </Style>
+
+    <Style TargetType="CheckBox">
+        <Setter Property="Foreground" Value="{StaticResource Texto}" />
+        <Setter Property="VerticalAlignment" Value="Center" />
+    </Style>
+
+</ResourceDictionary>
diff --git a/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs
new file mode 100644
index 0000000..6a9ea5d
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/ActionItemViewModel.cs
@@ -0,0 +1,60 @@
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core.Modules;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Envolve um ActionItem com o estado de selecao da UI. A tela de lista e
+/// generica: todo modulo produz ActionItem e reusa a mesma view.
+/// </summary>
+public sealed partial class ActionItemViewModel : ObservableObject
+{
+    public ActionItemViewModel(ActionItem item)
+    {
+        Item = item;
+        _selecionado = item.PreMarcado && !item.Bloqueado;
+    }
+
+    public ActionItem Item { get; }
+
+    [ObservableProperty]
+    private bool _selecionado;
+
+    public string Id => Item.Id;
+    public string Titulo => Item.Titulo;
+    public string Descricao => Item.Descricao;
+    public string Categoria => Item.Categoria;
+    public RiskLevel Risco => Item.Risco;
+    public string GanhoEstimado => Item.GanhoEstimado;
+    public bool Bloqueado => Item.Bloqueado;
+    public bool PodeSelecionar => !Item.Bloqueado;
+    public string? MotivoBloqueio => Item.MotivoBloqueio;
+    public string RotuloBloqueio => Item.RotuloBloqueio;
+
+    public string TextoDeRisco => Item.Risco switch
+    {
+        RiskLevel.Alto => "Risco alto",
+        RiskLevel.Medio => "Risco medio",
+        _ => "Risco baixo"
+    };
+
+    /// <summary>Conteudo do botao "?": o que faz, qual o risco, como desfazer (secao 6).</summary>
+    public string Explicacao =>
+        $"O que faz: {Item.Descricao}\n\n" +
+        $"Risco: {TextoDeRisco}\n\n" +
+        $"Como desfazer: {Item.ComoDesfazer}" +
+        (Item.MotivoBloqueio is null ? string.Empty : $"\n\nProtegido: {Item.MotivoBloqueio}");
+
+    [RelayCommand]
+    private void Explicar()
+        => MessageBox.Show(Explicacao, Titulo, MessageBoxButton.OK, MessageBoxImage.Information);
+
+    /// <summary>Selecao so muda quando o item nao esta bloqueado. Protege contra bind teimoso.</summary>
+    partial void OnSelecionadoChanged(bool value)
+    {
+        if (value && Item.Bloqueado)
+            Selecionado = false;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/AppsPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/AppsPageViewModel.cs
new file mode 100644
index 0000000..8010826
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/AppsPageViewModel.cs
@@ -0,0 +1,364 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.Uninstaller;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Uma pasta de resto, na aba própria.</summary>
+public sealed partial class RestoViewModel : ObservableObject
+{
+    public RestoViewModel(Resto resto)
+    {
+        Item = resto;
+    }
+
+    public Resto Item { get; }
+
+    /// <summary>Nunca pré-marcado: o casamento de nomes é heurística.</summary>
+    [ObservableProperty] private bool _selecionado;
+
+    public string Titulo => Item.Nome;
+    public string Descricao => $"{Item.Local} · {GameModeModule.Formatar(Item.Bytes)} · {Item.Idade}";
+    public string Caminho => Item.Caminho;
+}
+
+/// <summary>
+/// Página de aplicativos (seção 5.3), em três abas.
+///
+/// - **Instalados**: a lista principal, herdada do padrão de módulo.
+/// - **Atualizações**: o que o winget tem de versão nova.
+/// - **Restos de apps antigos**: pastas sem app correspondente.
+///
+/// As três compartilham o mesmo rodapé conceitual, mas cada uma age sobre a sua
+/// lista: aplicar na aba de atualizações não desinstala nada, e vice-versa.
+/// </summary>
+public sealed partial class AppsPageViewModel : ModulePageViewModel
+{
+    private readonly UninstallerModule _modulo;
+
+    public AppsPageViewModel(UninstallerModule modulo, IStateBackup backup)
+        : base(modulo, backup)
+    {
+        _modulo = modulo;
+    }
+
+    public override string Nome => "Apps";
+    public override string Titulo => "Aplicativos instalados";
+    public override string Subtitulo => "Desinstala em lote, inclusive apps da Store, e mostra o que ficou para trás.";
+    public override string Icone => "\uE71D";
+
+    // ==================================================================
+    // Aba: Atualizações
+    // ==================================================================
+
+    public ObservableCollection<ActionItemViewModel> Atualizacoes { get; } = new();
+
+    [ObservableProperty] private string _resumoDeAtualizacoes = "Clique em Verificar para consultar o winget.";
+    [ObservableProperty] private string _statusDeAtualizacoes = string.Empty;
+    [ObservableProperty] private bool _wingetAusente;
+    [ObservableProperty] private bool _ocupadoComAtualizacoes;
+
+    public int AtualizacoesSelecionadas => Atualizacoes.Count(a => a.Selecionado);
+
+    public string TextoAtualizar => AtualizacoesSelecionadas == 1
+        ? "Atualizar 1 selecionado"
+        : $"Atualizar {AtualizacoesSelecionadas} selecionados";
+
+    [RelayCommand]
+    public async Task VerificarAtualizacoesAsync()
+    {
+        if (OcupadoComAtualizacoes)
+            return;
+
+        OcupadoComAtualizacoes = true;
+        Atualizacoes.Clear();
+        ResumoDeAtualizacoes = "Consultando o winget...";
+
+        try
+        {
+            var progresso = new Progress<ModuleProgress>(p =>
+            {
+                StatusDeAtualizacoes = p.Etapa;
+                Progresso = p.Percentual;
+            });
+
+            var resultado = await _modulo.VarrerAtualizacoesAsync(progresso, CancellationToken.None);
+
+            WingetAusente = !_modulo.Winget.Disponivel;
+
+            foreach (var item in resultado.Itens)
+            {
+                var vm = new ActionItemViewModel(item);
+                vm.PropertyChanged += AoMudarSelecaoDeAtualizacao;
+                Atualizacoes.Add(vm);
+            }
+
+            ResumoDeAtualizacoes = resultado.Resumo;
+            StatusDeAtualizacoes = resultado.Avisos.Count > 0
+                ? string.Join("  ", resultado.Avisos)
+                : "Nada vem marcado. Marque o que quiser atualizar.";
+        }
+        catch (OperationCanceledException)
+        {
+            StatusDeAtualizacoes = "Consulta cancelada.";
+        }
+        finally
+        {
+            OcupadoComAtualizacoes = false;
+            Progresso = 100;
+            NotificarAtualizacoes();
+        }
+    }
+
+    [RelayCommand]
+    public async Task AtualizarSelecionadosAsync()
+    {
+        if (OcupadoComAtualizacoes || !EhAdministrador)
+            return;
+
+        var selecionados = Atualizacoes.Where(a => a.Selecionado && a.PodeSelecionar).ToList();
+
+        if (selecionados.Count == 0)
+            return;
+
+        if (!DryRun && !ConfirmarAtualizacao(selecionados))
+            return;
+
+        OcupadoComAtualizacoes = true;
+
+        try
+        {
+            var progresso = new Progress<ModuleProgress>(p =>
+            {
+                StatusDeAtualizacoes = p.Etapa;
+                Progresso = p.Percentual;
+            });
+
+            var resultado = await _modulo.AtualizarAsync(
+                selecionados.Select(s => s.Item.Id).ToList(), DryRun, progresso, CancellationToken.None);
+
+            ResumoDeAtualizacoes = resultado.Resumo;
+
+            var falhas = resultado.Acoes.Where(a => !a.Sucesso).ToList();
+
+            StatusDeAtualizacoes = falhas.Count == 0
+                ? "Tudo certo. Verifique de novo para confirmar."
+                : string.Join("  ", falhas.Select(f => f.Detalhe));
+
+            if (!DryRun)
+                await VerificarAtualizacoesAsync();
+        }
+        catch (OperationCanceledException)
+        {
+            StatusDeAtualizacoes = "Atualização cancelada.";
+        }
+        finally
+        {
+            OcupadoComAtualizacoes = false;
+        }
+    }
+
+    /// <summary>Abre a página do App Installer na Microsoft Store.</summary>
+    [RelayCommand]
+    private void InstalarWinget()
+    {
+        try
+        {
+            Process.Start(new ProcessStartInfo(WingetService.LinkDaStore) { UseShellExecute = true });
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            StatusDeAtualizacoes = $"Não foi possível abrir a Store: {ex.Message}";
+        }
+    }
+
+    private bool ConfirmarAtualizacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var nomes = string.Join("\n  ", selecionados.Take(12).Select(s => s.Titulo));
+        var extra = selecionados.Count > 12 ? $"\n  ... e mais {selecionados.Count - 12}" : string.Empty;
+
+        var arriscados = selecionados.Count(s => s.Item.Risco != RiskLevel.Baixo);
+
+        var texto = $"Atualizar {selecionados.Count} aplicativo(s) pelo winget?\n\n  {nomes}{extra}\n\n";
+
+        if (arriscados > 0)
+        {
+            texto += $"{arriscados} deles são runtime, se atualizam sozinhos ou têm versão "
+                   + "instalada desconhecida. O motivo aparece em cada linha.\n\n";
+        }
+
+        texto += "Cada app é atualizado por vez, pelo instalador do próprio fabricante. "
+               + "Não há como voltar a versão pelo winget: se a versão nova der problema, "
+               + "a reinstalação da antiga é pelo site do fabricante.\n\n"
+               + "Feche os aplicativos que estiverem abertos antes de continuar.\n\nContinuar?";
+
+        return System.Windows.MessageBox.Show(
+            texto, "Atualizar aplicativos",
+            System.Windows.MessageBoxButton.OKCancel,
+            System.Windows.MessageBoxImage.Warning) == System.Windows.MessageBoxResult.OK;
+    }
+
+    private void AoMudarSelecaoDeAtualizacao(object? remetente, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(ActionItemViewModel.Selecionado))
+            NotificarAtualizacoes();
+    }
+
+    private void NotificarAtualizacoes()
+    {
+        OnPropertyChanged(nameof(AtualizacoesSelecionadas));
+        OnPropertyChanged(nameof(TextoAtualizar));
+    }
+
+    // ==================================================================
+    // Aba: Restos de apps antigos
+    // ==================================================================
+
+    public ObservableCollection<RestoViewModel> Restos { get; } = new();
+
+    [ObservableProperty] private string _resumoDeRestos =
+        "Clique em Varrer restos para procurar pastas de programas que você já desinstalou.";
+
+    [ObservableProperty] private string _statusDeRestos = string.Empty;
+    [ObservableProperty] private bool _ocupadoComRestos;
+
+    public int RestosSelecionados => Restos.Count(r => r.Selecionado);
+
+    public string TextoRemoverRestos => RestosSelecionados == 1
+        ? "Mandar 1 para a Lixeira"
+        : $"Mandar {RestosSelecionados} para a Lixeira";
+
+    [RelayCommand]
+    public async Task VarrerRestosAsync()
+    {
+        if (OcupadoComRestos)
+            return;
+
+        OcupadoComRestos = true;
+        Restos.Clear();
+        ResumoDeRestos = "Procurando...";
+
+        try
+        {
+            // A varredura de restos precisa da lista de instalados para saber o
+            // que é resto. Sem ela, tudo viraria resto.
+            if (_modulo.UltimaLista.Count == 0)
+            {
+                StatusDeRestos = "Varrendo os apps instalados primeiro...";
+                await _modulo.ScanAsync(null, CancellationToken.None);
+            }
+
+            var progresso = new Progress<string>(texto => StatusDeRestos = texto);
+
+            var achados = await Task.Run(
+                () => _modulo.VarrerRestos(progresso, CancellationToken.None));
+
+            foreach (var resto in achados)
+            {
+                var vm = new RestoViewModel(resto);
+                vm.PropertyChanged += AoMudarSelecaoDeResto;
+                Restos.Add(vm);
+            }
+
+            var total = achados.Sum(r => r.Bytes);
+
+            ResumoDeRestos = achados.Count == 0
+                ? "Nenhuma pasta sem app correspondente."
+                : $"{achados.Count} pastas sem app correspondente, {GameModeModule.Formatar(total)} no total.";
+
+            StatusDeRestos = "O casamento de nomes é uma heurística: uma pasta pode pertencer "
+                           + "a um app que o registro não declara. Por isso nada vem marcado e "
+                           + "a remoção vai para a Lixeira.";
+        }
+        catch (OperationCanceledException)
+        {
+            StatusDeRestos = "Varredura cancelada.";
+        }
+        finally
+        {
+            OcupadoComRestos = false;
+            NotificarRestos();
+        }
+    }
+
+    [RelayCommand]
+    public void RemoverRestos()
+    {
+        var escolhidos = Restos.Where(r => r.Selecionado).ToList();
+
+        if (escolhidos.Count == 0 || !EhAdministrador)
+            return;
+
+        var nomes = string.Join("\n  ", escolhidos.Take(12).Select(r => $"{r.Titulo} — {r.Caminho}"));
+        var extra = escolhidos.Count > 12 ? $"\n  ... e mais {escolhidos.Count - 12}" : string.Empty;
+        var total = escolhidos.Sum(r => r.Item.Bytes);
+
+        var texto = $"Mandar {escolhidos.Count} pasta(s) para a Lixeira, "
+                  + $"liberando {GameModeModule.Formatar(total)}?\n\n  {nomes}{extra}\n\n"
+                  + "Elas vão para a Lixeira, não são apagadas de vez: se alguma pertencer a um "
+                  + "app que você ainda usa, dá para restaurar.\n\nContinuar?";
+
+        if (System.Windows.MessageBox.Show(
+                texto, "Remover restos",
+                System.Windows.MessageBoxButton.OKCancel,
+                System.Windows.MessageBoxImage.Warning) != System.Windows.MessageBoxResult.OK)
+        {
+            return;
+        }
+
+        var (removidos, bytes) = _modulo.RemoverRestos(escolhidos.Select(r => r.Item).ToList());
+
+        foreach (var removido in escolhidos.Take(removidos))
+            Restos.Remove(removido);
+
+        ResumoDeRestos = $"{removidos} pasta(s) na Lixeira, {GameModeModule.Formatar(bytes)} liberados.";
+        StatusDeRestos = "Para recuperar espaço de verdade, esvazie a Lixeira — está em Ferramentas.";
+        NotificarRestos();
+    }
+
+    private void AoMudarSelecaoDeResto(object? remetente, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(RestoViewModel.Selecionado))
+            NotificarRestos();
+    }
+
+    private void NotificarRestos()
+    {
+        OnPropertyChanged(nameof(RestosSelecionados));
+        OnPropertyChanged(nameof(TextoRemoverRestos));
+    }
+
+    // ==================================================================
+    // Aba: Instalados
+    // ==================================================================
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var total = selecionados.Sum(i => i.Item.GanhoBytes);
+        var nomes = string.Join("\n  ", selecionados.Take(10).Select(i => i.Titulo));
+        var extra = selecionados.Count > 10 ? $"\n  ... e mais {selecionados.Count - 10}" : string.Empty;
+
+        var apps = selecionados.Select(i => i.Item.Payload as InstalledApp).Where(a => a is not null).ToList();
+        var semSilencio = apps.Count(a => !a!.TemDesinstalacaoSilenciosa);
+
+        var texto = $"Desinstalar {selecionados.Count} aplicativo(s), liberando cerca de "
+                  + $"{GameModeModule.Formatar(total)}?\n\n  {nomes}{extra}\n\n";
+
+        if (semSilencio > 0)
+        {
+            texto += $"{semSilencio} deles não têm desinstalação silenciosa: o desinstalador "
+                   + "próprio de cada um vai abrir, e você conclui por ele.\n\n";
+        }
+
+        texto += "Isto não tem como ser desfeito pelo GameBoost. Configurações e dados dos "
+               + "aplicativos se perdem.\n\nConsidere criar um ponto de restauração antes "
+               + "(está em Ferramentas). Continuar?";
+
+        return texto;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/ConfiguracoesPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/ConfiguracoesPageViewModel.cs
new file mode 100644
index 0000000..a889972
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/ConfiguracoesPageViewModel.cs
@@ -0,0 +1,293 @@
+using System.Collections.ObjectModel;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Uma linha do Historico: uma alteracao de sistema ja aplicada.</summary>
+public sealed partial class HistoricoItemViewModel : ObservableObject
+{
+    public HistoricoItemViewModel(ChangeRecord record)
+    {
+        Record = record;
+        _revertido = record.Revertido;
+    }
+
+    public ChangeRecord Record { get; }
+
+    [ObservableProperty] private bool _revertido;
+
+    public string Quando => Record.Data.ToLocalTime().ToString("dd/MM/yyyy HH:mm");
+    public string Modulo => Record.Modulo;
+    public string Tipo => Record.Tipo.ToString();
+
+    public string Descricao => Record.Extras.TryGetValue("nome", out var nome) && !string.IsNullOrWhiteSpace(nome)
+        ? nome
+        : string.IsNullOrEmpty(Record.SubAlvo) ? Record.Alvo : $"{Record.Alvo}\\{Record.SubAlvo}";
+
+    public string Mudanca => Record.ValorAnteriorExistia
+        ? $"{Record.ValorAnterior ?? "-"}  ->  {Record.ValorNovo ?? "-"}"
+        : $"(nao existia)  ->  {Record.ValorNovo ?? "-"}";
+
+    public string Situacao => Revertido ? "Revertido" : "Aplicado";
+    public bool PodeDesfazer => !Revertido;
+}
+
+/// <summary>
+/// Configuracoes e Historico (secao 6). O Historico le direto o state-backup:
+/// e a mesma fonte que o "Reverter tudo" usa, entao nunca fica dessincronizado.
+/// </summary>
+public sealed partial class ConfiguracoesPageViewModel : PageViewModelBase
+{
+    private readonly AppSettings _settings;
+    private readonly ISettingsStore _store;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly AppPaths _paths;
+    private readonly Core.Updates.UpdateService _atualizacao;
+    private readonly IGameBoostLogger _log;
+    private bool _carregando;
+
+    public ConfiguracoesPageViewModel(
+        AppSettings settings,
+        ISettingsStore store,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        AppPaths paths,
+        Core.Updates.UpdateService atualizacao,
+        IGameBoostLogger log)
+    {
+        _atualizacao = atualizacao;
+        _versao = atualizacao.VersaoAtual;
+        _estadoDaAtualizacao = atualizacao.Suportado
+            ? "Clique em Verificar para procurar versao nova."
+            : "Esta copia nao foi instalada pelo instalador do GameBoost (ou esta em modo "
+            + "portatil), entao nao ha atualizacao automatica.";
+
+        _settings = settings;
+        _store = store;
+        _backup = backup;
+        _rollback = rollback;
+        _paths = paths;
+        _log = log;
+
+        _carregando = true;
+        _temaEscuro = !string.Equals(settings.Tema, "Light", StringComparison.OrdinalIgnoreCase);
+        _iniciarComWindows = settings.IniciarComWindows;
+        _permitirAcessoARede = settings.PermitirAcessoARede;
+        _mostrarNaBandeja = settings.MostrarNaBandeja;
+        _detectarJogosAutomaticamente = settings.DetectarJogosAutomaticamente;
+        _iniciarMinimizado = settings.IniciarMinimizado;
+        _carregando = false;
+
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+        RecarregarHistorico();
+    }
+
+    public override string Nome => "Configuracoes";
+    public override string Titulo => "Configuracoes";
+    public override string Subtitulo => "Preferencias do app e historico de tudo que ele ja alterou.";
+    public override string Icone => "\uE713";
+
+    public ObservableCollection<HistoricoItemViewModel> Historico { get; } = new();
+
+    [ObservableProperty] private bool _temaEscuro;
+    [ObservableProperty] private bool _iniciarComWindows;
+    [ObservableProperty] private bool _iniciarMinimizado;
+    [ObservableProperty] private bool _permitirAcessoARede;
+    [ObservableProperty] private bool _mostrarNaBandeja;
+    [ObservableProperty] private string _versao = string.Empty;
+    [ObservableProperty] private string _estadoDaAtualizacao = string.Empty;
+    [ObservableProperty] private bool _verificandoAtualizacao;
+    [ObservableProperty] private bool _atualizacaoPronta;
+    [ObservableProperty] private bool _detectarJogosAutomaticamente;
+    [ObservableProperty] private bool _ehAdministrador;
+    [ObservableProperty] private string _status = string.Empty;
+
+    public string PastaDeDados => _paths.RootDirectory;
+
+    public string ModoDeArmazenamento => _paths.Portatil
+        ? "Modo portatil: os dados ficam ao lado do executavel."
+        : "Os dados ficam em %LOCALAPPDATA%\\GameBoost.";
+
+    public bool HistoricoVazio => Historico.Count == 0;
+
+    public override void AoEntrar() => RecarregarHistorico();
+
+    [RelayCommand]
+    private void RecarregarHistorico()
+    {
+        _backup.Recarregar();
+        Historico.Clear();
+
+        // Mais recente primeiro: e o que o usuario quer desfazer.
+        foreach (var record in _backup.Todos.OrderByDescending(r => r.Data))
+            Historico.Add(new HistoricoItemViewModel(record));
+
+        OnPropertyChanged(nameof(HistoricoVazio));
+    }
+
+    [RelayCommand]
+    private void Desfazer(HistoricoItemViewModel? item)
+    {
+        if (item is null || !EhAdministrador)
+            return;
+
+        var resposta = MessageBox.Show(
+            $"Desfazer esta alteracao?\n\n{item.Descricao}\n{item.Mudanca}",
+            "Desfazer", MessageBoxButton.YesNo, MessageBoxImage.Question);
+
+        if (resposta != MessageBoxResult.Yes)
+            return;
+
+        var resultado = _rollback.Reverter(new[] { item.Record.Id }, dryRun: false).FirstOrDefault();
+
+        if (resultado is null)
+        {
+            Status = "Esta alteracao ja havia sido revertida.";
+            RecarregarHistorico();
+            return;
+        }
+
+        item.Revertido = resultado.Sucesso;
+        Status = resultado.Detalhe;
+        _log.Info("Config", "Desfazer", item.Record.Alvo, resultado.Detalhe);
+
+        RecarregarHistorico();
+    }
+
+    [RelayCommand]
+    private void AbrirPastaDeDados()
+    {
+        try
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = _paths.RootDirectory,
+                UseShellExecute = true
+            });
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            Status = "Nao foi possivel abrir a pasta.";
+        }
+    }
+
+    private void Salvar()
+    {
+        if (_carregando)
+            return;
+
+        _settings.Tema = TemaEscuro ? "Dark" : "Light";
+        _settings.IniciarComWindows = IniciarComWindows;
+        _settings.PermitirAcessoARede = PermitirAcessoARede;
+        _settings.MostrarNaBandeja = MostrarNaBandeja;
+        _settings.DetectarJogosAutomaticamente = DetectarJogosAutomaticamente;
+        _settings.IniciarMinimizado = IniciarMinimizado;
+        _store.Save(_settings);
+    }
+
+    partial void OnTemaEscuroChanged(bool value) => Salvar();
+
+    partial void OnIniciarComWindowsChanged(bool value)
+    {
+        Salvar();
+
+        // Honestidade (secao 6): o GameBoost aparece na propria lista de
+        // inicializacao que ele mesmo gerencia.
+        Status = value
+            ? "O GameBoost passa a iniciar com o Windows. Ele aparece na propria lista de Inicializacao."
+            : "O GameBoost nao inicia mais com o Windows.";
+    }
+
+    partial void OnIniciarMinimizadoChanged(bool value) => Salvar();
+
+    // ==================================================================
+    // Atualizacao do proprio GameBoost (secao 10)
+    // ==================================================================
+
+    /// <summary>
+    /// Verifica se ha versao nova.
+    ///
+    /// Sem permissao de rede, sem instalacao feita pelo instalador ou em modo
+    /// portatil, ele **diz o que falta** em vez de falhar calado. Um botao que
+    /// nao responde e pior que um botao que explica.
+    /// </summary>
+    [RelayCommand]
+    private async Task VerificarAtualizacaoAsync()
+    {
+        if (VerificandoAtualizacao)
+            return;
+
+        VerificandoAtualizacao = true;
+        EstadoDaAtualizacao = "Verificando...";
+
+        try
+        {
+            var estado = await _atualizacao.VerificarAsync(CancellationToken.None);
+
+            if (estado == Core.Updates.EstadoDaAtualizacao.Disponivel)
+            {
+                EstadoDaAtualizacao = _atualizacao.Motivo + " Baixando...";
+                estado = await _atualizacao.BaixarAsync(CancellationToken.None);
+            }
+
+            EstadoDaAtualizacao = _atualizacao.Motivo ?? "Nada a relatar.";
+            AtualizacaoPronta = estado == Core.Updates.EstadoDaAtualizacao.ProntaParaInstalar;
+        }
+        catch (OperationCanceledException)
+        {
+            EstadoDaAtualizacao = "Verificacao cancelada.";
+        }
+        finally
+        {
+            VerificandoAtualizacao = false;
+        }
+    }
+
+    [RelayCommand]
+    private void InstalarAtualizacao()
+    {
+        if (!AtualizacaoPronta)
+            return;
+
+        _atualizacao.InstalarEReiniciar();
+    }
+
+    partial void OnMostrarNaBandejaChanged(bool value)
+    {
+        Salvar();
+
+        Status = value
+            ? "O ícone volta a aparecer na bandeja na próxima abertura."
+            : "Sem o ícone na bandeja, fechar a janela fecha o GameBoost de vez. "
+            + "A mudança vale na próxima abertura.";
+    }
+
+    partial void OnDetectarJogosAutomaticamenteChanged(bool value)
+    {
+        Salvar();
+
+        Status = value
+            ? "Ao abrir um jogo, o GameBoost vai perguntar se você quer ativar o Modo Game. "
+            + "Ele nunca ativa sozinho, a não ser que o perfil daquele jogo mande."
+            : "O GameBoost deixa de vigiar os processos. O Modo Game continua funcionando "
+            + "pelo botão de sempre. Vale na próxima abertura.";
+    }
+
+    partial void OnPermitirAcessoARedeChanged(bool value)
+    {
+        Salvar();
+
+        Status = value
+            ? "O teste de velocidade da página Rede foi liberado. Nenhum dado seu é enviado: "
+            + "o teste só baixa e envia bytes aleatórios para medir a conexão."
+            : "Acesso à internet desligado. O teste de velocidade fica indisponível; "
+            + "ping, DNS e detecção de NAT continuam funcionando.";
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/DiagnosticoPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/DiagnosticoPageViewModel.cs
new file mode 100644
index 0000000..31bec51
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/DiagnosticoPageViewModel.cs
@@ -0,0 +1,348 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.HealthReport;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Um dos cinco medidores do painel.</summary>
+public sealed partial class MedidorViewModel : ObservableObject
+{
+    public MedidorViewModel(string nome, string unidade, double maximo)
+    {
+        Nome = nome;
+        Unidade = unidade;
+        Maximo = maximo;
+    }
+
+    public string Nome { get; }
+    public string Unidade { get; }
+    public double Maximo { get; }
+
+    [ObservableProperty] private double _valor;
+    [ObservableProperty] private string _texto = "--";
+    [ObservableProperty] private bool _disponivel = true;
+    [ObservableProperty] private string? _detalhe;
+    [ObservableProperty] private IReadOnlyList<double> _serie = Array.Empty<double>();
+
+    /// <summary>Percentual para a barra, mesmo quando a unidade nao e porcentagem.</summary>
+    public double Percentual => Maximo <= 0 ? 0 : Math.Clamp(Valor / Maximo * 100.0, 0, 100);
+
+    partial void OnValorChanged(double value) => OnPropertyChanged(nameof(Percentual));
+}
+
+public sealed partial class FindingViewModel : ObservableObject
+{
+    public FindingViewModel(Finding finding)
+    {
+        Finding = finding;
+    }
+
+    public Finding Finding { get; }
+
+    public string Titulo => Finding.Titulo;
+    public string Detalhe => Finding.Detalhe;
+    public string? TextoDaAcao => Finding.TextoDaAcao;
+    public bool TemAcao => Finding.Acao != FindingAcao.Nenhuma && Finding.TextoDaAcao is not null;
+    public FindingSeverity Severidade => Finding.Severidade;
+
+    public string TextoDeSeveridade => Finding.Severidade switch
+    {
+        FindingSeverity.Critico => "Critico",
+        FindingSeverity.Atencao => "Atencao",
+        _ => "Informativo"
+    };
+}
+
+/// <summary>
+/// Painel de diagnostico (secao 5.5): cinco medidores ao vivo, grafico de 60 s,
+/// top 10 processos e a lista de findings em linguagem humana.
+///
+/// A coleta roda em Task propria dentro do BottleneckMonitor; aqui so
+/// devolvemos cada tique para a thread da UI (regra 10).
+/// </summary>
+public sealed partial class DiagnosticoPageViewModel : PageViewModelBase, IDisposable
+{
+    private readonly BottleneckMonitor _monitor;
+    private readonly HealthReportModule _relatorio;
+    private readonly IMemoryService _memoria;
+    private readonly IGameBoostLogger _log;
+    private bool _inscrito;
+
+    public DiagnosticoPageViewModel(
+        BottleneckMonitor monitor,
+        HealthReportModule relatorio,
+        IMemoryService memoria,
+        IGameBoostLogger log)
+    {
+        _monitor = monitor;
+        _relatorio = relatorio;
+        _memoria = memoria;
+        _log = log;
+
+        Cpu = new MedidorViewModel("CPU", "%", 100);
+        Gpu = new MedidorViewModel("GPU", "%", 100);
+        Ram = new MedidorViewModel("Memoria", "%", 100);
+        Disco = new MedidorViewModel("Disco", "%", 100);
+        Rede = new MedidorViewModel("Rede", "MB/s", 10);
+
+        Medidores = new ObservableCollection<MedidorViewModel> { Cpu, Gpu, Ram, Disco, Rede };
+
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+    }
+
+    public override string Nome => "Diagnostico";
+    public override string Titulo => "Diagnostico de gargalos";
+    public override string Subtitulo => "O que esta consumindo a maquina agora, e quem e o culpado.";
+    public override string Icone => "\uE9D9";
+
+    public ObservableCollection<MedidorViewModel> Medidores { get; }
+    public MedidorViewModel Cpu { get; }
+    public MedidorViewModel Gpu { get; }
+    public MedidorViewModel Ram { get; }
+    public MedidorViewModel Disco { get; }
+    public MedidorViewModel Rede { get; }
+
+    public ObservableCollection<ProcessUsage> TopProcessos { get; } = new();
+    public ObservableCollection<FindingViewModel> Findings { get; } = new();
+
+    [ObservableProperty] private bool _monitorando;
+    [ObservableProperty] private bool _ehAdministrador;
+    [ObservableProperty] private string _status = "Clique em Iniciar para acompanhar a maquina em tempo real.";
+    [ObservableProperty] private string? _temperaturaCpu;
+    [ObservableProperty] private string? _jogoDetectado;
+    [ObservableProperty] private string _custoDaColeta = string.Empty;
+
+    public bool SemFindings => Findings.Count == 0 && Monitorando;
+
+    /// <summary>Ao entrar na pagina o monitoramento comeca sozinho: e o que o usuario quer ver.</summary>
+    public override void AoEntrar()
+    {
+        if (!Monitorando)
+            Iniciar();
+    }
+
+    /// <summary>Sair da pagina para a coleta: nao faz sentido medir o que ninguem esta vendo.</summary>
+    public override void AoSair() => Parar();
+
+    [RelayCommand]
+    private void Iniciar()
+    {
+        if (Monitorando)
+            return;
+
+        if (!_inscrito)
+        {
+            _monitor.AoColetar += AoColetar;
+            _inscrito = true;
+        }
+
+        _monitor.Iniciar();
+        Monitorando = true;
+        Status = "Acompanhando a maquina. A coleta roda uma vez por segundo.";
+    }
+
+    [RelayCommand]
+    private void Parar()
+    {
+        if (!Monitorando)
+            return;
+
+        _monitor.Parar();
+        Monitorando = false;
+        Status = $"Monitoramento parado. Custo medio da coleta: {_monitor.CustoMedioDeCpuPercent:0.00}% de CPU.";
+    }
+
+    private void AoColetar(MonitorTick tique)
+    {
+        // O monitor roda em Task propria; tudo daqui para baixo e UI.
+        var dispatcher = Application.Current?.Dispatcher;
+        if (dispatcher is null)
+            return;
+
+        dispatcher.InvokeAsync(() => Aplicar(tique));
+    }
+
+    private void Aplicar(MonitorTick tique)
+    {
+        var s = tique.Snapshot;
+        var historico = _monitor.Buffer.Ultimos(TimeSpan.FromSeconds(60));
+
+        Cpu.Valor = s.CpuPercent;
+        Cpu.Texto = $"{s.CpuPercent:0}%";
+        Cpu.Detalhe = $"{s.NucleosLogicos} nucleos logicos";
+        Cpu.Serie = historico.Select(h => h.CpuPercent).ToList();
+
+        if (s.GpuPercent.Disponivel)
+        {
+            Gpu.Disponivel = true;
+            Gpu.Valor = s.GpuPercent.Valor;
+            Gpu.Texto = $"{s.GpuPercent.Valor:0}%";
+            Gpu.Serie = historico.Select(h => h.GpuPercent.OuZero).ToList();
+            Gpu.Detalhe = s.GpuMemoriaBytes.Disponivel
+                ? $"{GameModeModule.Formatar((long)s.GpuMemoriaBytes.Valor)} de VRAM em uso"
+                : null;
+        }
+        else
+        {
+            Gpu.Disponivel = false;
+            Gpu.Texto = "indisponivel";
+            Gpu.Detalhe = "Os contadores de GPU nao existem nesta maquina.";
+        }
+
+        Ram.Valor = s.RamUsadaPercent;
+        Ram.Texto = $"{s.RamUsadaPercent:0}%";
+        Ram.Detalhe = $"{GameModeModule.Formatar(s.RamDisponivelBytes)} livres de {GameModeModule.Formatar(s.RamTotalBytes)}"
+                    + (s.StandbyBytes > 0 ? $"  ·  {GameModeModule.Formatar(s.StandbyBytes)} em cache" : string.Empty);
+        Ram.Serie = historico.Select(h => h.RamUsadaPercent).ToList();
+
+        Disco.Valor = s.DiscoSistemaUsadoPercent;
+        Disco.Texto = $"{s.DiscoSistemaUsadoPercent:0}%";
+        Disco.Detalhe = "ocupacao do disco do sistema";
+        Disco.Serie = historico.Select(h => h.DiscoSistemaUsadoPercent).ToList();
+
+        if (s.RedeBytesPorSegundo.Disponivel)
+        {
+            var mbps = s.RedeBytesPorSegundo.Valor / (1024.0 * 1024.0);
+            Rede.Disponivel = true;
+            Rede.Valor = mbps;
+            Rede.Texto = $"{mbps:0.0} MB/s";
+            Rede.Detalhe = "soma das interfaces ativas";
+            Rede.Serie = historico
+                .Select(h => h.RedeBytesPorSegundo.OuZero / (1024.0 * 1024.0))
+                .ToList();
+        }
+        else
+        {
+            Rede.Disponivel = false;
+            Rede.Texto = "--";
+        }
+
+        TemperaturaCpu = s.TemperaturaCpu.Disponivel
+            ? $"CPU a {s.TemperaturaCpu.Valor:0} C"
+            : null;
+
+        TopProcessos.Clear();
+        foreach (var p in s.Processos.Take(10))
+            TopProcessos.Add(p);
+
+        AtualizarFindings(tique.Findings);
+
+        CustoDaColeta = $"A propria coleta custa {_monitor.CustoMedioDeCpuPercent:0.00}% de CPU.";
+    }
+
+    private void AtualizarFindings(IReadOnlyList<Finding> novos)
+    {
+        // Reconstroi so quando o conjunto muda: a lista nao pode piscar a cada segundo.
+        var idsAtuais = Findings.Select(f => f.Finding.Id).ToList();
+        var idsNovos = novos.Select(f => f.Id).ToList();
+
+        if (idsAtuais.SequenceEqual(idsNovos))
+            return;
+
+        Findings.Clear();
+        foreach (var f in novos)
+            Findings.Add(new FindingViewModel(f));
+
+        OnPropertyChanged(nameof(SemFindings));
+    }
+
+    /// <summary>Botao de acao de um finding. Cada acao leva para onde resolve.</summary>
+    [RelayCommand]
+    private void ExecutarAcao(FindingViewModel? item)
+    {
+        if (item is null)
+            return;
+
+        switch (item.Finding.Acao)
+        {
+            case FindingAcao.LimparRam:
+            case FindingAcao.PurgarStandby:
+                if (!EhAdministrador)
+                {
+                    Status = "Limpar memoria exige executar como administrador.";
+                    return;
+                }
+
+                var antes = _memoria.GetSnapshot();
+                var ok = _memoria.PurgeStandbyList();
+                var depois = _memoria.GetSnapshot();
+                var ganho = depois.AvailableBytes - antes.AvailableBytes;
+
+                // Regra 4: mostra o ganho medido, inclusive quando e zero.
+                Status = ok
+                    ? ganho > 0
+                        ? $"Standby List purgada: {GameModeModule.Formatar(ganho)} a mais de RAM livre."
+                        : "Standby List purgada, mas sem ganho mensuravel de memoria."
+                    : "Nao foi possivel purgar a Standby List.";
+                break;
+
+            case FindingAcao.AbrirSegurancaDoWindows:
+                Abrir("windowsdefender://coreisolation");
+                break;
+
+            case FindingAcao.AbrirConfiguracoesDeVideo:
+                Abrir("ms-settings:display-advanced");
+                break;
+
+            case FindingAcao.AtivarAltoDesempenho:
+                Abrir("ms-settings:powersleep");
+                break;
+
+            case FindingAcao.AbrirSiteDoDriver:
+                Abrir(EnderecoDoDriver(item.Finding));
+                break;
+
+            default:
+                Status = item.Finding.TextoDaAcao is null
+                    ? "Este achado e informativo."
+                    : $"{item.Finding.TextoDaAcao}: disponivel quando o modulo correspondente chegar.";
+                break;
+        }
+    }
+
+    private static string EnderecoDoDriver(Finding finding)
+    {
+        if (finding.Titulo.Contains("NVIDIA", StringComparison.OrdinalIgnoreCase))
+            return "https://www.nvidia.com/pt-br/drivers/";
+
+        if (finding.Titulo.Contains("AMD", StringComparison.OrdinalIgnoreCase))
+            return "https://www.amd.com/pt/support";
+
+        if (finding.Titulo.Contains("Intel", StringComparison.OrdinalIgnoreCase))
+            return "https://www.intel.com.br/content/www/br/pt/download-center/home.html";
+
+        return "https://www.google.com/search?q=atualizar+driver+de+video";
+    }
+
+    private void Abrir(string destino)
+    {
+        try
+        {
+            Process.Start(new ProcessStartInfo { FileName = destino, UseShellExecute = true });
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            _log.Warn("Diagnostico", "Abrir", destino, ex.Message);
+            Status = "Nao foi possivel abrir esse destino.";
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_inscrito)
+        {
+            _monitor.AoColetar -= AoColetar;
+            _inscrito = false;
+        }
+
+        _monitor.Parar();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/EspacoPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/EspacoPageViewModel.cs
new file mode 100644
index 0000000..7aaf13b
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/EspacoPageViewModel.cs
@@ -0,0 +1,315 @@
+using System.IO;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.DiskAnalyzer;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Native;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Um item de lista: arquivo grande, pasta grande ou jogo instalado.</summary>
+public sealed class ItemDeEspacoViewModel
+{
+    public ItemDeEspacoViewModel(string nome, string detalhe, long bytes, string caminho, string? marca = null)
+    {
+        Nome = nome;
+        Detalhe = detalhe;
+        Bytes = bytes;
+        Caminho = caminho;
+        Marca = marca;
+    }
+
+    public string Nome { get; }
+    public string Detalhe { get; }
+    public long Bytes { get; }
+    public string Caminho { get; }
+
+    /// <summary>Selo curto, como "parado há muito tempo".</summary>
+    public string? Marca { get; }
+
+    public string Tamanho => GameModeModule.Formatar(Bytes);
+    public bool TemMarca => Marca is not null;
+}
+
+/// <summary>
+/// Analisador de espaço em disco (seção 5.4) com a biblioteca de jogos (5.11).
+///
+/// Não implementa IModule: aqui nada é aplicado nem revertido. A página mostra
+/// onde está o espaço e abre no Explorer — quem apaga é o usuário, com as
+/// ferramentas do Windows.
+/// </summary>
+public sealed partial class EspacoPageViewModel : PageViewModelBase
+{
+    private readonly DiskScanner _scanner;
+    private readonly GameLibrary _biblioteca;
+    private readonly IGameBoostLogger _log;
+
+    private DiskScanResult? _resultado;
+    private CancellationTokenSource? _cts;
+
+    public EspacoPageViewModel(DiskScanner scanner, GameLibrary biblioteca, IGameBoostLogger log)
+    {
+        _scanner = scanner;
+        _biblioteca = biblioteca;
+        _log = log;
+
+        foreach (var unidade in DiskScanner.VolumesDisponiveis())
+            Volumes.Add(unidade.RootDirectory.FullName);
+
+        VolumeSelecionado = Volumes.FirstOrDefault()
+            ?? Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.Windows))
+            ?? @"C:\";
+    }
+
+    public override string Nome => "Espaco";
+    public override string Titulo => "Onde está o seu espaço";
+    public override string Subtitulo => "Varre o disco e mostra o que ocupa, do maior para o menor.";
+    public override string Icone => "\uE8B7";
+
+    public ObservableCollection<string> Volumes { get; } = new();
+    public ObservableCollection<ItemDeEspacoViewModel> MaioresArquivos { get; } = new();
+    public ObservableCollection<ItemDeEspacoViewModel> MaioresPastas { get; } = new();
+    public ObservableCollection<ItemDeEspacoViewModel> Jogos { get; } = new();
+    public ObservableCollection<SpecialFile> Especiais { get; } = new();
+
+    /// <summary>Caminho até a pasta aberta no treemap, para o botão de voltar.</summary>
+    public ObservableCollection<DiskNode> Trilha { get; } = new();
+
+    [ObservableProperty] private string _volumeSelecionado = @"C:\";
+    [ObservableProperty] private DiskNode? _noAtual;
+    [ObservableProperty] private bool _varrendo;
+    [ObservableProperty] private bool _jaVarreu;
+    [ObservableProperty] private int _progresso;
+    [ObservableProperty] private string _status = "Escolha um disco e clique em Varrer.";
+    [ObservableProperty] private string _resumo = string.Empty;
+    [ObservableProperty] private string? _sobOMouse;
+
+    public bool PodeSubir => Trilha.Count > 1;
+
+    [RelayCommand]
+    private async Task VarrerAsync()
+    {
+        if (Varrendo)
+            return;
+
+        _cts = new CancellationTokenSource();
+        Varrendo = true;
+        Progresso = 0;
+        Status = $"Lendo {VolumeSelecionado}...";
+
+        Limpar();
+
+        var volume = VolumeSelecionado;
+
+        try
+        {
+            var progresso = new Progress<ScanProgresso>(p =>
+            {
+                Status = $"{p.Arquivos:N0} arquivos, {GameModeModule.Formatar(p.Bytes)}...";
+
+                // Não há total conhecido antes do fim: a barra anda até 95% e
+                // completa na conclusão, em vez de fingir uma porcentagem exata.
+                Progresso = Math.Min(95, Progresso + 1);
+            });
+
+            var resultado = await Task.Run(() => _scanner.Varrer(volume, progresso, _cts.Token), _cts.Token);
+            var jogos = await Task.Run(() => _biblioteca.Listar(), _cts.Token);
+
+            _resultado = resultado;
+            Preencher(resultado, jogos);
+
+            Progresso = 100;
+            JaVarreu = true;
+        }
+        catch (OperationCanceledException)
+        {
+            Status = "Varredura cancelada.";
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            Status = $"Não foi possível varrer {volume}: {ex.Message}";
+            _log.Error("Espaco", "Varrer", volume, ex.Message, ex);
+        }
+        finally
+        {
+            Varrendo = false;
+        }
+    }
+
+    private void Limpar()
+    {
+        MaioresArquivos.Clear();
+        MaioresPastas.Clear();
+        Jogos.Clear();
+        Especiais.Clear();
+        Trilha.Clear();
+        NoAtual = null;
+    }
+
+    private void Preencher(DiskScanResult resultado, IReadOnlyList<JogoInstalado> jogos)
+    {
+        NoAtual = resultado.Raiz;
+        Trilha.Add(resultado.Raiz);
+
+        foreach (var arquivo in resultado.Raiz.MaioresArquivos(100))
+        {
+            MaioresArquivos.Add(new ItemDeEspacoViewModel(
+                arquivo.Nome,
+                Path.GetDirectoryName(arquivo.Caminho) ?? arquivo.Caminho,
+                arquivo.Tamanho,
+                arquivo.Caminho,
+                DiskCategories.Nome(arquivo.Categoria)));
+        }
+
+        foreach (var pasta in resultado.Raiz.MaioresPastas(50))
+        {
+            MaioresPastas.Add(new ItemDeEspacoViewModel(
+                pasta.Nome,
+                $"{pasta.TotalDeArquivos:N0} arquivos · {pasta.Caminho}",
+                pasta.Tamanho,
+                pasta.Caminho));
+        }
+
+        foreach (var jogo in jogos)
+        {
+            Jogos.Add(new ItemDeEspacoViewModel(
+                jogo.Nome,
+                $"{jogo.Launcher} · jogado {jogo.QuandoJogou}",
+                jogo.Bytes,
+                jogo.Pasta,
+                jogo.CandidatoADesinstalar ? "parado e grande" : null));
+        }
+
+        foreach (var especial in SpecialFiles.Encontrar(resultado.Raiz.Caminho))
+            Especiais.Add(especial);
+
+        var ocupado = resultado.EspacoTotal - resultado.EspacoLivre;
+        var naoAlcancado = ocupado - resultado.Raiz.Tamanho;
+
+        Resumo = $"{GameModeModule.Formatar(resultado.Raiz.Tamanho)} mapeados em "
+               + $"{resultado.TotalDeArquivos:N0} arquivos, em {resultado.Duracao.TotalSeconds:0.0} segundos. "
+               + $"Livre: {GameModeModule.Formatar(resultado.EspacoLivre)} de "
+               + $"{GameModeModule.Formatar(resultado.EspacoTotal)}.";
+
+        // Honestidade sobre o que a varredura não alcançou (regra 4).
+        Status = resultado.PastasIgnoradas > 0
+            ? $"{resultado.PastasIgnoradas} pastas não puderam ser lidas (permissão do Windows). "
+            + $"Faltam {GameModeModule.Formatar(Math.Max(0, naoAlcancado))} para fechar com o espaço ocupado."
+            : "Varredura concluída.";
+    }
+
+    // ---------------- Navegação no treemap ----------------
+
+    public void Entrar(DiskNode pasta)
+    {
+        if (!pasta.EhPasta || pasta.Filhos.Count == 0)
+            return;
+
+        Trilha.Add(pasta);
+        NoAtual = pasta;
+        OnPropertyChanged(nameof(PodeSubir));
+    }
+
+    [RelayCommand]
+    private void Subir()
+    {
+        if (Trilha.Count <= 1)
+            return;
+
+        Trilha.RemoveAt(Trilha.Count - 1);
+        NoAtual = Trilha[^1];
+        OnPropertyChanged(nameof(PodeSubir));
+    }
+
+    [RelayCommand]
+    private void VoltarParaRaiz()
+    {
+        if (_resultado is null)
+            return;
+
+        Trilha.Clear();
+        Trilha.Add(_resultado.Raiz);
+        NoAtual = _resultado.Raiz;
+        OnPropertyChanged(nameof(PodeSubir));
+    }
+
+    public void MostrarNoRodape(DiskNode? no)
+        => SobOMouse = no is null
+            ? null
+            : $"{no.Caminho} — {GameModeModule.Formatar(no.Tamanho)}"
+            + (no.EhPasta ? $" em {no.TotalDeArquivos:N0} arquivos" : string.Empty);
+
+    // ---------------- Ações ----------------
+
+    /// <summary>
+    /// Abre no Explorer com o item já selecionado. O GameBoost não apaga nada
+    /// daqui: a seção 5.4 é para mostrar, e quem decide é o usuário.
+    /// </summary>
+    [RelayCommand]
+    private void AbrirNoExplorer(ItemDeEspacoViewModel? item)
+    {
+        if (item is null)
+            return;
+
+        try
+        {
+            var existeArquivo = File.Exists(item.Caminho);
+            var argumento = existeArquivo ? $"/select,\"{item.Caminho}\"" : $"\"{item.Caminho}\"";
+
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = "explorer.exe",
+                Arguments = argumento,
+                UseShellExecute = true
+            });
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            Status = "Não foi possível abrir o Explorer.";
+            _log.Warn("Espaco", "AbrirNoExplorer", item.Caminho, ex.Message);
+        }
+    }
+
+    /// <summary>Manda um item para a Lixeira, com confirmação e sem apagar de vez.</summary>
+    [RelayCommand]
+    private void MandarParaLixeira(ItemDeEspacoViewModel? item)
+    {
+        if (item is null)
+            return;
+
+        var resposta = MessageBox.Show(
+            $"Enviar para a Lixeira?\n\n{item.Caminho}\n{item.Tamanho}\n\n"
+            + "Dá para recuperar pela Lixeira do Windows enquanto ela não for esvaziada.",
+            "Enviar para a Lixeira", MessageBoxButton.YesNo, MessageBoxImage.Warning);
+
+        if (resposta != MessageBoxResult.Yes)
+            return;
+
+        if (RecycleBinBridge.ParaLixeira(new[] { item.Caminho }))
+        {
+            Status = $"{item.Nome} foi para a Lixeira. Varra de novo para atualizar os números.";
+            _log.Info("Espaco", "ParaLixeira", item.Caminho, item.Tamanho);
+        }
+        else
+        {
+            Status = "O Windows recusou mover para a Lixeira. O arquivo pode estar em uso.";
+        }
+    }
+
+    [RelayCommand]
+    private void ExplicarEspecial(SpecialFile? arquivo)
+    {
+        if (arquivo is null)
+            return;
+
+        MessageBox.Show(SpecialFiles.Descrever(arquivo), arquivo.Nome,
+            MessageBoxButton.OK, MessageBoxImage.Information);
+    }
+
+    [RelayCommand]
+    private void Cancelar() => _cts?.Cancel();
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/FerramentasPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/FerramentasPageViewModel.cs
new file mode 100644
index 0000000..795bc85
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/FerramentasPageViewModel.cs
@@ -0,0 +1,192 @@
+using System.Collections.ObjectModel;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Tools;
+
+namespace GameBoost.App.ViewModels;
+
+public sealed partial class FerramentaViewModel : ObservableObject
+{
+    public FerramentaViewModel(QuickTool ferramenta)
+    {
+        Ferramenta = ferramenta;
+    }
+
+    public QuickTool Ferramenta { get; }
+
+    public string Id => Ferramenta.Id;
+    public string Titulo => Ferramenta.Titulo;
+    public string Descricao => Ferramenta.Descricao;
+    public string Categoria => Ferramenta.Categoria;
+    public RiskLevel Risco => Ferramenta.Risco;
+    public string? Duracao => Ferramenta.Duracao;
+    public bool PrecisaAdmin => Ferramenta.PrecisaAdmin;
+
+    public string TextoDeRisco => Ferramenta.Risco switch
+    {
+        RiskLevel.Alto => "Risco alto",
+        RiskLevel.Medio => "Risco medio",
+        _ => "Risco baixo"
+    };
+
+    [ObservableProperty] private bool _rodando;
+    [ObservableProperty] private string? _resultado;
+    [ObservableProperty] private bool _falhou;
+
+    public bool TemResultado => !string.IsNullOrWhiteSpace(Resultado);
+
+    partial void OnResultadoChanged(string? value) => OnPropertyChanged(nameof(TemResultado));
+}
+
+/// <summary>
+/// Página de Ferramentas rápidas (seção 5.13).
+///
+/// Não herda de ModulePageViewModel de propósito: aqui não existe lista de
+/// itens para marcar e aplicar em lote. São ações independentes, cada uma com
+/// a própria confirmação e o próprio resultado.
+/// </summary>
+public sealed partial class FerramentasPageViewModel : PageViewModelBase
+{
+    private readonly QuickToolsService _servico;
+    private CancellationTokenSource? _cts;
+
+    public FerramentasPageViewModel(QuickToolsService servico)
+    {
+        _servico = servico;
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+
+        foreach (var ferramenta in QuickToolsCatalog.Todas())
+            Ferramentas.Add(new FerramentaViewModel(ferramenta));
+    }
+
+    public override string Nome => "Ferramentas";
+    public override string Titulo => "Ferramentas rápidas";
+    public override string Subtitulo => "Atalhos para o que normalmente exige prompt de comando.";
+    public override string Icone => "\uE912";
+
+    public ObservableCollection<FerramentaViewModel> Ferramentas { get; } = new();
+
+    [ObservableProperty] private bool _ehAdministrador;
+    [ObservableProperty] private string _status = "Cada ferramenta explica o que faz e como desfazer.";
+    [ObservableProperty] private string? _saidaLonga;
+    [ObservableProperty] private bool _ocupado;
+
+    public bool TemSaida => !string.IsNullOrWhiteSpace(SaidaLonga);
+
+    partial void OnSaidaLongaChanged(string? value) => OnPropertyChanged(nameof(TemSaida));
+
+    [RelayCommand]
+    private async Task ExecutarAsync(FerramentaViewModel? item)
+    {
+        if (item is null || Ocupado)
+            return;
+
+        var f = item.Ferramenta;
+
+        if (f.PrecisaAdmin && !EhAdministrador)
+        {
+            item.Falhou = true;
+            item.Resultado = "Esta ferramenta exige executar o GameBoost como administrador.";
+            return;
+        }
+
+        if (f.Confirmacao is not null)
+        {
+            var texto = f.Confirmacao;
+
+            if (f.Duracao is not null)
+                texto += $"\n\nIsto {f.Duracao}.";
+
+            var resposta = MessageBox.Show(texto, f.Titulo,
+                MessageBoxButton.YesNo, MessageBoxImage.Warning);
+
+            if (resposta != MessageBoxResult.Yes)
+                return;
+        }
+
+        _cts = new CancellationTokenSource();
+        Ocupado = true;
+        item.Rodando = true;
+        item.Falhou = false;
+        item.Resultado = null;
+        SaidaLonga = null;
+        Status = f.Duracao is null ? $"{f.Titulo}..." : $"{f.Titulo} — {f.Duracao}.";
+
+        // Ferramenta demorada mostra a saída ao vivo: sem isso o usuário acha
+        // que travou e mata o app no meio de um sfc.
+        var progresso = f.Tipo == ToolKind.Demorada
+            ? new Progress<string>(linha => SaidaLonga = (SaidaLonga ?? string.Empty) + linha + Environment.NewLine)
+            : null;
+
+        try
+        {
+            var resultado = await _servico.ExecutarAsync(f.Id, progresso, _cts.Token);
+
+            item.Falhou = !resultado.Sucesso;
+            item.Resultado = resultado.Mensagem;
+
+            if (!string.IsNullOrWhiteSpace(resultado.Detalhe))
+                SaidaLonga = resultado.Detalhe;
+
+            Status = resultado.Mensagem;
+        }
+        catch (OperationCanceledException)
+        {
+            item.Resultado = "Cancelado.";
+            Status = "Cancelado.";
+        }
+        finally
+        {
+            item.Rodando = false;
+            Ocupado = false;
+        }
+    }
+
+    [RelayCommand]
+    private void Cancelar() => _cts?.Cancel();
+
+    [RelayCommand]
+    private void CopiarSaida()
+    {
+        if (string.IsNullOrWhiteSpace(SaidaLonga))
+            return;
+
+        try
+        {
+            Clipboard.SetText(SaidaLonga);
+            Status = "Copiado. É só colar onde precisar.";
+        }
+        catch (System.Runtime.InteropServices.ExternalException)
+        {
+            // A área de transferência pode estar presa por outro app.
+            Status = "Não foi possível copiar: outro programa está usando a área de transferência.";
+        }
+    }
+
+    [RelayCommand]
+    private void LimparSaida() => SaidaLonga = null;
+
+    /// <summary>Explicação do botão "?": o que faz, risco e como desfazer.</summary>
+    [RelayCommand]
+    private void Explicar(FerramentaViewModel? item)
+    {
+        if (item is null)
+            return;
+
+        var f = item.Ferramenta;
+        var texto = $"O que faz: {f.Descricao}\n\nRisco: {item.TextoDeRisco}";
+
+        if (f.Duracao is not null)
+            texto += $"\n\nDuração: {f.Duracao}";
+
+        if (f.PrecisaAdmin)
+            texto += "\n\nExige executar como administrador.";
+
+        texto += $"\n\nComo desfazer: {f.ComoDesfazer}";
+
+        MessageBox.Show(texto, f.Titulo, MessageBoxButton.OK, MessageBoxImage.Information);
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/InicializacaoPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/InicializacaoPageViewModel.cs
new file mode 100644
index 0000000..7f9da7d
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/InicializacaoPageViewModel.cs
@@ -0,0 +1,34 @@
+using GameBoost.Core.Modules.Startup;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Página de inicialização (seção 5.6). Também herda a tela do padrão de módulo:
+/// "Aplicar N selecionados" aqui significa desativar, e "Reverter" reativa.
+/// </summary>
+public sealed class InicializacaoPageViewModel : ModulePageViewModel
+{
+    public InicializacaoPageViewModel(StartupModule modulo, IStateBackup backup)
+        : base(modulo, backup)
+    {
+    }
+
+    public override string Nome => "Inicializacao";
+    public override string Titulo => "O que abre com o Windows";
+    public override string Subtitulo => "Podar a inicialização é, junto com o plano de energia, o ajuste de maior valor.";
+    public override string Icone => "\uE7E8";
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var nomes = string.Join("\n  ", selecionados.Take(12).Select(i => i.Titulo));
+        var extra = selecionados.Count > 12 ? $"\n  ... e mais {selecionados.Count - 12}" : string.Empty;
+
+        return $"Impedir que {selecionados.Count} programa(s) abram junto com o Windows?\n\n"
+             + $"  {nomes}{extra}\n\n"
+             + "Os programas continuam instalados e você pode abrir quando quiser. "
+             + "O efeito aparece no próximo boot.\n\n"
+             + "Para reativar, use o botão Reverter aqui, o Gerenciador de Tarefas ou "
+             + "Configurações, Aplicativos, Inicializar.";
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/InicioPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/InicioPageViewModel.cs
new file mode 100644
index 0000000..06e7989
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/InicioPageViewModel.cs
@@ -0,0 +1,390 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.HealthReport;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Pagina Inicio: Modo Game, pontuacao e findings (secao 6).
+///
+/// Herda o padrao de pagina de modulo, mas troca o rodape generico
+/// "Aplicar N selecionados" pelos botoes do Modo Game, que e o que o usuario
+/// espera encontrar na abertura.
+/// </summary>
+/// <summary>Uma linha da lista de restauracao.</summary>
+public sealed class AppParaReabrir
+{
+    public AppParaReabrir(Core.Modules.GameMode.ClosedApp item)
+    {
+        Item = item;
+    }
+
+    public Core.Modules.GameMode.ClosedApp Item { get; }
+
+    public string Nome => Item.Nome;
+
+    public string Detalhe => Item.Essencial
+        ? "marcado como essencial"
+        : "não reabre sozinho porque não está marcado com estrela";
+}
+
+public sealed partial class InicioPageViewModel : ModulePageViewModel
+{
+    private readonly GameModeModule _gameMode;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly ISessionStore _sessions;
+    private readonly HealthReportModule _saude;
+    private readonly IMemoryService _memoria;
+    private readonly IProcessService _processos;
+    private readonly IGameBoostLogger _log;
+    private CancellationTokenSource? _ctsSaude;
+
+    public InicioPageViewModel(
+        GameModeModule gameMode,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        ISessionStore sessions,
+        HealthReportModule saude,
+        IMemoryService memoria,
+        IProcessService processos,
+        IGameBoostLogger log)
+        : base(gameMode, backup)
+    {
+        _gameMode = gameMode;
+        _memoria = memoria;
+        _processos = processos;
+        _saude = saude;
+        _backup = backup;
+        _rollback = rollback;
+        _sessions = sessions;
+        _log = log;
+
+        // Aviso na abertura se o app morreu com o Modo Game ativo (secao 1).
+        var sessao = _sessions.Load();
+        if (sessao.Ativo)
+        {
+            ModoGameAtivo = true;
+            AtualizarListaDeRestauracao();
+            AvisoDeRestauracao =
+                "O GameBoost foi fechado com o Modo Game ainda ativo. " +
+                "Clique em Restaurar agora para devolver o sistema ao estado anterior.";
+        }
+        else if (_backup.TemPendencias)
+        {
+            AvisoDeRestauracao =
+                $"Existem {_backup.Pendentes.Count} alteracoes de sistema pendentes de reversao.";
+        }
+    }
+
+    public override string Nome => "Inicio";
+    public override string Titulo => "Modo Game";
+    public override string Subtitulo => "Encerra o que voce confirmar, libera RAM e prepara o sistema para o jogo.";
+    public override string Icone => "\uE80F";
+
+    [ObservableProperty] private bool _modoGameAtivo;
+    [ObservableProperty] private string? _avisoDeRestauracao;
+
+    /// <summary>
+    /// Apps encerrados que ainda nao voltaram. Sem estrela eles nao reabrem
+    /// sozinhos, e ate agora o app anunciava "N aguardando na lista de
+    /// restauracao" sem existir lista nenhuma para agir.
+    /// </summary>
+    public ObservableCollection<AppParaReabrir> ParaReabrir { get; } = new();
+
+    public bool TemAppsParaReabrir => ParaReabrir.Count > 0;
+
+    private void AtualizarListaDeRestauracao()
+    {
+        ParaReabrir.Clear();
+
+        foreach (var app in _sessions.Load().AppsEncerrados.Where(a => !a.Reaberto))
+        {
+            if (!string.IsNullOrWhiteSpace(app.ExecutablePath))
+                ParaReabrir.Add(new AppParaReabrir(app));
+        }
+
+        OnPropertyChanged(nameof(TemAppsParaReabrir));
+    }
+
+    /// <summary>Reabre um app da lista, e so ele.</summary>
+    [RelayCommand]
+    private void Reabrir(AppParaReabrir? alvo)
+    {
+        if (alvo?.Item.ExecutablePath is null)
+            return;
+
+        var ok = _processos.Start(
+            alvo.Item.ExecutablePath, alvo.Item.Argumentos, alvo.Item.WorkingDirectory);
+
+        if (!ok)
+        {
+            Status = $"Não foi possível reabrir {alvo.Nome}. "
+                   + "Alguns apps da Microsoft Store só abrem pelo menu Iniciar.";
+            return;
+        }
+
+        // Marcar no arquivo, senao ele reaparece na lista na proxima abertura.
+        var sessao = _sessions.Load();
+
+        foreach (var app in sessao.AppsEncerrados.Where(a =>
+                     string.Equals(a.Nome, alvo.Item.Nome, StringComparison.OrdinalIgnoreCase)))
+        {
+            app.Reaberto = true;
+        }
+
+        _sessions.Save(sessao);
+
+        ParaReabrir.Remove(alvo);
+        OnPropertyChanged(nameof(TemAppsParaReabrir));
+
+        Status = $"{alvo.Nome} reaberto.";
+        _log.Info("gamemode", "Reabrir", alvo.Nome, "pela lista de restauração");
+    }
+
+    /// <summary>Encerra a sessao no arquivo e limpa a lista da tela.</summary>
+    private void EncerrarSessao()
+    {
+        var sessao = _sessions.Load();
+
+        if (!sessao.Ativo && sessao.AppsEncerrados.Count == 0)
+            return;
+
+        sessao.Ativo = false;
+        _sessions.Save(sessao);
+
+        AtualizarListaDeRestauracao();
+    }
+
+    // ------------------------------------------------------------------
+    // Pontuacao de saude e principais findings (secoes 5.12 e 5.5)
+    // ------------------------------------------------------------------
+
+    public ObservableCollection<AreaScore> Areas { get; } = new();
+    public ObservableCollection<FindingViewModel> PrincipaisFindings { get; } = new();
+
+    [ObservableProperty] private bool _pontuacaoDisponivel;
+    [ObservableProperty] private bool _analisando;
+    [ObservableProperty] private int _notaGeral;
+    [ObservableProperty] private string _conceito = string.Empty;
+    [ObservableProperty] private string _progressoDaAnalise = string.Empty;
+
+    public string PontuacaoPlaceholder =>
+        "Clique em Analisar para medir a maquina e ver a nota de saude com os principais achados.";
+
+    /// <summary>Roda o relatorio de saude completo: mede por alguns segundos e pontua.</summary>
+    [RelayCommand]
+    private async Task AnalisarSaudeAsync()
+    {
+        if (Analisando)
+            return;
+
+        _ctsSaude = new CancellationTokenSource();
+        Analisando = true;
+        ProgressoDaAnalise = "Medindo a maquina...";
+
+        var progresso = new Progress<ModuleProgress>(p => ProgressoDaAnalise = p.Etapa);
+
+        try
+        {
+            var relatorio = await _saude.GerarAsync(progresso, _ctsSaude.Token);
+
+            NotaGeral = relatorio.Pontuacao.NotaGeral;
+            Conceito = relatorio.Pontuacao.Conceito;
+
+            Areas.Clear();
+            foreach (var area in relatorio.Pontuacao.Areas)
+                Areas.Add(area);
+
+            PrincipaisFindings.Clear();
+            foreach (var f in relatorio.Pontuacao.Principais)
+                PrincipaisFindings.Add(new FindingViewModel(f));
+
+            PontuacaoDisponivel = true;
+            ProgressoDaAnalise = PrincipaisFindings.Count == 0
+                ? "Nada fora do lugar."
+                : $"{PrincipaisFindings.Count} achados. Detalhes no Diagnostico.";
+        }
+        catch (OperationCanceledException)
+        {
+            ProgressoDaAnalise = "Analise cancelada.";
+        }
+        finally
+        {
+            Analisando = false;
+        }
+    }
+
+    [RelayCommand]
+    private void CancelarAnalise() => _ctsSaude?.Cancel();
+
+    /// <summary>Exportar o relatorio para mandar a quem da suporte (secao 5.12).</summary>
+    [RelayCommand]
+    private async Task ExportarRelatorioAsync()
+    {
+        var dialogo = new Microsoft.Win32.SaveFileDialog
+        {
+            FileName = $"gameboost-saude-{DateTime.Now:yyyy-MM-dd-HHmm}.html",
+            Filter = "Pagina HTML (*.html)|*.html|Dados JSON (*.json)|*.json",
+            Title = "Salvar relatorio de saude"
+        };
+
+        if (dialogo.ShowDialog() != true)
+            return;
+
+        Analisando = true;
+        ProgressoDaAnalise = "Medindo a maquina para o relatorio...";
+
+        try
+        {
+            var relatorio = await _saude.GerarAsync(
+                new Progress<ModuleProgress>(p => ProgressoDaAnalise = p.Etapa),
+                CancellationToken.None);
+
+            var json = dialogo.FileName.EndsWith(".json", StringComparison.OrdinalIgnoreCase);
+            var conteudo = json
+                ? HtmlReportWriter.GerarJson(relatorio)
+                : HtmlReportWriter.GerarHtml(relatorio);
+
+            File.WriteAllText(dialogo.FileName, conteudo, new System.Text.UTF8Encoding(false));
+
+            ProgressoDaAnalise = $"Relatorio salvo em {dialogo.FileName}";
+            _log.Info("Inicio", "ExportarRelatorio", dialogo.FileName, $"nota {relatorio.Pontuacao.NotaGeral}");
+        }
+        catch (IOException ex)
+        {
+            ProgressoDaAnalise = $"Nao foi possivel salvar: {ex.Message}";
+        }
+        finally
+        {
+            Analisando = false;
+        }
+    }
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        if (selecionados.Count == 0)
+            return "Nenhum app foi marcado. O Modo Game vai apenas ajustar o sistema "
+                 + "(energia, gravacao, Windows Update). Continuar?";
+
+        var nomes = string.Join("\n  ", selecionados.Take(12).Select(i => i.Titulo));
+        var extra = selecionados.Count > 12 ? $"\n  ... e mais {selecionados.Count - 12}" : string.Empty;
+
+        return $"O GameBoost vai encerrar {selecionados.Count} app(s):\n\n  {nomes}{extra}\n\n"
+             + "Cada um recebe primeiro o pedido de fechamento normal, com 3 segundos para salvar.\n\n"
+             + "Continuar?";
+    }
+
+    protected override void AposAplicar(ApplyResult resultado)
+    {
+        if (resultado.DryRun)
+            return;
+
+        ModoGameAtivo = true;
+        AvisoDeRestauracao = null;
+    }
+
+    protected override void AposReverter(ApplyResult resultado)
+    {
+        if (resultado.DryRun)
+            return;
+
+        ModoGameAtivo = false;
+        AvisoDeRestauracao = null;
+
+        // O que nao tinha estrela nao volta sozinho: aparece aqui com botao.
+        AtualizarListaDeRestauracao();
+    }
+
+    /// <summary>
+    /// Libera memoria sem ativar o Modo Game. E o item "Limpar RAM" da bandeja.
+    ///
+    /// O ganho e medido, nao estimado: mede a RAM livre antes, roda, mede
+    /// depois e mostra a diferenca. Boosters costumam anunciar aqui um numero
+    /// inventado; quando o Windows ja estava bem de memoria, o numero honesto
+    /// e "quase nada", e e isso que aparece.
+    /// </summary>
+    [RelayCommand]
+    private void LimparRam()
+    {
+        if (!EhAdministrador)
+        {
+            Status = "Liberar memoria precisa de privilegios de administrador.";
+            return;
+        }
+
+        var antes = _memoria.GetSnapshot();
+
+        var processos = 0;
+
+        foreach (var p in _processos.GetProcesses())
+        {
+            if (_processos.TrimWorkingSet(p.Pid) > 0)
+                processos++;
+        }
+
+        var purgou = _memoria.PurgeStandbyList();
+        var depois = _memoria.GetSnapshot();
+        var ganho = depois.AvailableBytes - antes.AvailableBytes;
+
+        Status = ganho > 0
+            ? $"{Core.Modules.GameMode.GameModeModule.Formatar(ganho)} a mais de RAM livre "
+            + $"({processos} processos{(purgou ? ", Standby List purgada" : string.Empty)})."
+            : "A memoria ja estava livre: nao havia o que liberar. "
+            + "Isso e normal em maquina com RAM sobrando.";
+
+        _log.Info("gamemode", "LimparRam", null, Status);
+    }
+
+    /// <summary>Botao Reverter tudo: sempre visivel, desfaz qualquer alteracao pendente.</summary>
+    [RelayCommand]
+    private void ReverterTudo()
+    {
+        if (!EhAdministrador)
+            return;
+
+        if (!_backup.TemPendencias)
+        {
+            Status = "Nada a reverter: nenhuma alteracao pendente.";
+            return;
+        }
+
+        var pendentes = _backup.Pendentes.Count;
+        var resposta = MessageBox.Show(
+            $"Desfazer {pendentes} alteracao(oes) de sistema feitas pelo GameBoost?",
+            "Reverter tudo", MessageBoxButton.YesNo, MessageBoxImage.Question);
+
+        if (resposta != MessageBoxResult.Yes)
+            return;
+
+        var resultados = _rollback.ReverterTudo(DryRun);
+        var falhas = resultados.Count(r => !r.Sucesso);
+
+        // Encerrar a sessao no arquivo, e nao so na tela.
+        //
+        // Sem isto, o session.json continuava dizendo Ativo=true para sempre, e
+        // o aviso "foi fechado com o Modo Game ainda ativo" voltava em TODA
+        // abertura — mesmo com zero pendencias. Um aviso que aparece sempre
+        // deixa de ser aviso.
+        if (!DryRun)
+            EncerrarSessao();
+
+        ModoGameAtivo = false;
+        AvisoDeRestauracao = null;
+        Status = falhas == 0
+            ? $"{resultados.Count} alteracoes revertidas."
+            : $"{resultados.Count - falhas} revertidas, {falhas} falharam. Veja o log.";
+
+        _log.Info("App", "ReverterTudo", null, Status);
+        OnPropertyChanged(nameof(TemPendencias));
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/JogosPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/JogosPageViewModel.cs
new file mode 100644
index 0000000..bfbb67e
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/JogosPageViewModel.cs
@@ -0,0 +1,303 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules.DiskAnalyzer;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.Profiles;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Um jogo da biblioteca, com ou sem perfil.</summary>
+public sealed partial class JogoViewModel : ObservableObject
+{
+    public JogoViewModel(string nome, string? caminho, string launcher, long bytes, string quandoJogou, GameProfile? perfil)
+    {
+        Nome = nome;
+        Caminho = caminho;
+        Launcher = launcher;
+        Bytes = bytes;
+        QuandoJogou = quandoJogou;
+        _perfil = perfil;
+    }
+
+    public string Nome { get; }
+    public string? Caminho { get; }
+    public string Launcher { get; }
+    public long Bytes { get; }
+    public string QuandoJogou { get; }
+
+    [ObservableProperty] private GameProfile? _perfil;
+
+    public bool TemPerfil => Perfil is not null;
+
+    public string Tamanho => Bytes > 0 ? GameModeModule.Formatar(Bytes) : "tamanho desconhecido";
+
+    public string Detalhe => Perfil is null
+        ? $"{Launcher} · {Tamanho} · {QuandoJogou} · sem perfil"
+        : $"{Launcher} · {Tamanho} · {QuandoJogou} · {Perfil.Resumo}";
+
+    partial void OnPerfilChanged(GameProfile? value)
+    {
+        OnPropertyChanged(nameof(TemPerfil));
+        OnPropertyChanged(nameof(Detalhe));
+    }
+}
+
+/// <summary>
+/// Página Jogos (seções 5.1 e 5.11).
+///
+/// Junta a biblioteca lida dos launchers com os perfis gravados. Um jogo sem
+/// perfil aparece igual aos outros, com o botão de criar; o perfil não é
+/// obrigatório para nada, e o Modo Game continua funcionando sem ele.
+/// </summary>
+public sealed partial class JogosPageViewModel : PageViewModelBase
+{
+    private readonly GameLibrary _biblioteca;
+    private readonly ProfileStore _perfis;
+    private readonly GameWatcher _vigia;
+    private readonly ProfileRunner _executor;
+
+    public JogosPageViewModel(
+        GameLibrary biblioteca,
+        ProfileStore perfis,
+        GameWatcher vigia,
+        ProfileRunner executor)
+    {
+        _biblioteca = biblioteca;
+        _perfis = perfis;
+        _vigia = vigia;
+        _executor = executor;
+
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+    }
+
+    public override string Nome => "Jogos";
+    public override string Titulo => "Jogos e perfis";
+    public override string Subtitulo => "Cada jogo com os seus ajustes, aplicados ao abrir e desfeitos ao fechar.";
+    public override string Icone => "\uE7FC";
+
+    public ObservableCollection<JogoViewModel> Jogos { get; } = new();
+
+    [ObservableProperty] private string _resumo = "Clique em Varrer para ler a sua biblioteca.";
+    [ObservableProperty] private string _status = string.Empty;
+    [ObservableProperty] private bool _ocupado;
+    [ObservableProperty] private bool _ehAdministrador;
+    [ObservableProperty] private bool _vigiaLigado;
+    [ObservableProperty] private string _jogoEmExecucao = string.Empty;
+    [ObservableProperty] private JogoViewModel? _selecionado;
+
+    /// <summary>
+    /// Lista vazia. A visibilidade do texto de estado vazio precisa depender
+    /// disto, nao do Resumo: o Resumo nunca fica vazio, entao o texto ficava
+    /// desenhado por cima da lista cheia.
+    /// </summary>
+    public bool ListaVazia => Jogos.Count == 0;
+
+    public override void AoEntrar()
+    {
+        base.AoEntrar();
+        VigiaLigado = _vigia.Ativo;
+        AtualizarJogoEmExecucao();
+    }
+
+    private void AtualizarJogoEmExecucao()
+    {
+        var atual = _vigia.JogoAtual;
+
+        JogoEmExecucao = atual is null
+            ? string.Empty
+            : _executor.EmSessao
+                ? $"{atual.Process.Name} rodando, perfil aplicado."
+                : $"{atual.Process.Name} rodando, sem perfil aplicado.";
+    }
+
+    [RelayCommand]
+    public async Task VarrerAsync()
+    {
+        if (Ocupado)
+            return;
+
+        Ocupado = true;
+        Jogos.Clear();
+        Resumo = "Lendo Steam, Epic, GOG e Xbox...";
+
+        try
+        {
+            var achados = await Task.Run(() => _biblioteca.Listar());
+
+            var perfis = _perfis.Todos.ToList();
+
+            foreach (var jogo in achados)
+            {
+                Jogos.Add(new JogoViewModel(
+                    jogo.Nome, jogo.Pasta, jogo.Launcher, jogo.Bytes, jogo.QuandoJogou,
+                    CasarPerfil(jogo, perfis)));
+            }
+
+            // Perfis de jogos que a biblioteca não achou: instalado fora de
+            // launcher, ou launcher que o GameBoost ainda não lê. Some da tela
+            // seria pior que aparecer sem tamanho.
+            foreach (var perfil in perfis)
+            {
+                if (Jogos.Any(j => j.Perfil?.Executavel == perfil.Executavel))
+                    continue;
+
+                Jogos.Add(new JogoViewModel(
+                    perfil.Nome, perfil.Caminho, perfil.Launcher ?? "fora de launcher",
+                    0, perfil.UltimaVez is null ? "nunca usado pelo perfil" : $"perfil usado {perfil.VezesUsado}x",
+                    perfil));
+            }
+
+            OnPropertyChanged(nameof(ListaVazia));
+
+            var comPerfil = Jogos.Count(j => j.TemPerfil);
+            var total = Jogos.Sum(j => j.Bytes);
+
+            Resumo = $"{Jogos.Count} jogos, {GameModeModule.Formatar(total)} no total. "
+                   + $"{comPerfil} com perfil.";
+
+            Status = VigiaLigado
+                ? "A detecção automática está ligada: ao abrir um jogo, o GameBoost pergunta."
+                : "A detecção automática está desligada. Ligue em Configurações para o GameBoost "
+                + "reconhecer o jogo sozinho.";
+        }
+        catch (OperationCanceledException)
+        {
+            Status = "Varredura cancelada.";
+        }
+        finally
+        {
+            Ocupado = false;
+        }
+    }
+
+    /// <summary>Cria um perfil padrão para o jogo selecionado.</summary>
+    [RelayCommand]
+    private void CriarPerfil()
+    {
+        var jogo = Selecionado;
+
+        if (jogo is null || jogo.TemPerfil)
+            return;
+
+        var executavel = ExecutavelProvavel(jogo);
+
+        if (executavel is null)
+        {
+            Status = $"Não foi possível descobrir o executável de {jogo.Nome}. "
+                   + "Abra o jogo uma vez com a detecção automática ligada: o GameBoost aprende sozinho.";
+            return;
+        }
+
+        var perfil = GameProfile.Padrao(executavel, jogo.Nome, jogo.Caminho, jogo.Launcher);
+        _perfis.Salvar(perfil);
+        jogo.Perfil = perfil;
+
+        Status = $"Perfil criado para {jogo.Nome}. Ele não ativa sozinho: "
+               + "marque \"ativar sozinho\" se quiser que o GameBoost não pergunte.";
+    }
+
+    [RelayCommand]
+    private void RemoverPerfil()
+    {
+        var jogo = Selecionado;
+
+        if (jogo?.Perfil is null)
+            return;
+
+        _perfis.Remover(jogo.Perfil.Executavel);
+        Status = $"Perfil de {jogo.Nome} removido. O jogo continua na biblioteca.";
+        jogo.Perfil = null;
+    }
+
+    /// <summary>Alterna "ativa sozinho" do perfil selecionado.</summary>
+    [RelayCommand]
+    private void AlternarAutomatico()
+    {
+        var perfil = Selecionado?.Perfil;
+
+        if (perfil is null)
+            return;
+
+        perfil.Automatico = !perfil.Automatico;
+        _perfis.Salvar(perfil);
+
+        // Forca a linha a redesenhar com o resumo novo.
+        var jogo = Selecionado!;
+        jogo.Perfil = null;
+        jogo.Perfil = perfil;
+
+        Status = perfil.Automatico
+            ? $"{perfil.Nome} passa a ativar o Modo Game sozinho ao abrir."
+            : $"{perfil.Nome} volta a perguntar antes de ativar.";
+    }
+
+    /// <summary>
+    /// Tenta adivinhar o executável a partir da pasta do jogo.
+    ///
+    /// É palpite, e a tela diz isso: escolhe o maior .exe da raiz da pasta, que
+    /// acerta na maioria dos jogos e erra em quem põe o executável num
+    /// subdiretório `Binaries\Win64`. Quando erra, o caminho certo é abrir o
+    /// jogo com a detecção ligada — aí o executável vem do processo de verdade.
+    /// </summary>
+    private static string? ExecutavelProvavel(JogoViewModel jogo)
+    {
+        if (jogo.Caminho is null || !Directory.Exists(jogo.Caminho))
+            return null;
+
+        try
+        {
+            var candidatos = Directory.EnumerateFiles(jogo.Caminho, "*.exe", SearchOption.TopDirectoryOnly)
+                .Select(f => new FileInfo(f))
+                .Where(f => !EhAuxiliar(f.Name))
+                .OrderByDescending(f => f.Length)
+                .ToList();
+
+            return candidatos.Count == 0 ? null : Path.GetFileNameWithoutExtension(candidatos[0].Name);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    private static bool EhAuxiliar(string nome)
+    {
+        string[] marcadores = { "unins", "setup", "install", "launcher", "crash", "report", "redist", "vcredist", "directx" };
+        return marcadores.Any(m => nome.Contains(m, StringComparison.OrdinalIgnoreCase));
+    }
+
+    /// <summary>
+    /// Acha o perfil do jogo, pela pasta antes do nome.
+    ///
+    /// A primeira versão casava pelo nome da pasta contra a chave do perfil,
+    /// que é o **executável**. "Warframe" nunca casa com "warframe.x64": o jogo
+    /// aparecia como "sem perfil" e o perfil entrava de novo na lista como
+    /// órfão. A mesma linha duas vezes, uma dizendo que tem perfil e a outra
+    /// que não tem.
+    ///
+    /// A pasta de instalação é o que os dois têm em comum e não muda, então é
+    /// por ela que o casamento começa. O nome fica de reserva, para o perfil
+    /// que foi gravado sem caminho.
+    /// </summary>
+    private static GameProfile? CasarPerfil(JogoInstalado jogo, IReadOnlyList<GameProfile> perfis)
+    {
+        if (!string.IsNullOrWhiteSpace(jogo.Pasta))
+        {
+            var pasta = jogo.Pasta.TrimEnd('\\', '/');
+
+            var porCaminho = perfis.FirstOrDefault(p =>
+                !string.IsNullOrWhiteSpace(p.Caminho)
+                && string.Equals(p.Caminho!.TrimEnd('\\', '/'), pasta, StringComparison.OrdinalIgnoreCase));
+
+            if (porCaminho is not null)
+                return porCaminho;
+        }
+
+        return perfis.FirstOrDefault(p =>
+            string.Equals(p.Nome, jogo.Nome, StringComparison.OrdinalIgnoreCase));
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/LimpezaPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/LimpezaPageViewModel.cs
new file mode 100644
index 0000000..90684b8
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/LimpezaPageViewModel.cs
@@ -0,0 +1,49 @@
+using GameBoost.Core.Modules.Cleaner;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Página de Limpeza (seção 5.2).
+///
+/// Toda a tela vem de ModulePageViewModel: cabeçalho com Varrer, lista genérica
+/// de ActionItem, rodapé com "Aplicar N selecionados". Este arquivo só precisa
+/// dizer como a página se chama e o que perguntar antes de apagar — que era
+/// exatamente a promessa do padrão criado junto com o shell.
+/// </summary>
+public sealed class LimpezaPageViewModel : ModulePageViewModel
+{
+    public LimpezaPageViewModel(CleanerModule modulo, IStateBackup backup)
+        : base(modulo, backup)
+    {
+    }
+
+    public override string Nome => "Limpeza";
+    public override string Titulo => "Limpeza de temporários e caches";
+    public override string Subtitulo => "Libera espaço mostrando exatamente o que sai e quanto ocupa.";
+    public override string Icone => "\uE74D";
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var total = selecionados.Sum(i => i.Item.GanhoBytes);
+        var nomes = string.Join("\n  ", selecionados.Take(10).Select(i => i.Titulo));
+        var extra = selecionados.Count > 10 ? $"\n  ... e mais {selecionados.Count - 10}" : string.Empty;
+
+        var texto = $"O GameBoost vai limpar {selecionados.Count} item(ns), "
+                  + $"liberando cerca de {Core.Modules.GameMode.GameModeModule.Formatar(total)}:\n\n"
+                  + $"  {nomes}{extra}\n\n";
+
+        // Avisa de novo, na hora de confirmar, o que tem efeito colateral.
+        var comAviso = selecionados
+            .Select(i => i.Item.Payload as AchadoDeLimpeza)
+            .Where(a => a?.Alvo.Advertencia is not null)
+            .Select(a => $"  - {a!.Alvo.Titulo}: {a.Alvo.Advertencia}")
+            .ToList();
+
+        if (comAviso.Count > 0)
+            texto += "Atenção:\n" + string.Join("\n", comAviso) + "\n\n";
+
+        texto += "Arquivos em uso são mantidos. Continuar?";
+        return texto;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/ModulePageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/ModulePageViewModel.cs
new file mode 100644
index 0000000..bab806a
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/ModulePageViewModel.cs
@@ -0,0 +1,371 @@
+using System.Collections.ObjectModel;
+using System.Windows;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+using GameBoost.Core.Modules;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Padrao de pagina de modulo da secao 6, pronto para reuso: cabecalho com
+/// botao Varrer e resumo, lista generica de ActionItem agrupada por categoria,
+/// rodape fixo com "Aplicar N selecionados" e "Reverter".
+///
+/// Todo modulo das fases seguintes so precisa implementar IModule e herdar
+/// daqui — nenhuma tela nova.
+/// </summary>
+public abstract partial class ModulePageViewModel : PageViewModelBase
+{
+    private readonly IModule _modulo;
+    private readonly IStateBackup _backup;
+    private CancellationTokenSource? _cts;
+
+    protected ModulePageViewModel(IModule modulo, IStateBackup backup)
+    {
+        _modulo = modulo;
+        _backup = backup;
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+
+        Status = EhAdministrador
+            ? "Clique em Varrer para ver o que pode ser feito."
+            : "Modo somente leitura: sem privilegios de administrador as varreduras funcionam, mas nada pode ser alterado.";
+    }
+
+    /// <summary>
+    /// Tudo o que a varredura achou. A lista que a tela mostra e a
+    /// <see cref="Itens"/>, que e esta filtrada pela busca.
+    /// </summary>
+    private readonly List<ActionItemViewModel> _todos = new();
+
+    public ObservableCollection<ActionItemViewModel> Itens { get; } = new();
+
+    /// <summary>
+    /// Texto da busca. Procura no titulo e na descricao, sem acento e sem
+    /// diferenciar maiuscula: quem procura "notepad" tem que achar "Notepad", e
+    /// quem procura "gravacao" tem que achar "Gravação".
+    /// </summary>
+    [ObservableProperty] private string _busca = string.Empty;
+
+    partial void OnBuscaChanged(string value) => AplicarBusca();
+
+    private void AplicarBusca()
+    {
+        Itens.Clear();
+
+        var termo = Normalizar(Busca);
+
+        foreach (var item in _todos)
+        {
+            if (termo.Length == 0
+                || Normalizar(item.Titulo).Contains(termo, StringComparison.Ordinal)
+                || Normalizar(item.Item.Descricao).Contains(termo, StringComparison.Ordinal))
+            {
+                Itens.Add(item);
+            }
+        }
+
+        OnPropertyChanged(nameof(TextoDoFiltro));
+        OnPropertyChanged(nameof(ListaVaziaPorBusca));
+    }
+
+    /// <summary>Tira acento e caixa para a busca casar do jeito que se digita.</summary>
+    private static string Normalizar(string texto)
+    {
+        var decomposto = texto.Normalize(System.Text.NormalizationForm.FormD);
+        var sb = new System.Text.StringBuilder(decomposto.Length);
+
+        foreach (var c in decomposto)
+        {
+            if (System.Globalization.CharUnicodeInfo.GetUnicodeCategory(c)
+                != System.Globalization.UnicodeCategory.NonSpacingMark)
+            {
+                sb.Append(char.ToLowerInvariant(c));
+            }
+        }
+
+        return sb.ToString();
+    }
+
+    public bool ListaVaziaPorBusca => Busca.Length > 0 && Itens.Count == 0;
+
+    public string TextoDoFiltro => Busca.Length == 0
+        ? string.Empty
+        : $"{Itens.Count} de {_todos.Count} itens";
+
+    /// <summary>
+    /// Quantos estao marcados agora, independente da busca.
+    ///
+    /// Conta sobre <see cref="_todos"/>, nao sobre <see cref="Itens"/>: filtrar
+    /// a lista nao pode desmarcar nada nem esconder da contagem o que vai ser
+    /// aplicado.
+    /// </summary>
+    public int SelecionadosNoTotal => _todos.Count(i => i.Selecionado);
+
+    public string TextoDaSelecao => SelecionadosNoTotal == 0
+        ? "Nada marcado."
+        : SelecionadosNoTotal == 1
+            ? "1 item marcado."
+            : $"{SelecionadosNoTotal} itens marcados.";
+
+    [ObservableProperty] private string _status = string.Empty;
+    [ObservableProperty] private string _resumo = string.Empty;
+    [ObservableProperty] private string? _ganhoMedido;
+    [ObservableProperty] private bool _ocupado;
+    [ObservableProperty] private int _progresso;
+    [ObservableProperty] private bool _ehAdministrador;
+    [ObservableProperty] private bool _dryRun;
+    [ObservableProperty] private bool _jaVarreu;
+
+    public bool PodeAgir => !Ocupado && EhAdministrador;
+
+    public int Selecionados => SelecionadosNoTotal;
+
+    public string TextoAplicar => Selecionados == 1
+        ? "Aplicar 1 selecionado"
+        : $"Aplicar {Selecionados} selecionados";
+
+    public bool TemPendencias => _backup.Pendentes.Any(r => r.Modulo == _modulo.Id);
+
+    /// <summary>Texto da confirmacao antes de aplicar. Cada modulo explica o seu.</summary>
+    protected abstract string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados);
+
+    /// <summary>
+    /// Varrer de novo sozinho depois de aplicar ou reverter.
+    ///
+    /// Ligado onde a varredura e barata — ler registro e servico custa
+    /// milissegundos. Desligado onde ela demora: a lista de apps instalados
+    /// leva quase um minuto, e revarrer sozinho deixaria a tela travada logo
+    /// depois de uma acao.
+    ///
+    /// Quando esta desligado, a tela avisa que a lista pode estar
+    /// desatualizada em vez de mostrar um estado antigo como se fosse o atual.
+    /// </summary>
+    protected virtual bool RevarrerAposAgir => false;
+
+    [RelayCommand]
+    public async Task VarrerAsync()
+    {
+        if (Ocupado)
+            return;
+
+        _cts = new CancellationTokenSource();
+        Ocupado = true;
+        Progresso = 0;
+        GanhoMedido = null;
+
+        foreach (var antigo in _todos)
+            antigo.PropertyChanged -= AoMudarSelecao;
+
+        _todos.Clear();
+        Itens.Clear();
+
+        var progresso = new Progress<ModuleProgress>(p =>
+        {
+            Status = p.Etapa;
+            Progresso = p.Percentual;
+        });
+
+        try
+        {
+            var resultado = await _modulo.ScanAsync(progresso, _cts.Token);
+
+            foreach (var item in resultado.Itens)
+            {
+                var vm = new ActionItemViewModel(item);
+                vm.PropertyChanged += AoMudarSelecao;
+                _todos.Add(vm);
+            }
+
+            AplicarBusca();
+
+            Resumo = resultado.Resumo;
+            Status = resultado.Avisos.Count > 0
+                ? string.Join("  ", resultado.Avisos)
+                : "Varredura concluida. Revise a lista antes de confirmar.";
+            JaVarreu = true;
+
+            AposVarrer(resultado);
+        }
+        catch (OperationCanceledException)
+        {
+            Status = "Varredura cancelada.";
+        }
+        finally
+        {
+            Ocupado = false;
+            Progresso = 100;
+            NotificarSelecao();
+        }
+    }
+
+    [RelayCommand]
+    private async Task AplicarAsync()
+    {
+        if (Ocupado || !EhAdministrador)
+            return;
+
+        var selecionados = _todos.Where(i => i.Selecionado && i.PodeSelecionar).ToList();
+
+        if (!DryRun && !Confirmar(selecionados))
+            return;
+
+        _cts = new CancellationTokenSource();
+        Ocupado = true;
+
+        try
+        {
+            var resultado = await _modulo.ApplyAsync(
+                selecionados.Select(i => i.Id).ToList(), DryRun, _cts.Token);
+
+            Resumo = resultado.Resumo;
+            GanhoMedido = resultado.GanhoMedido;
+            Status = resultado.Falhas > 0
+                ? $"{resultado.Sucessos} acoes concluidas, {resultado.Falhas} falharam. Veja o log."
+                : "Pronto.";
+
+            AposAplicar(resultado);
+        }
+        catch (OperationCanceledException)
+        {
+            Status = "Cancelado.";
+        }
+        finally
+        {
+            Ocupado = false;
+            OnPropertyChanged(nameof(TemPendencias));
+        }
+
+        await AtualizarListaAsync(DryRun);
+    }
+
+    [RelayCommand]
+    private async Task ReverterAsync()
+    {
+        if (Ocupado || !EhAdministrador)
+            return;
+
+        var pendentes = _backup.Pendentes.Where(r => r.Modulo == _modulo.Id).ToList();
+
+        if (pendentes.Count == 0)
+        {
+            Status = "Nada a reverter nesta pagina.";
+            return;
+        }
+
+        var resposta = MessageBox.Show(
+            $"Desfazer {pendentes.Count} alteracao(oes) de sistema feitas por {Titulo}?",
+            "Reverter", MessageBoxButton.YesNo, MessageBoxImage.Question);
+
+        if (resposta != MessageBoxResult.Yes)
+            return;
+
+        Ocupado = true;
+
+        try
+        {
+            var resultado = await _modulo.RevertAsync(
+                pendentes.Select(r => r.Id).ToList(), DryRun, CancellationToken.None);
+
+            Resumo = resultado.Resumo;
+            GanhoMedido = resultado.GanhoMedido;
+            Status = resultado.Falhas > 0
+                ? $"{resultado.Sucessos} revertidas, {resultado.Falhas} falharam."
+                : "Sistema devolvido ao estado anterior.";
+
+            AposReverter(resultado);
+        }
+        finally
+        {
+            Ocupado = false;
+            OnPropertyChanged(nameof(TemPendencias));
+        }
+
+        await AtualizarListaAsync(DryRun);
+    }
+
+    [RelayCommand]
+    private void Cancelar() => _cts?.Cancel();
+
+    [RelayCommand]
+    private void MarcarTodos()
+    {
+        foreach (var item in _todos.Where(i => i.PodeSelecionar))
+            item.Selecionado = true;
+    }
+
+    [RelayCommand]
+    private void DesmarcarTodos()
+    {
+        foreach (var item in _todos)
+            item.Selecionado = false;
+    }
+
+    protected virtual bool Confirmar(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var resposta = MessageBox.Show(
+            MontarConfirmacao(selecionados),
+            $"Confirmar - {Titulo}", MessageBoxButton.YesNo, MessageBoxImage.Warning);
+
+        return resposta == MessageBoxResult.Yes;
+    }
+
+    /// <summary>
+    /// Gancho para a pagina que tem conteudo proprio alem da lista. A pagina de
+    /// Rede usa isto para preencher as tabelas de latencia e DNS, que nao cabem
+    /// no formato de ActionItem.
+    /// </summary>
+    protected virtual void AposVarrer(ScanResult resultado)
+    {
+    }
+
+    protected virtual void AposAplicar(ApplyResult resultado)
+    {
+    }
+
+    protected virtual void AposReverter(ApplyResult resultado)
+    {
+    }
+
+    private void AoMudarSelecao(object? remetente, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(ActionItemViewModel.Selecionado))
+            NotificarSelecao();
+    }
+
+    /// <summary>
+    /// Depois de agir, a lista mostra o estado de ANTES ate alguem varrer de
+    /// novo. Isso fez o badge de um servico continuar dizendo "automatico"
+    /// depois de ele ja ter virado "manual": a tela parecia nao ter feito nada.
+    /// </summary>
+    private async Task AtualizarListaAsync(bool foiDryRun)
+    {
+        if (foiDryRun || !JaVarreu)
+            return;
+
+        if (RevarrerAposAgir)
+        {
+            var buscaAnterior = Busca;
+            await VarrerAsync();
+            Busca = buscaAnterior;
+            return;
+        }
+
+        Status = Status.Length == 0
+            ? "A lista ainda mostra o estado de antes. Varra de novo para ver como ficou."
+            : Status + "  A lista ainda mostra o estado de antes; varra de novo para ver como ficou.";
+    }
+
+    protected void NotificarSelecao()
+    {
+        OnPropertyChanged(nameof(Selecionados));
+        OnPropertyChanged(nameof(SelecionadosNoTotal));
+        OnPropertyChanged(nameof(TextoAplicar));
+        OnPropertyChanged(nameof(TextoDaSelecao));
+    }
+
+    partial void OnOcupadoChanged(bool value) => OnPropertyChanged(nameof(PodeAgir));
+
+    partial void OnEhAdministradorChanged(bool value) => OnPropertyChanged(nameof(PodeAgir));
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/OnboardingViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/OnboardingViewModel.cs
new file mode 100644
index 0000000..a21ed54
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/OnboardingViewModel.cs
@@ -0,0 +1,102 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Uma das três telas do onboarding.</summary>
+public sealed record TelaDeOnboarding(string Titulo, string Texto, string Rodape);
+
+/// <summary>
+/// Onboarding da primeira abertura (seção 6).
+///
+/// Três telas, e o conteúdo delas não é propaganda: é o contrato. O usuário
+/// precisa saber, antes de clicar em qualquer coisa, que tudo volta atrás, que
+/// nada é enviado para lugar nenhum, e que a maior parte do que os boosters
+/// prometem não existe. Um onboarding que vendesse FPS seria a primeira mentira
+/// do aplicativo.
+/// </summary>
+public sealed partial class OnboardingViewModel : ObservableObject
+{
+    public static IReadOnlyList<TelaDeOnboarding> Telas { get; } = new[]
+    {
+        new TelaDeOnboarding(
+            "Tudo o que ele faz, ele desfaz",
+            "Antes de alterar qualquer coisa no Windows, o GameBoost grava o valor anterior. "
+          + "Cada ação tem um botão de desfazer, e Configurações → Histórico mostra tudo o que "
+          + "já foi feito, com a data.\n\n"
+          + "Se o aplicativo travar ou o computador reiniciar no meio de uma sessão, a próxima "
+          + "abertura avisa e oferece a restauração.\n\n"
+          + "Nada é aplicado sem você confirmar, e nada vem marcado — nem o que o próprio "
+          + "GameBoost recomenda.",
+            "Reversível por construção, não por promessa."),
+
+        new TelaDeOnboarding(
+            "Nada sai daqui",
+            "O GameBoost não tem telemetria. Não há conta, não há login, não há servidor "
+          + "recebendo dados sobre você ou sobre esta máquina.\n\n"
+          + "Tudo o que ele lê fica em %LOCALAPPDATA%\\GameBoost, em arquivos de texto que você "
+          + "pode abrir e ler.\n\n"
+          + "As únicas funções que usam a internet são o teste de velocidade e a checagem de "
+          + "atualizações de aplicativos. A primeira vem desligada e só liga se você mandar.",
+            "Sem conta, sem nuvem, sem telemetria."),
+
+        new TelaDeOnboarding(
+            "O que faz diferença de verdade",
+            "A maior parte do que os \"otimizadores\" prometem não existe. Limpar registro não "
+          + "acelera nada. Desfragmentar SSD só desgasta a unidade. Fechar processo do Windows "
+          + "à toa quebra mais do que ajuda.\n\n"
+          + "O que rende de verdade, nesta ordem: podar o que abre com o Windows, liberar espaço "
+          + "em disco quando ele está cheio, manter o driver de vídeo atual, e usar cabo em vez "
+          + "de Wi-Fi para jogo online.\n\n"
+          + "Cada ajuste desta ferramenta diz o efeito real que tem. Quando é marginal, está "
+          + "escrito que é marginal.",
+            "Números medidos, não estimados.")
+    };
+
+    [ObservableProperty] private int _indice;
+
+    public TelaDeOnboarding Atual => Telas[Indice];
+
+    public bool EhPrimeira => Indice == 0;
+    public bool EhUltima => Indice == Telas.Count - 1;
+
+    public string TextoDoAvancar => EhUltima ? "Começar" : "Próxima";
+    public string Passo => $"{Indice + 1} de {Telas.Count}";
+
+    /// <summary>Marcado na última tela: abre o relatório de saúde ao terminar.</summary>
+    [ObservableProperty] private bool _abrirRelatorio = true;
+
+    /// <summary>Fechado, com ou sem "começar".</summary>
+    public event Action<bool>? AoTerminar;
+
+    [RelayCommand]
+    private void Avancar()
+    {
+        if (EhUltima)
+        {
+            AoTerminar?.Invoke(AbrirRelatorio);
+            return;
+        }
+
+        Indice++;
+    }
+
+    [RelayCommand]
+    private void Voltar()
+    {
+        if (!EhPrimeira)
+            Indice--;
+    }
+
+    [RelayCommand]
+    private void Pular() => AoTerminar?.Invoke(false);
+
+    partial void OnIndiceChanged(int value)
+    {
+        OnPropertyChanged(nameof(Atual));
+        OnPropertyChanged(nameof(EhPrimeira));
+        OnPropertyChanged(nameof(EhUltima));
+        OnPropertyChanged(nameof(TextoDoAvancar));
+        OnPropertyChanged(nameof(Passo));
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/PageViewModelBase.cs b/GameBoost/src/GameBoost.App/ViewModels/PageViewModelBase.cs
new file mode 100644
index 0000000..38b114f
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/PageViewModelBase.cs
@@ -0,0 +1,39 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Base de toda pagina do menu lateral (secao 6 do spec). O shell so conhece
+/// este contrato: titulo, icone e se a pagina ja existe de verdade.
+/// </summary>
+public abstract partial class PageViewModelBase : ObservableObject
+{
+    /// <summary>Nome curto, como aparece no menu lateral.</summary>
+    public abstract string Nome { get; }
+
+    /// <summary>Titulo da pagina, no cabecalho.</summary>
+    public abstract string Titulo { get; }
+
+    /// <summary>Uma linha explicando o que a pagina faz.</summary>
+    public abstract string Subtitulo { get; }
+
+    /// <summary>Glifo da fonte Segoe Fluent Icons / Segoe MDL2 Assets.</summary>
+    public abstract string Icone { get; }
+
+    /// <summary>Falso enquanto o modulo nao existe: a pagina mostra o aviso de fase.</summary>
+    public virtual bool Implementada => true;
+
+    /// <summary>Chamado toda vez que a pagina entra em foco no shell.</summary>
+    public virtual void AoEntrar()
+    {
+    }
+
+    /// <summary>
+    /// Chamado ao sair da pagina. Existe para quem liga trabalho continuo
+    /// poder desligar: o monitoramento do Diagnostico nao deve seguir rodando
+    /// enquanto o usuario le a tela de Limpeza.
+    /// </summary>
+    public virtual void AoSair()
+    {
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/PlaceholderPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/PlaceholderPageViewModel.cs
new file mode 100644
index 0000000..8b97d90
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/PlaceholderPageViewModel.cs
@@ -0,0 +1,39 @@
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Pagina de modulo que ainda nao existe. Mostra o que vai fazer e em qual fase
+/// chega, em vez de sumir do menu: o usuario ve o mapa inteiro do produto.
+/// </summary>
+public sealed class PlaceholderPageViewModel : PageViewModelBase
+{
+    public PlaceholderPageViewModel(
+        string nome,
+        string titulo,
+        string subtitulo,
+        string icone,
+        int fase,
+        string secaoDoSpec,
+        IReadOnlyList<string> oQueVaiFazer)
+    {
+        Nome = nome;
+        Titulo = titulo;
+        Subtitulo = subtitulo;
+        Icone = icone;
+        Fase = fase;
+        SecaoDoSpec = secaoDoSpec;
+        OQueVaiFazer = oQueVaiFazer;
+    }
+
+    public override string Nome { get; }
+    public override string Titulo { get; }
+    public override string Subtitulo { get; }
+    public override string Icone { get; }
+    public override bool Implementada => false;
+
+    public int Fase { get; }
+    public string SecaoDoSpec { get; }
+    public IReadOnlyList<string> OQueVaiFazer { get; }
+
+    public string AvisoDeFase => $"Disponivel na Fase {Fase}";
+    public string Referencia => $"Especificado na secao {SecaoDoSpec} do GAMEBOOST_V2_SPEC.md";
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/RedePageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/RedePageViewModel.cs
new file mode 100644
index 0000000..4127be1
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/RedePageViewModel.cs
@@ -0,0 +1,241 @@
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Network;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>Uma linha da tabela de latência.</summary>
+public sealed record LinhaDePing(string Alvo, string Latencia, string Jitter, string Perda, string Leitura);
+
+/// <summary>Uma linha da tabela de DNS.</summary>
+public sealed record LinhaDeDns(string Nome, string Endereco, string Tempo, bool EmUso, string Comparacao);
+
+/// <summary>Uma linha de quem está conectado agora.</summary>
+public sealed record LinhaDeConexao(string Processo, string Conexoes, string Destino);
+
+/// <summary>
+/// Página de rede (seção 5.9).
+///
+/// Diferente das outras páginas de módulo, esta tem conteúdo acima da lista: as
+/// medições. A lista de ações sozinha não resolveria — "trocar de DNS" só faz
+/// sentido depois de ver a tabela que mostra quanto cada um demora.
+/// </summary>
+public sealed partial class RedePageViewModel : ModulePageViewModel
+{
+    private readonly NetworkModule _modulo;
+
+    public RedePageViewModel(NetworkModule modulo, IStateBackup backup)
+        : base(modulo, backup)
+    {
+        _modulo = modulo;
+    }
+
+    public override string Nome => "Rede";
+    public override string Titulo => "Rede";
+    public override string Subtitulo => "Latência, jitter, perda e DNS medidos agora, na sua conexão.";
+    public override string Icone => "\uE839";
+
+    public ObservableCollection<LinhaDePing> Pings { get; } = new();
+    public ObservableCollection<LinhaDeDns> Dns { get; } = new();
+    public ObservableCollection<LinhaDeConexao> Conexoes { get; } = new();
+
+    [ObservableProperty] private string? _wifi;
+    [ObservableProperty] private bool _temMedicao;
+
+    // ---- Bloco "Posso jogar online?" ----
+    [ObservableProperty] private string _nat = string.Empty;
+    [ObservableProperty] private string _natExplicacao = string.Empty;
+    [ObservableProperty] private string _natSemaforo = "cinza";
+    [ObservableProperty] private bool _temNat;
+    public ObservableCollection<string> Causas { get; } = new();
+
+    // ---- Bloco "Velocidade" ----
+    [ObservableProperty] private string _velocidade = string.Empty;
+    [ObservableProperty] private bool _medindoVelocidade;
+    [ObservableProperty] private bool _velocidadePermitida;
+
+    public string TextoDoBotaoDeVelocidade => VelocidadePermitida
+        ? "Testar velocidade"
+        : "Testar velocidade (precisa de permissão)";
+
+    /// <summary>
+    /// O teste de velocidade é um botão à parte, e não parte de Medir, porque
+    /// ele transfere quase 100 MB. Quem está com franquia contada não pode ter
+    /// isso acontecendo sem pedir.
+    /// </summary>
+    [RelayCommand]
+    public async Task TestarVelocidadeAsync()
+    {
+        if (MedindoVelocidade)
+            return;
+
+        MedindoVelocidade = true;
+        Velocidade = "Medindo...";
+
+        try
+        {
+            var progresso = new Progress<string>(texto => Velocidade = texto);
+            var resultado = await _modulo.MedirVelocidadeAsync(progresso, CancellationToken.None);
+
+            Velocidade = resultado.Funcionou
+                ? $"Download {resultado.DownloadMbps} Mbps · upload {resultado.UploadMbps} Mbps "
+                + $"· {resultado.BytesBaixados / 1024 / 1024} MB em {resultado.Duracao.TotalSeconds:0} s"
+                : resultado.Erro ?? "Não foi possível medir.";
+        }
+        catch (OperationCanceledException)
+        {
+            Velocidade = "Teste cancelado.";
+        }
+        finally
+        {
+            MedindoVelocidade = false;
+            VelocidadePermitida = _modulo.VelocidadePermitida;
+        }
+    }
+
+    public override void AoEntrar()
+    {
+        base.AoEntrar();
+        VelocidadePermitida = _modulo.VelocidadePermitida;
+
+        if (Velocidade.Length == 0)
+        {
+            Velocidade = VelocidadePermitida
+                ? "Não medido ainda. O teste baixa e envia cerca de 100 MB."
+                : "O teste de velocidade usa a internet e está desligado por padrão. "
+                + "Ligue em Configurações, se quiser.";
+        }
+    }
+
+    protected override void AposVarrer(ScanResult resultado)
+    {
+        Pings.Clear();
+        Dns.Clear();
+        Conexoes.Clear();
+
+        foreach (var p in _modulo.UltimoPing)
+        {
+            Pings.Add(new LinhaDePing(
+                $"{p.Rotulo} ({p.Alvo})",
+                p.Respondeu ? $"{p.MediaMs} ms" : "sem resposta",
+                p.Respondeu ? $"{p.JitterMs} ms" : "—",
+                p.Respondeu ? $"{p.PerdaPercentual}%" : "—",
+                p.Leitura));
+        }
+
+        var atual = _modulo.UltimoDns.FirstOrDefault(d => d.EmUso && d.Respondeu);
+
+        foreach (var d in _modulo.UltimoDns)
+        {
+            var comparacao = !d.Respondeu
+                ? "não respondeu"
+                : d.EmUso || atual is null
+                    ? string.Empty
+                    : d.MediaMs < atual.MediaMs
+                        ? $"{Math.Round(atual.MediaMs - d.MediaMs, 1)} ms mais rápido"
+                        : $"{Math.Round(d.MediaMs - atual.MediaMs, 1)} ms mais lento";
+
+            Dns.Add(new LinhaDeDns(
+                d.Nome, d.Endereco,
+                d.Respondeu ? $"{d.MediaMs} ms" : "—",
+                d.EmUso, comparacao));
+        }
+
+        foreach (var c in _modulo.UltimosConsumidores)
+            Conexoes.Add(new LinhaDeConexao(c.Nome, c.Conexoes.ToString(), c.PrincipalDestino));
+
+        var w = _modulo.UltimoWifi;
+
+        Wifi = w is null
+            ? NetworkDiagnostics.ConectadoPorCabo()
+                ? "Conectado por cabo. Para jogo competitivo é o melhor que existe."
+                : null
+            : $"Wi-Fi: {w.Ssid} · {w.Padrao} · {w.Banda} · sinal {w.SinalPercentual}%";
+
+        TemMedicao = Pings.Count > 0;
+
+        var n = _modulo.UltimoNat;
+        Causas.Clear();
+
+        if (n is null)
+        {
+            TemNat = false;
+        }
+        else
+        {
+            TemNat = true;
+            Nat = n.NomeCurto;
+            NatExplicacao = n.Explicacao;
+            NatSemaforo = n.Semaforo;
+
+            // As causas só aparecem quando **são** causa. Listar "UPnP: ligado"
+            // num NAT aberto seria encher a tela de verde inútil e esconder a
+            // linha que importa quando houver uma.
+            if (n.Tipo == TipoDeNat.Cgnat)
+                Causas.Add("CGNAT da operadora: o NAT que atrapalha não está na sua casa.");
+
+            if (n.SaltosPrivados >= 2)
+                Causas.Add($"{n.SaltosPrivados} saltos privados antes da internet: há dois roteadores em série.");
+
+            if (!n.UpnpDisponivel && n.Tipo is TipoDeNat.Estrito or TipoDeNat.Moderado)
+                Causas.Add("O roteador não respondeu por UPnP: os jogos não conseguem abrir porta sozinhos.");
+
+            if (n.Teredo == EstadoTeredo.Desativado)
+                Causas.Add("Teredo desativado: multiplayer de Xbox e Game Pass no PC não conecta.");
+
+            if (n.PerfisDeFirewallAtivos.Count == 0)
+                Causas.Add("Nenhum perfil do firewall do Windows está ligado. Isso não é otimização, é risco.");
+
+            foreach (var ruim in _modulo.UltimoPing.Where(p => p.EhProblema))
+            {
+                Causas.Add($"{ruim.Rotulo}: jitter de {ruim.JitterMs} ms e {ruim.PerdaPercentual}% de perda. "
+                         + "Acima de 15 ms de jitter ou 1% de perda o jogo engasga.");
+            }
+
+            if (Causas.Count == 0 && n.Tipo is TipoDeNat.Aberto or TipoDeNat.SemNat)
+                Causas.Add("Nenhum problema de conectividade encontrado. Dá para hospedar partida e entrar em festa.");
+        }
+
+        // A classe base joga todos os avisos na barra de status. Aqui isso
+        // duplicaria a explicação do NAT, que já tem bloco próprio no topo, e o
+        // texto ainda sairia cortado no meio da frase por falta de espaço.
+        Status = resultado.Itens.Count == 0
+            ? "Medição concluída. Nada a ajustar."
+            : $"Medição concluída. {resultado.Itens.Count} ajuste(s) disponíveis abaixo.";
+    }
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var nomes = string.Join("\n  ", selecionados.Select(i => i.Titulo));
+        var winsock = selecionados.Any(i => i.Item.Id == "rede:winsock");
+        var dns = selecionados.Count(i => i.Item.Id.StartsWith("dns:", StringComparison.Ordinal));
+
+        var texto = $"Aplicar {selecionados.Count} ação(ões) de rede?\n\n  {nomes}\n\n";
+
+        if (dns > 1)
+        {
+            texto += "Você marcou mais de um servidor de DNS. Só um pode ser o primário: "
+                   + "o último da lista é o que vai valer.\n\n";
+        }
+
+        if (dns > 0)
+        {
+            texto += "Trocar o DNS não muda o ping do jogo. O jogo resolve o nome do servidor "
+                   + "uma vez e depois fala direto com ele por IP. O que melhora é o tempo de "
+                   + "abrir páginas e de o launcher encontrar os servidores.\n\n";
+        }
+
+        if (winsock)
+        {
+            texto += "ATENÇÃO: resetar o Winsock derruba a rede até você reiniciar o "
+                   + "computador, apaga configurações de VPN e proxy, e não tem desfazer "
+                   + "automático. Só faz sentido se a máquina já está sem internet.\n\n";
+        }
+
+        texto += "Continuar?";
+        return texto;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/ShellViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/ShellViewModel.cs
new file mode 100644
index 0000000..fed2e85
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/ShellViewModel.cs
@@ -0,0 +1,284 @@
+using System.Collections.ObjectModel;
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GameBoost.Core;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Shell da secao 6: navegacao lateral com as 11 entradas, uma pagina por vez.
+///
+/// As paginas dos modulos que ainda nao existem sao placeholders explicando o
+/// que farao e em qual fase chegam. Elas ficam no menu de proposito: o usuario
+/// ve o mapa inteiro do produto desde a primeira versao.
+/// </summary>
+public sealed partial class ShellViewModel : ObservableObject
+{
+    public ShellViewModel(
+        InicioPageViewModel inicio,
+        DiagnosticoPageViewModel diagnostico,
+        LimpezaPageViewModel limpeza,
+        EspacoPageViewModel espaco,
+        AppsPageViewModel apps,
+        InicializacaoPageViewModel inicializacao,
+        JogosPageViewModel jogos,
+        Core.Modules.Profiles.ProfileRunner executorDePerfil,
+        Core.Modules.Profiles.ProfileStore perfis,
+        Core.Modules.Profiles.GameWatcher vigia,
+        TweaksPageViewModel tweaks,
+        RedePageViewModel rede,
+        FerramentasPageViewModel ferramentas,
+        ConfiguracoesPageViewModel configuracoes)
+    {
+        Paginas = new ObservableCollection<PageViewModelBase>
+        {
+            inicio,
+
+            diagnostico,
+
+            limpeza,
+
+            espaco,
+
+            apps,
+
+            inicializacao,
+
+            jogos,
+
+            tweaks,
+
+            rede,
+
+            ferramentas,
+
+            configuracoes
+        };
+
+        _inicio = inicio;
+        _jogos = jogos;
+        _executorDePerfil = executorDePerfil;
+        _perfis = perfis;
+        _vigia = vigia;
+        _paginaAtual = Paginas[0];
+        EhAdministrador = CoreServices.RodandoComoAdministrador();
+    }
+
+    private readonly InicioPageViewModel _inicio;
+    private readonly JogosPageViewModel _jogos;
+    private readonly Core.Modules.Profiles.ProfileRunner _executorDePerfil;
+    private readonly Core.Modules.Profiles.ProfileStore _perfis;
+    private readonly Core.Modules.Profiles.GameWatcher _vigia;
+
+    public ObservableCollection<PageViewModelBase> Paginas { get; }
+
+    [ObservableProperty] private PageViewModelBase _paginaAtual;
+    [ObservableProperty] private bool _ehAdministrador;
+
+    public string AvisoDePrivilegio => EhAdministrador
+        ? "Executando como administrador."
+        : "Modo somente leitura: sem privilegios de administrador.";
+
+    [RelayCommand]
+    private void Navegar(PageViewModelBase? pagina)
+    {
+        if (pagina is not null)
+            PaginaAtual = pagina;
+    }
+
+    /// <summary>
+    /// AoEntrar tem que ficar aqui, e nao no comando Navegar: o menu lateral
+    /// troca de pagina pelo binding de SelectedItem, que nunca passa pelo
+    /// comando. Com o gancho no comando, o Diagnostico nao comecava a coletar
+    /// e o Historico nao recarregava ao abrir a pagina.
+    /// </summary>
+    partial void OnPaginaAtualChanged(PageViewModelBase? oldValue, PageViewModelBase newValue)
+    {
+        oldValue?.AoSair();
+        newValue?.AoEntrar();
+    }
+
+    // ==================================================================
+    // Bandeja (secao 6)
+    // ==================================================================
+
+    /// <summary>
+    /// Menu da bandeja: liga ou desliga o Modo Game.
+    ///
+    /// Ligar leva para a tela de Inicio antes de agir. A confirmacao do Modo
+    /// Game lista o que vai ser fechado, e essa lista **precisa** ser vista:
+    /// ativar direto da bandeja, sem a tela, seria fechar programas do usuario
+    /// a partir de um menu de dois cliques.
+    /// </summary>
+    public void AlternarModoGamePelaBandeja()
+    {
+        PaginaAtual = _inicio;
+
+        if (_inicio.ModoGameAtivo)
+        {
+            _inicio.ReverterCommand.Execute(null);
+            return;
+        }
+
+        // Sem varredura previa nao ha o que confirmar.
+        if (_inicio.Itens.Count == 0)
+            _inicio.VarrerCommand.Execute(null);
+    }
+
+    /// <summary>Menu da bandeja: libera memoria, sem tocar em mais nada.</summary>
+    public void LimparRamPelaBandeja()
+    {
+        PaginaAtual = _inicio;
+        _inicio.LimparRamCommand.Execute(null);
+    }
+
+    public void AbrirRelatorioInicial()
+    {
+        PaginaAtual = _inicio;
+        _inicio.AnalisarSaudeCommand.Execute(null);
+    }
+
+    // ==================================================================
+    // Deteccao automatica de jogo (secao 5.1)
+    // ==================================================================
+
+    [ObservableProperty] private string? _convite;
+
+    public event Action<string, string>? AoPedirAviso;
+
+    /// <summary>
+    /// O vigia achou um jogo. Perfil com "ativa sozinho" aplica direto; todo o
+    /// resto **pergunta** (regra 3).
+    /// </summary>
+    public void JogoDetectado(Core.Modules.Profiles.JogoAbriu evento)
+    {
+        JogoDetectadoAgora = evento;
+
+        var nome = evento.Perfil?.Nome ?? evento.Jogo.Process.Name;
+
+        if (evento.Perfil is { Automatico: true })
+        {
+            Convite = null;
+            AoPedirAviso?.Invoke("GameBoost",
+                $"{nome} detectado. O perfil dele ativa sozinho, e tudo volta ao normal quando o jogo fechar.");
+            return;
+        }
+
+        Convite = evento.Perfil is null
+            ? $"{nome} está rodando. Ativar o Modo Game para ele?"
+            : $"{nome} está rodando. Aplicar o perfil deste jogo?";
+
+        AoPedirAviso?.Invoke("GameBoost", Convite);
+    }
+
+    /// <summary>Guarda o evento inteiro; Convite e so o texto da faixa.</summary>
+    public Core.Modules.Profiles.JogoAbriu? JogoDetectadoAgora { get; private set; }
+
+    /// <summary>
+    /// O jogo saiu: desfazer o que o perfil aplicou.
+    ///
+    /// A primeira versão só limpava o convite e anunciava que "tudo foi
+    /// desfeito" — sem desfazer nada. Prioridade, afinidade e tweaks ficariam
+    /// de pé até alguém reverter à mão, e o aviso na tela estaria mentindo.
+    /// </summary>
+    public void JogoEncerrado(Core.Modules.Profiles.JogoFechou evento)
+    {
+        Convite = null;
+        JogoDetectadoAgora = null;
+
+        // Saber ANTES se havia sessao: depois do Desfazer nao da mais para
+        // distinguir "nao havia perfil" de "havia, mas nada sobrou para
+        // restaurar".
+        var haviaPerfil = _executorDePerfil.EmSessao;
+        var feitos = _executorDePerfil.Desfazer();
+
+        var texto = $"{evento.Nome} fechou depois de {evento.Duracao.TotalMinutes:0} minutos.";
+
+        // Só afirmar que desfez quando desfez mesmo, e nunca negar que havia
+        // perfil quando havia.
+        if (feitos.Count > 0)
+        {
+            texto += $" Desfeito: {string.Join(", ", feitos)}.";
+        }
+        else if (haviaPerfil)
+        {
+            // Prioridade e afinidade morrem junto com o processo: quando o jogo
+            // fecha primeiro, nao sobra o que restaurar. Isso e o esperado, nao
+            // uma falha.
+            texto += " O perfil saiu junto com o jogo: prioridade e afinidade "
+                   + "valem enquanto o processo existe.";
+        }
+        else
+        {
+            texto += " Não havia perfil aplicado.";
+        }
+
+        AoPedirAviso?.Invoke("GameBoost", texto);
+    }
+
+    /// <summary>
+    /// Aceitar o convite aplica o perfil do jogo e leva para o Modo Game.
+    ///
+    /// A primeira versão só navegava para a tela Início. O perfil nunca era
+    /// aplicado: prioridade, afinidade e tweaks ficavam parados no arquivo, e o
+    /// `ProfileRunner` não era chamado por ninguém.
+    /// </summary>
+    [RelayCommand]
+    private void AceitarConvite()
+    {
+        var evento = JogoDetectadoAgora;
+        Convite = null;
+
+        if (evento is null)
+        {
+            AlternarModoGamePelaBandeja();
+            return;
+        }
+
+        AplicarPerfil(evento);
+        AlternarModoGamePelaBandeja();
+    }
+
+    /// <summary>
+    /// Aplica o perfil do jogo, criando um padrão quando ainda não existe.
+    ///
+    /// Criar aqui é o que faz a segunda vez ser diferente da primeira: o perfil
+    /// nasce com o executável certo, vindo do processo de verdade, e não de um
+    /// palpite sobre qual `.exe` da pasta é o jogo.
+    /// </summary>
+    private void AplicarPerfil(Core.Modules.Profiles.JogoAbriu evento)
+    {
+        var perfil = evento.Perfil;
+
+        if (perfil is null)
+        {
+            perfil = Core.Modules.Profiles.GameProfile.Padrao(
+                evento.Jogo.Process.Name,
+                evento.Jogo.Process.Name,
+                Path.GetDirectoryName(evento.Jogo.Process.ExecutablePath),
+                null);
+        }
+
+        try
+        {
+            _executorDePerfil.Aplicar(perfil, evento.Jogo.Process.Pid);
+            _perfis.Salvar(perfil);
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+        {
+            AoPedirAviso?.Invoke("GameBoost", $"Não foi possível aplicar o perfil: {ex.Message}");
+        }
+    }
+
+    [RelayCommand]
+    private void RecusarConvite()
+    {
+        // Recusar tem que valer para a sessão: sem isto a pergunta voltaria
+        // dois segundos depois, e de novo, e de novo.
+        if (JogoDetectadoAgora is not null)
+            _vigia.Recusar(JogoDetectadoAgora.Jogo.Process.Name);
+
+        Convite = null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/ViewModels/TweaksPageViewModel.cs b/GameBoost/src/GameBoost.App/ViewModels/TweaksPageViewModel.cs
new file mode 100644
index 0000000..ce5f105
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/ViewModels/TweaksPageViewModel.cs
@@ -0,0 +1,78 @@
+using GameBoost.Core.Modules.Tweaks;
+using GameBoost.Core.State;
+
+namespace GameBoost.App.ViewModels;
+
+/// <summary>
+/// Página de tweaks e serviços (seções 5.8 e 5.7).
+///
+/// A confirmação desta tela é a mais séria do app depois da do desinstalador:
+/// aqui o usuário está alterando o Windows, não apagando arquivo. Por isso ela
+/// separa o que precisa de reinício, o que é de risco médio ou alto, e diz
+/// exatamente onde o estado anterior ficou guardado.
+/// </summary>
+public sealed class TweaksPageViewModel : ModulePageViewModel
+{
+    public TweaksPageViewModel(TweaksModule modulo, IStateBackup backup)
+        : base(modulo, backup)
+    {
+    }
+
+    public override string Nome => "Tweaks";
+    public override string Titulo => "Ajustes do Windows";
+    public override string Subtitulo => "Cada ajuste com o efeito real, não com a promessa. Nada vem marcado.";
+    public override string Icone => "\uE90F";
+
+    /// <summary>
+    /// Ler o estado de 24 ajustes custa milissegundos: registro e consulta de
+    /// servico. Vale revarrer sozinho para o badge de cada linha mostrar como
+    /// as coisas ficaram, e nao como estavam.
+    /// </summary>
+    protected override bool RevarrerAposAgir => true;
+
+    protected override string MontarConfirmacao(IReadOnlyList<ActionItemViewModel> selecionados)
+    {
+        var nomes = string.Join("\n  ", selecionados.Select(i => i.Titulo));
+
+        var reboot = selecionados
+            .Select(i => i.Item.Payload)
+            .OfType<TweaksModule.TweakEstado>()
+            .Where(e => e.Definicao.ExigeReboot)
+            .Select(e => e.Definicao.Nome)
+            .ToList();
+
+        var servicos = selecionados.Count(i => i.Item.Id.StartsWith("servico:", StringComparison.Ordinal));
+
+        var texto = $"Aplicar {selecionados.Count} ajuste(s)?\n\n  {nomes}\n\n";
+
+        if (servicos > 0)
+        {
+            texto += $"{servicos} deles mudam o tipo de inicialização de um serviço do Windows. "
+                   + "O estado atual de cada um fica guardado e volta pelo botão Reverter.\n\n";
+        }
+
+        if (reboot.Count > 0)
+        {
+            texto += $"{reboot.Count} só passa(m) a valer depois de reiniciar o computador:\n  "
+                   + string.Join("\n  ", reboot)
+                   + "\n\nAté lá, nada muda na prática.\n\n";
+        }
+
+        var arriscados = selecionados
+            .Where(i => i.Item.Risco != Core.Modules.RiskLevel.Baixo)
+            .ToList();
+
+        if (arriscados.Count > 0)
+        {
+            texto += "Ajustes de risco médio ou alto nesta seleção:\n  "
+                   + string.Join("\n  ", arriscados.Select(i => $"{i.Titulo} — {i.Item.ComoDesfazer}"))
+                   + "\n\n";
+        }
+
+        texto += "Tudo isto é reversível: o valor anterior de cada chave vai para o histórico "
+               + "antes de qualquer escrita, e Configurações → Histórico desfaz um por um.\n\n"
+               + "Continuar?";
+
+        return texto;
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/AppsPage.xaml b/GameBoost/src/GameBoost.App/Views/AppsPage.xaml
new file mode 100644
index 0000000..dd28318
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/AppsPage.xaml
@@ -0,0 +1,304 @@
+<UserControl x:Class="GameBoost.App.Views.AppsPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!--
+      Pagina de aplicativos (secao 5.3), em tres abas. Cada aba tem a sua
+      lista e o seu proprio botao de acao: aplicar na aba de atualizacoes
+      nao desinstala nada, e vice-versa. Misturar as tres num rodape so
+      seria o jeito mais rapido de alguem desinstalar querendo atualizar.
+    -->
+    <Grid Margin="26,22,26,0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Grid.Row="0" Margin="0,0,0,14">
+            <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+            <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}"
+                       Margin="0,3,0,0" TextWrapping="Wrap" />
+        </StackPanel>
+
+        <TabControl Grid.Row="1" Background="Transparent" BorderThickness="0" Margin="0,0,0,18">
+
+            <!-- ==================== Instalados ==================== -->
+            <TabItem Header="Instalados">
+                <Grid Margin="0,14,0,0">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+
+                    <Grid Grid.Row="0" Margin="0,0,0,12">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+
+                        <Border Grid.Column="0" Background="{StaticResource Superficie}" CornerRadius="6"
+                                Padding="14,10" Margin="0,0,10,0"
+                                Visibility="{Binding Resumo, Converter={StaticResource TextoParaVisibilidade}}">
+                            <TextBlock Text="{Binding Resumo}" FontWeight="SemiBold" TextWrapping="Wrap" />
+                        </Border>
+
+                        <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Top">
+                            <Button Content="Varrer" Style="{StaticResource BotaoBase}"
+                                    AutomationProperties.Name="Varrer aplicativos instalados"
+                                    Command="{Binding VarrerCommand}"
+                                    IsEnabled="{Binding Ocupado, Converter={StaticResource InverterBool}}" />
+                            <Button Content="Cancelar" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                                    Command="{Binding CancelarCommand}"
+                                    Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+                        </StackPanel>
+                    </Grid>
+
+
+                    <Grid Grid.Row="1" Margin="0,0,0,10">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+
+                        <Border Grid.Column="0" Background="{StaticResource Superficie}"
+                                BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="6">
+                            <Grid>
+                                <TextBox Text="{Binding Busca, UpdateSourceTrigger=PropertyChanged}"
+                                         Background="Transparent" BorderThickness="0"
+                                         Foreground="{StaticResource Texto}" CaretBrush="{StaticResource Texto}"
+                                         Padding="12,8" VerticalContentAlignment="Center"
+                                         AutomationProperties.Name="Buscar aplicativo" />
+
+                                <TextBlock Text="Buscar pelo nome..." IsHitTestVisible="False"
+                                           Foreground="{StaticResource TextoSecundario}"
+                                           Margin="13,0,0,0" VerticalAlignment="Center"
+                                           Visibility="{Binding Busca, Converter={StaticResource TextoParaVisibilidade}, ConverterParameter=inverter}" />
+                            </Grid>
+                        </Border>
+
+                        <StackPanel Grid.Column="1" Orientation="Horizontal" Margin="10,0,0,0">
+                            <Button Content="Marcar todos" Style="{StaticResource BotaoBase}" Padding="10,7"
+                                    Command="{Binding MarcarTodosCommand}" />
+                            <Button Content="Limpar" Style="{StaticResource BotaoBase}" Padding="10,7" Margin="6,0,0,0"
+                                    Command="{Binding DesmarcarTodosCommand}" />
+                        </StackPanel>
+
+                        <TextBlock Grid.Column="2" Text="{Binding TextoDoFiltro}" VerticalAlignment="Center"
+                                   Margin="12,0,0,0" FontSize="12"
+                                   Foreground="{StaticResource TextoSecundario}" />
+                    </Grid>
+
+                    <Border Grid.Row="2" Background="{StaticResource Superficie}"
+                            BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8">
+                        <Grid>
+                            <ListBox ItemsSource="{Binding Itens}" Background="Transparent" BorderThickness="0"
+                                     ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                     HorizontalContentAlignment="Stretch" Padding="6"
+                                     ItemContainerStyle="{StaticResource ItemDeAcao}"
+                                     ItemTemplate="{StaticResource TemplateDeActionItem}" />
+
+                            <TextBlock Text="Clique em Varrer para ver o que está instalado."
+                                       Foreground="{StaticResource TextoSecundario}"
+                                       HorizontalAlignment="Center" VerticalAlignment="Center"
+                                       Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+                        </Grid>
+                    </Border>
+
+                    <StackPanel Grid.Row="3" Margin="0,12,0,0">
+                        <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100"
+                                     Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                                     BorderThickness="0" Margin="0,0,0,10"
+                                     Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                        <Grid>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="*" />
+                                <ColumnDefinition Width="Auto" />
+                            </Grid.ColumnDefinitions>
+
+                            <Button Grid.Column="0" Content="{Binding TextoAplicar}"
+                                    Style="{StaticResource BotaoPrimario}"
+                                    Command="{Binding AplicarCommand}" IsEnabled="{Binding PodeAgir}" />
+
+                            <TextBlock Grid.Column="1" Text="{Binding TextoDaSelecao}"
+                                       VerticalAlignment="Center" Margin="14,0,0,0"
+                                       Foreground="{StaticResource Acento}" />
+
+                            <CheckBox Grid.Column="3" Content="Simular (nao altera nada)" IsChecked="{Binding DryRun}"
+                                      VerticalAlignment="Center"
+                                      ToolTip="Dry-run: produz o mesmo relatorio sem tocar no sistema." />
+                        </Grid>
+
+                        <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                                   FontSize="12" Margin="0,10,0,0" TextWrapping="Wrap" MaxHeight="40" />
+                    </StackPanel>
+                </Grid>
+            </TabItem>
+
+            <!-- ==================== Atualizacoes ==================== -->
+            <TabItem Header="Atualizações">
+                <Grid Margin="0,14,0,0">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+
+                    <Grid Grid.Row="0" Margin="0,0,0,12">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+
+                        <Border Grid.Column="0" Background="{StaticResource Superficie}" CornerRadius="6"
+                                Padding="14,10" Margin="0,0,10,0">
+                            <TextBlock Text="{Binding ResumoDeAtualizacoes}" FontWeight="SemiBold" TextWrapping="Wrap" />
+                        </Border>
+
+                        <Button Grid.Column="1" Content="Verificar" Style="{StaticResource BotaoBase}"
+                                VerticalAlignment="Top"
+                                AutomationProperties.Name="Verificar atualizacoes"
+                                Command="{Binding VerificarAtualizacoesCommand}"
+                                IsEnabled="{Binding OcupadoComAtualizacoes, Converter={StaticResource InverterBool}}" />
+                    </Grid>
+
+                    <!-- winget ausente: nao adianta lista, o que falta e o proprio winget -->
+                    <Border Grid.Row="1" Background="{StaticResource Superficie}"
+                            BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8"
+                            Padding="16,14" Margin="0,0,0,12"
+                            Visibility="{Binding WingetAusente, Converter={StaticResource BoolParaVisibilidade}}">
+                        <StackPanel>
+                            <TextBlock Text="O winget não está instalado" FontWeight="SemiBold" />
+                            <TextBlock TextWrapping="Wrap" Margin="0,6,0,10"
+                                       Foreground="{StaticResource TextoSecundario}"
+                                       Text="Esta aba usa o winget, o gerenciador de pacotes da própria Microsoft, que vem junto com o App Installer. Ele existe no Windows 10 1709 em diante e no Windows 11; quando falta, é porque foi removido." />
+                            <Button Content="Abrir na Microsoft Store" Style="{StaticResource BotaoBase}"
+                                    HorizontalAlignment="Left"
+                                    Command="{Binding InstalarWingetCommand}" />
+                        </StackPanel>
+                    </Border>
+
+                    <Border Grid.Row="2" Background="{StaticResource Superficie}"
+                            BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8">
+                        <Grid>
+                            <ListBox ItemsSource="{Binding Atualizacoes}" Background="Transparent" BorderThickness="0"
+                                     ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                     HorizontalContentAlignment="Stretch" Padding="6"
+                                     ItemContainerStyle="{StaticResource ItemDeAcao}"
+                                     ItemTemplate="{StaticResource TemplateDeActionItem}" />
+                        </Grid>
+                    </Border>
+
+                    <StackPanel Grid.Row="3" Margin="0,12,0,0">
+                        <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100"
+                                     Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                                     BorderThickness="0" Margin="0,0,0,10"
+                                     Visibility="{Binding OcupadoComAtualizacoes, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                        <Grid>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="*" />
+                                <ColumnDefinition Width="Auto" />
+                            </Grid.ColumnDefinitions>
+
+                            <Button Grid.Column="0" Content="{Binding TextoAtualizar}"
+                                    Style="{StaticResource BotaoPrimario}"
+                                    Command="{Binding AtualizarSelecionadosCommand}"
+                                    IsEnabled="{Binding PodeAgir}" />
+
+                            <CheckBox Grid.Column="2" Content="Simular (nao altera nada)" IsChecked="{Binding DryRun}"
+                                      VerticalAlignment="Center" />
+                        </Grid>
+
+                        <TextBlock Text="{Binding StatusDeAtualizacoes}" Foreground="{StaticResource TextoSecundario}"
+                                   FontSize="12" Margin="0,10,0,0" TextWrapping="Wrap" MaxHeight="52" />
+                    </StackPanel>
+                </Grid>
+            </TabItem>
+
+            <!-- ==================== Restos ==================== -->
+            <TabItem Header="Restos de apps antigos">
+                <Grid Margin="0,14,0,0">
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+
+                    <Grid Grid.Row="0" Margin="0,0,0,12">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+
+                        <Border Grid.Column="0" Background="{StaticResource Superficie}" CornerRadius="6"
+                                Padding="14,10" Margin="0,0,10,0">
+                            <TextBlock Text="{Binding ResumoDeRestos}" FontWeight="SemiBold" TextWrapping="Wrap" />
+                        </Border>
+
+                        <Button Grid.Column="1" Content="Varrer restos" Style="{StaticResource BotaoBase}"
+                                VerticalAlignment="Top"
+                                AutomationProperties.Name="Varrer restos de apps antigos"
+                                Command="{Binding VarrerRestosCommand}"
+                                IsEnabled="{Binding OcupadoComRestos, Converter={StaticResource InverterBool}}" />
+                    </Grid>
+
+                    <Border Grid.Row="1" Background="{StaticResource Superficie}"
+                            BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8">
+                        <ListBox ItemsSource="{Binding Restos}" Background="Transparent" BorderThickness="0"
+                                 ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                 HorizontalContentAlignment="Stretch" Padding="6">
+                            <ListBox.ItemTemplate>
+                                <DataTemplate>
+                                    <Grid Margin="6,8">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="Auto" />
+                                            <ColumnDefinition Width="*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <CheckBox Grid.Column="0" IsChecked="{Binding Selecionado}"
+                                                  VerticalAlignment="Center" Margin="0,0,10,0"
+                                                  AutomationProperties.Name="{Binding Titulo}" />
+
+                                        <StackPanel Grid.Column="1">
+                                            <TextBlock Text="{Binding Titulo}" FontWeight="SemiBold" />
+                                            <TextBlock Text="{Binding Descricao}" FontSize="12"
+                                                       Foreground="{StaticResource TextoSecundario}" />
+                                            <TextBlock Text="{Binding Caminho}" FontSize="11"
+                                                       Foreground="{StaticResource TextoSecundario}"
+                                                       TextTrimming="CharacterEllipsis" />
+                                        </StackPanel>
+                                    </Grid>
+                                </DataTemplate>
+                            </ListBox.ItemTemplate>
+                        </ListBox>
+                    </Border>
+
+                    <StackPanel Grid.Row="2" Margin="0,12,0,0">
+                        <Grid>
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="Auto" />
+                                <ColumnDefinition Width="*" />
+                            </Grid.ColumnDefinitions>
+
+                            <Button Grid.Column="0" Content="{Binding TextoRemoverRestos}"
+                                    Style="{StaticResource BotaoPrimario}"
+                                    Command="{Binding RemoverRestosCommand}"
+                                    IsEnabled="{Binding PodeAgir}" />
+                        </Grid>
+
+                        <TextBlock Text="{Binding StatusDeRestos}" Foreground="{StaticResource TextoSecundario}"
+                                   FontSize="12" Margin="0,10,0,0" TextWrapping="Wrap" MaxHeight="52" />
+                    </StackPanel>
+                </Grid>
+            </TabItem>
+        </TabControl>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/AppsPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/AppsPage.xaml.cs
new file mode 100644
index 0000000..42d9b33
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/AppsPage.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class AppsPage : UserControl
+{
+    public AppsPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml b/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml
new file mode 100644
index 0000000..c3347a5
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml
@@ -0,0 +1,219 @@
+<UserControl x:Class="GameBoost.App.Views.ConfiguracoesPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <Grid Margin="26,22,26,22">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Grid.Row="0" Margin="0,0,0,16">
+            <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+            <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,0,0" />
+        </StackPanel>
+
+        <TabControl Grid.Row="1" Background="Transparent" BorderThickness="0" Padding="0,14,0,0">
+            <TabControl.Resources>
+                <Style TargetType="TabItem">
+                    <Setter Property="Foreground" Value="{StaticResource TextoSecundario}" />
+                    <Setter Property="Template">
+                        <Setter.Value>
+                            <ControlTemplate TargetType="TabItem">
+                                <Border x:Name="Aba" Padding="16,9" Margin="0,0,4,0" CornerRadius="6"
+                                        Background="Transparent">
+                                    <ContentPresenter ContentSource="Header" />
+                                </Border>
+                                <ControlTemplate.Triggers>
+                                    <Trigger Property="IsMouseOver" Value="True">
+                                        <Setter TargetName="Aba" Property="Background" Value="{StaticResource Superficie}" />
+                                    </Trigger>
+                                    <Trigger Property="IsSelected" Value="True">
+                                        <Setter TargetName="Aba" Property="Background" Value="{StaticResource SuperficieAlta}" />
+                                        <Setter Property="Foreground" Value="{StaticResource Texto}" />
+                                    </Trigger>
+                                </ControlTemplate.Triggers>
+                            </ControlTemplate>
+                        </Setter.Value>
+                    </Setter>
+                </Style>
+            </TabControl.Resources>
+
+            <!-- Preferencias -->
+            <TabItem Header="Preferencias">
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="22,18" VerticalAlignment="Top">
+                    <StackPanel>
+                        <TextBlock Text="Aparencia" FontWeight="SemiBold" Margin="0,0,0,10" />
+                        <CheckBox Content="Tema escuro" IsChecked="{Binding TemaEscuro}" />
+                        <TextBlock Text="O tema claro entra numa fase seguinte; por ora a troca fica registrada nas preferencias."
+                                   Foreground="{StaticResource TextoDesabilitado}" FontSize="11" Margin="24,4,0,0" />
+
+                        <Rectangle Height="1" Fill="{StaticResource Borda}" Margin="0,18" />
+
+                        <TextBlock Text="Inicializacao" FontWeight="SemiBold" Margin="0,0,0,10" />
+                        <CheckBox Content="Iniciar o GameBoost com o Windows" IsChecked="{Binding IniciarComWindows}" />
+                        <TextBlock Text="Desligado por padrao. Se ligar, o GameBoost aparece na propria lista de Inicializacao que ele gerencia."
+                                   Foreground="{StaticResource TextoDesabilitado}" FontSize="11" Margin="24,4,0,0" />
+
+                        <CheckBox Content="Abrir minimizado na bandeja" IsChecked="{Binding IniciarMinimizado}"
+                                  IsEnabled="{Binding IniciarComWindows}" Margin="0,10,0,0" />
+
+                <CheckBox Margin="0,14,0,0"
+                          Content="Permitir que o GameBoost use a internet"
+                          IsChecked="{Binding PermitirAcessoARede}"
+                          AutomationProperties.Name="Permitir que o GameBoost use a internet" />
+
+                <TextBlock Margin="24,4,0,0" FontSize="12" TextWrapping="Wrap"
+                           Foreground="{StaticResource TextoSecundario}"
+                           Text="Desligado por padrão. Serve só para o teste de velocidade da página Rede, que baixa e envia cerca de 100 MB de bytes aleatórios. O GameBoost não tem telemetria: nada sobre você ou sobre esta máquina sai daqui, com esta opção ligada ou desligada." />
+
+                <CheckBox Margin="0,18,0,0"
+                          Content="Mostrar o ícone na bandeja do sistema"
+                          IsChecked="{Binding MostrarNaBandeja}"
+                          AutomationProperties.Name="Mostrar o icone na bandeja do sistema" />
+
+                <TextBlock Margin="24,4,0,0" FontSize="12" TextWrapping="Wrap"
+                           Foreground="{StaticResource TextoSecundario}"
+                           Text="Com o ícone ligado, fechar a janela esconde o GameBoost na bandeja em vez de encerrar. Para sair de vez, clique com o botão direito no ícone e escolha Sair." />
+
+                <CheckBox Margin="0,18,0,0"
+                          Content="Reconhecer quando um jogo abre"
+                          IsChecked="{Binding DetectarJogosAutomaticamente}"
+                          AutomationProperties.Name="Reconhecer quando um jogo abre" />
+
+                <TextBlock Margin="24,4,0,0" FontSize="12" TextWrapping="Wrap"
+                           Foreground="{StaticResource TextoSecundario}"
+                           Text="Verifica os processos a cada 2 segundos, numa thread de prioridade baixa. Ao encontrar um jogo, ele pergunta se quer ativar o Modo Game — nunca ativa sozinho, a não ser que o perfil daquele jogo mande. Ao fechar o jogo, tudo é desfeito." />
+
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,22,0,0">
+                    <StackPanel>
+                        <TextBlock Text="Versão do GameBoost" FontWeight="SemiBold" />
+
+                        <TextBlock Margin="0,6,0,0" Foreground="{StaticResource TextoSecundario}">
+                            <Run Text="Você está na versão" />
+                            <Run Text="{Binding Versao, Mode=OneWay}" FontWeight="SemiBold" />
+                        </TextBlock>
+
+                        <TextBlock Text="{Binding EstadoDaAtualizacao}" TextWrapping="Wrap"
+                                   Margin="0,8,0,0" Foreground="{StaticResource TextoSecundario}" />
+
+                        <StackPanel Orientation="Horizontal" Margin="0,12,0,0">
+                            <Button Content="Verificar agora" Style="{StaticResource BotaoBase}"
+                                    AutomationProperties.Name="Verificar atualizacao do GameBoost"
+                                    Command="{Binding VerificarAtualizacaoCommand}"
+                                    IsEnabled="{Binding VerificandoAtualizacao, Converter={StaticResource InverterBool}}" />
+
+                            <Button Content="Instalar e reiniciar" Style="{StaticResource BotaoPrimario}"
+                                    Margin="8,0,0,0"
+                                    Command="{Binding InstalarAtualizacaoCommand}"
+                                    Visibility="{Binding AtualizacaoPronta, Converter={StaticResource BoolParaVisibilidade}}" />
+                        </StackPanel>
+
+                        <TextBlock Margin="0,10,0,0" FontSize="12" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   Text="A atualização é baixada em segundo plano e só entra quando você mandar, ou no próximo início. O GameBoost nunca troca de versão no meio do que você está fazendo." />
+                    </StackPanel>
+                </Border>
+
+                        <Rectangle Height="1" Fill="{StaticResource Borda}" Margin="0,18" />
+
+                        <TextBlock Text="Dados" FontWeight="SemiBold" Margin="0,0,0,8" />
+                        <TextBlock Text="{Binding ModoDeArmazenamento}" Foreground="{StaticResource TextoSecundario}" FontSize="12" />
+                        <TextBlock Text="{Binding PastaDeDados}" Foreground="{StaticResource TextoDesabilitado}"
+                                   FontSize="11" Margin="0,3,0,0" />
+                        <Button Content="Abrir pasta de dados" Style="{StaticResource BotaoBase}"
+                                HorizontalAlignment="Left" Margin="0,10,0,0"
+                                Command="{Binding AbrirPastaDeDadosCommand}" />
+
+                        <Rectangle Height="1" Fill="{StaticResource Borda}" Margin="0,18" />
+
+                        <TextBlock Text="Sem telemetria, sem anuncios, sem conta." FontWeight="SemiBold" />
+                        <TextBlock Text="Nada sai desta maquina. O GameBoost nao envia dados de uso para lugar nenhum."
+                                   Foreground="{StaticResource TextoSecundario}" FontSize="12" Margin="0,3,0,0" />
+                    </StackPanel>
+                </Border>
+            </TabItem>
+
+            <!-- Historico -->
+            <TabItem Header="Historico">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                    </Grid.RowDefinitions>
+
+                    <Grid Grid.Row="0" Margin="0,0,0,10">
+                        <TextBlock Text="Toda alteracao de sistema que o GameBoost ja fez, lida do state-backup."
+                                   Foreground="{StaticResource TextoSecundario}" FontSize="12" VerticalAlignment="Center" />
+                        <Button Content="Recarregar" Style="{StaticResource BotaoBase}" Padding="10,6"
+                                HorizontalAlignment="Right" Command="{Binding RecarregarHistoricoCommand}" />
+                    </Grid>
+
+                    <Border Grid.Row="1" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8">
+                        <Grid>
+                            <ListBox ItemsSource="{Binding Historico}" Background="Transparent" BorderThickness="0"
+                                     HorizontalContentAlignment="Stretch" Padding="6"
+                                     ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                     ItemContainerStyle="{StaticResource ItemDeAcao}">
+                                <ListBox.ItemTemplate>
+                                    <DataTemplate>
+                                        <Border Background="{StaticResource SuperficieAlta}" CornerRadius="6"
+                                                Padding="12,10" Margin="4,3">
+                                            <Grid>
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="*" />
+                                                    <ColumnDefinition Width="Auto" />
+                                                    <ColumnDefinition Width="Auto" />
+                                                </Grid.ColumnDefinitions>
+
+                                                <StackPanel Grid.Column="0">
+                                                    <TextBlock Text="{Binding Descricao}" FontWeight="SemiBold" />
+                                                    <TextBlock Text="{Binding Mudanca}" FontSize="12"
+                                                               Foreground="{StaticResource TextoSecundario}" />
+                                                    <StackPanel Orientation="Horizontal" Margin="0,3,0,0">
+                                                        <TextBlock Text="{Binding Quando}" FontSize="11"
+                                                                   Foreground="{StaticResource TextoDesabilitado}" />
+                                                        <TextBlock Text="  ·  " FontSize="11"
+                                                                   Foreground="{StaticResource TextoDesabilitado}" />
+                                                        <TextBlock Text="{Binding Modulo}" FontSize="11"
+                                                                   Foreground="{StaticResource TextoDesabilitado}" />
+                                                        <TextBlock Text="  ·  " FontSize="11"
+                                                                   Foreground="{StaticResource TextoDesabilitado}" />
+                                                        <TextBlock Text="{Binding Tipo}" FontSize="11"
+                                                                   Foreground="{StaticResource TextoDesabilitado}" />
+                                                    </StackPanel>
+                                                </StackPanel>
+
+                                                <TextBlock Grid.Column="1" Text="{Binding Situacao}" FontSize="12"
+                                                           VerticalAlignment="Center" Margin="12,0"
+                                                           Foreground="{StaticResource TextoSecundario}" />
+
+                                                <Button Grid.Column="2" Content="Desfazer" Style="{StaticResource BotaoBase}"
+                                                        Padding="10,6" IsEnabled="{Binding PodeDesfazer}"
+                                                        Command="{Binding DataContext.DesfazerCommand,
+                                                                  RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                                        CommandParameter="{Binding}" />
+                                            </Grid>
+                                        </Border>
+                                    </DataTemplate>
+                                </ListBox.ItemTemplate>
+                            </ListBox>
+
+                            <TextBlock Text="Nenhuma alteracao registrada ainda."
+                                       Foreground="{StaticResource TextoSecundario}"
+                                       HorizontalAlignment="Center" VerticalAlignment="Center"
+                                       Visibility="{Binding HistoricoVazio, Converter={StaticResource BoolParaVisibilidade}}" />
+                        </Grid>
+                    </Border>
+                </Grid>
+            </TabItem>
+        </TabControl>
+
+        <TextBlock Grid.Row="2" Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                   FontSize="12" Margin="0,12,0,0" />
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml.cs
new file mode 100644
index 0000000..aa031c7
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ConfiguracoesPage.xaml.cs
@@ -0,0 +1,12 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class ConfiguracoesPage : UserControl
+{
+    public ConfiguracoesPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml b/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml
new file mode 100644
index 0000000..7dcbefd
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml
@@ -0,0 +1,189 @@
+<UserControl x:Class="GameBoost.App.Views.DiagnosticoPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ctrl="clr-namespace:GameBoost.App.Controls">
+
+    <Grid Margin="26,22,26,22">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Cabecalho -->
+        <Grid Grid.Row="0" Margin="0,0,0,16">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+                <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,12,0" />
+            </StackPanel>
+
+            <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Top">
+                <TextBlock Text="{Binding TemperaturaCpu}" VerticalAlignment="Center" Margin="0,0,14,0"
+                           Foreground="{StaticResource TextoSecundario}"
+                           Visibility="{Binding TemperaturaCpu, Converter={StaticResource TextoParaVisibilidade}}" />
+
+                <Button Content="Iniciar" Style="{StaticResource BotaoPrimario}"
+                        Command="{Binding IniciarCommand}"
+                        Visibility="{Binding Monitorando, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+
+                <Button Content="Parar" Style="{StaticResource BotaoBase}"
+                        Command="{Binding PararCommand}"
+                        Visibility="{Binding Monitorando, Converter={StaticResource BoolParaVisibilidade}}" />
+            </StackPanel>
+        </Grid>
+
+        <!-- Cinco medidores com grafico de 60 s -->
+        <ItemsControl Grid.Row="1" ItemsSource="{Binding Medidores}" Margin="0,0,0,14">
+            <ItemsControl.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <UniformGrid Rows="1" />
+                </ItemsPanelTemplate>
+            </ItemsControl.ItemsPanel>
+
+            <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                    <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8" Padding="14,12" Margin="0,0,10,0">
+                        <StackPanel>
+                            <Grid>
+                                <TextBlock Text="{Binding Nome}" Foreground="{StaticResource TextoSecundario}" FontSize="12" />
+                                <TextBlock Text="{Binding Texto}" HorizontalAlignment="Right"
+                                           FontSize="17" FontWeight="Bold" />
+                            </Grid>
+
+                            <ctrl:MiniGrafico Height="46" Margin="0,8,0,0"
+                                              Valores="{Binding Serie}"
+                                              Maximo="{Binding Maximo}"
+                                              CorDaLinha="{StaticResource Acento}" />
+
+                            <TextBlock Text="{Binding Detalhe}" Foreground="{StaticResource TextoDesabilitado}"
+                                       FontSize="10" Margin="0,6,0,0" TextTrimming="CharacterEllipsis"
+                                       ToolTip="{Binding Detalhe}"
+                                       Visibility="{Binding Detalhe, Converter={StaticResource TextoParaVisibilidade}}" />
+                        </StackPanel>
+                    </Border>
+                </DataTemplate>
+            </ItemsControl.ItemTemplate>
+        </ItemsControl>
+
+        <!-- Findings e top 10 processos -->
+        <Grid Grid.Row="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="3*" />
+                <ColumnDefinition Width="2*" />
+            </Grid.ColumnDefinitions>
+
+            <!-- Findings -->
+            <Border Grid.Column="0" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                    BorderThickness="1" CornerRadius="8" Margin="0,0,10,0">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                    </Grid.RowDefinitions>
+
+                    <TextBlock Grid.Row="0" Text="O que encontramos" FontWeight="SemiBold" Margin="16,14,16,8" />
+
+                    <ListBox Grid.Row="1" ItemsSource="{Binding Findings}" Background="Transparent"
+                             BorderThickness="0" Padding="10,0,10,10"
+                             HorizontalContentAlignment="Stretch"
+                             ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                             ItemContainerStyle="{StaticResource ItemDeAcao}">
+                        <ListBox.ItemTemplate>
+                            <DataTemplate>
+                                <Border Background="{StaticResource SuperficieAlta}" CornerRadius="6"
+                                        Padding="14,11" Margin="0,4" BorderThickness="3,0,0,0">
+                                    <Border.Style>
+                                        <Style TargetType="Border">
+                                            <Setter Property="BorderBrush" Value="{StaticResource Acento}" />
+                                            <Style.Triggers>
+                                                <DataTrigger Binding="{Binding TextoDeSeveridade}" Value="Critico">
+                                                    <Setter Property="BorderBrush" Value="{StaticResource RiscoAlto}" />
+                                                </DataTrigger>
+                                                <DataTrigger Binding="{Binding TextoDeSeveridade}" Value="Atencao">
+                                                    <Setter Property="BorderBrush" Value="{StaticResource RiscoMedio}" />
+                                                </DataTrigger>
+                                            </Style.Triggers>
+                                        </Style>
+                                    </Border.Style>
+
+                                    <StackPanel>
+                                        <Grid>
+                                            <TextBlock Text="{Binding Titulo}" FontWeight="SemiBold"
+                                                       Margin="0,0,80,0" />
+                                            <TextBlock Text="{Binding TextoDeSeveridade}" FontSize="10"
+                                                       HorizontalAlignment="Right" VerticalAlignment="Top"
+                                                       Foreground="{StaticResource TextoDesabilitado}" />
+                                        </Grid>
+
+                                        <TextBlock Text="{Binding Detalhe}" Foreground="{StaticResource TextoSecundario}"
+                                                   FontSize="12" Margin="0,4,0,0" />
+
+                                        <Button Content="{Binding TextoDaAcao}" Style="{StaticResource BotaoBase}"
+                                                Padding="10,5" HorizontalAlignment="Left" Margin="0,9,0,0"
+                                                Visibility="{Binding TemAcao, Converter={StaticResource BoolParaVisibilidade}}"
+                                                Command="{Binding DataContext.ExecutarAcaoCommand,
+                                                          RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                                CommandParameter="{Binding}" />
+                                    </StackPanel>
+                                </Border>
+                            </DataTemplate>
+                        </ListBox.ItemTemplate>
+                    </ListBox>
+
+                    <TextBlock Grid.Row="1" Text="Nada fora do lugar por enquanto."
+                               Foreground="{StaticResource RiscoBaixo}"
+                               HorizontalAlignment="Center" VerticalAlignment="Center"
+                               Visibility="{Binding SemFindings, Converter={StaticResource BoolParaVisibilidade}}" />
+                </Grid>
+            </Border>
+
+            <!-- Top 10 processos -->
+            <Border Grid.Column="1" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                    BorderThickness="1" CornerRadius="8">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                    </Grid.RowDefinitions>
+
+                    <TextBlock Grid.Row="0" Text="Quem mais consome" FontWeight="SemiBold" Margin="16,14,16,8" />
+
+                    <ItemsControl Grid.Row="1" ItemsSource="{Binding TopProcessos}" Margin="10,0,10,10">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Grid Margin="6,5">
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="*" />
+                                        <ColumnDefinition Width="Auto" />
+                                    </Grid.ColumnDefinitions>
+
+                                    <TextBlock Grid.Column="0" Text="{Binding NomeExibido}"
+                                               TextTrimming="CharacterEllipsis" />
+                                    <TextBlock Grid.Column="1" FontSize="12"
+                                               Foreground="{StaticResource TextoSecundario}">
+                                        <Run Text="{Binding CpuPercent, StringFormat={}{0:0.0}%, Mode=OneWay}" />
+                                    </TextBlock>
+                                </Grid>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+                </Grid>
+            </Border>
+        </Grid>
+
+        <!-- Rodape -->
+        <StackPanel Grid.Row="3" Margin="0,12,0,0">
+            <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}" FontSize="12" />
+            <TextBlock Text="{Binding CustoDaColeta}" Foreground="{StaticResource TextoDesabilitado}"
+                       FontSize="11" Margin="0,3,0,0"
+                       Visibility="{Binding CustoDaColeta, Converter={StaticResource TextoParaVisibilidade}}" />
+        </StackPanel>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml.cs
new file mode 100644
index 0000000..a7f19af
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/DiagnosticoPage.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class DiagnosticoPage : UserControl
+{
+    public DiagnosticoPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml b/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml
new file mode 100644
index 0000000..3d92026
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml
@@ -0,0 +1,257 @@
+<UserControl x:Class="GameBoost.App.Views.EspacoPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ctrl="clr-namespace:GameBoost.App.Controls">
+
+    <UserControl.Resources>
+        <!-- Mesma linha para arquivo, pasta e jogo: os tres tem nome, detalhe e tamanho. -->
+        <DataTemplate x:Key="LinhaDeEspaco">
+            <Border Background="{StaticResource SuperficieAlta}" CornerRadius="5" Padding="10,7" Margin="3,2">
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <StackPanel Grid.Column="0">
+                        <StackPanel Orientation="Horizontal">
+                            <TextBlock Text="{Binding Nome}" FontWeight="SemiBold"
+                                       TextTrimming="CharacterEllipsis" MaxWidth="300" />
+                            <Border Background="{StaticResource RiscoMedio}" CornerRadius="3" Padding="6,1"
+                                    Margin="8,0,0,0" VerticalAlignment="Center"
+                                    Visibility="{Binding TemMarca, Converter={StaticResource BoolParaVisibilidade}}">
+                                <TextBlock Text="{Binding Marca}" FontSize="10" Foreground="#FF0D1117" />
+                            </Border>
+                        </StackPanel>
+                        <TextBlock Text="{Binding Detalhe}" FontSize="11" Margin="0,2,8,0"
+                                   Foreground="{StaticResource TextoDesabilitado}"
+                                   TextTrimming="CharacterEllipsis" />
+                    </StackPanel>
+
+                    <TextBlock Grid.Column="1" Text="{Binding Tamanho}" VerticalAlignment="Center"
+                               FontWeight="SemiBold" Margin="8,0,10,0" />
+
+                    <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center">
+                        <Button Content="Abrir" Style="{StaticResource BotaoBase}" Padding="9,5"
+                                Command="{Binding DataContext.AbrirNoExplorerCommand,
+                                          RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                CommandParameter="{Binding}"
+                                ToolTip="Abrir no Explorer" />
+                        <Button Content="Lixeira" Style="{StaticResource BotaoBase}" Padding="9,5" Margin="5,0,0,0"
+                                Command="{Binding DataContext.MandarParaLixeiraCommand,
+                                          RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                CommandParameter="{Binding}"
+                                ToolTip="Enviar para a Lixeira, de onde dá para recuperar" />
+                    </StackPanel>
+                </Grid>
+            </Border>
+        </DataTemplate>
+    </UserControl.Resources>
+
+    <Grid Margin="26,22,26,22">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Cabecalho -->
+        <Grid Grid.Row="0" Margin="0,0,0,14">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+                <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,12,0" />
+            </StackPanel>
+
+            <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Top">
+                <ComboBox ItemsSource="{Binding Volumes}" SelectedItem="{Binding VolumeSelecionado}"
+                          Width="80" VerticalContentAlignment="Center" Margin="0,0,8,0"
+                          IsEnabled="{Binding Varrendo, Converter={StaticResource InverterBool}}" />
+
+                <Button Content="Varrer" Style="{StaticResource BotaoPrimario}"
+                        Command="{Binding VarrerCommand}"
+                        Visibility="{Binding Varrendo, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+
+                <Button Content="Cancelar" Style="{StaticResource BotaoBase}"
+                        Command="{Binding CancelarCommand}"
+                        Visibility="{Binding Varrendo, Converter={StaticResource BoolParaVisibilidade}}" />
+            </StackPanel>
+        </Grid>
+
+        <!-- Resumo -->
+        <Border Grid.Row="1" Background="{StaticResource Superficie}" CornerRadius="6" Padding="14,10"
+                Margin="0,0,0,12"
+                Visibility="{Binding Resumo, Converter={StaticResource TextoParaVisibilidade}}">
+            <TextBlock Text="{Binding Resumo}" FontWeight="SemiBold" />
+        </Border>
+
+        <!-- Treemap e listas -->
+        <Grid Grid.Row="2">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="460" />
+            </Grid.ColumnDefinitions>
+
+            <Border Grid.Column="0" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                    BorderThickness="1" CornerRadius="8" Margin="0,0,12,0">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                    </Grid.RowDefinitions>
+
+                    <!-- Trilha de navegacao -->
+                    <Grid Grid.Row="0" Margin="12,10,12,8">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+
+                        <Button Grid.Column="0" Content="Subir" Style="{StaticResource BotaoBase}" Padding="10,5"
+                                Command="{Binding SubirCommand}" IsEnabled="{Binding PodeSubir}" />
+                        <Button Grid.Column="1" Content="Raiz" Style="{StaticResource BotaoBase}" Padding="10,5"
+                                Margin="6,0,0,0" Command="{Binding VoltarParaRaizCommand}"
+                                IsEnabled="{Binding PodeSubir}" />
+
+                        <TextBlock Grid.Column="2" Text="{Binding NoAtual.Caminho}" VerticalAlignment="Center"
+                                   Margin="12,0,0,0" FontSize="12" TextTrimming="CharacterEllipsis"
+                                   Foreground="{StaticResource TextoSecundario}" />
+                    </Grid>
+
+                    <ctrl:Treemap x:Name="Mapa" Grid.Row="1" Margin="10,0,10,10"
+                                  Raiz="{Binding NoAtual}" />
+                </Grid>
+            </Border>
+
+            <!-- Abas: jogos, arquivos, pastas -->
+            <TabControl Grid.Column="1" Background="Transparent" BorderThickness="0" Padding="0,10,0,0">
+                <TabControl.Resources>
+                    <Style TargetType="TabItem">
+                        <Setter Property="Foreground" Value="{StaticResource TextoSecundario}" />
+                        <Setter Property="Template">
+                            <Setter.Value>
+                                <ControlTemplate TargetType="TabItem">
+                                    <Border x:Name="Aba" Padding="13,8" Margin="0,0,4,0" CornerRadius="6"
+                                            Background="Transparent">
+                                        <ContentPresenter ContentSource="Header" />
+                                    </Border>
+                                    <ControlTemplate.Triggers>
+                                        <Trigger Property="IsMouseOver" Value="True">
+                                            <Setter TargetName="Aba" Property="Background" Value="{StaticResource Superficie}" />
+                                        </Trigger>
+                                        <Trigger Property="IsSelected" Value="True">
+                                            <Setter TargetName="Aba" Property="Background" Value="{StaticResource SuperficieAlta}" />
+                                            <Setter Property="Foreground" Value="{StaticResource Texto}" />
+                                        </Trigger>
+                                    </ControlTemplate.Triggers>
+                                </ControlTemplate>
+                            </Setter.Value>
+                        </Setter>
+                    </Style>
+                </TabControl.Resources>
+
+                <TabItem Header="Jogos">
+                    <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8">
+                        <Grid>
+                            <ListBox ItemsSource="{Binding Jogos}" Background="Transparent" BorderThickness="0"
+                                     Padding="6" HorizontalContentAlignment="Stretch"
+                                     ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                     ItemContainerStyle="{StaticResource ItemDeAcao}"
+                                     ItemTemplate="{StaticResource LinhaDeEspaco}" />
+
+                            <TextBlock Text="Nenhum jogo encontrado nos launchers."
+                                       Foreground="{StaticResource TextoSecundario}"
+                                       HorizontalAlignment="Center" VerticalAlignment="Center"
+                                       Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+                        </Grid>
+                    </Border>
+                </TabItem>
+
+                <TabItem Header="Maiores arquivos">
+                    <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8">
+                        <ListBox ItemsSource="{Binding MaioresArquivos}" Background="Transparent" BorderThickness="0"
+                                 Padding="6" HorizontalContentAlignment="Stretch"
+                                 ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                 ItemContainerStyle="{StaticResource ItemDeAcao}"
+                                 ItemTemplate="{StaticResource LinhaDeEspaco}" />
+                    </Border>
+                </TabItem>
+
+                <TabItem Header="Maiores pastas">
+                    <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8">
+                        <ListBox ItemsSource="{Binding MaioresPastas}" Background="Transparent" BorderThickness="0"
+                                 Padding="6" HorizontalContentAlignment="Stretch"
+                                 ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                 ItemContainerStyle="{StaticResource ItemDeAcao}"
+                                 ItemTemplate="{StaticResource LinhaDeEspaco}" />
+                    </Border>
+                </TabItem>
+
+                <TabItem Header="Sistema">
+                    <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                            BorderThickness="1" CornerRadius="8">
+                        <ListBox ItemsSource="{Binding Especiais}" Background="Transparent" BorderThickness="0"
+                                 Padding="6" HorizontalContentAlignment="Stretch"
+                                 ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                                 ItemContainerStyle="{StaticResource ItemDeAcao}">
+                            <ListBox.ItemTemplate>
+                                <DataTemplate>
+                                    <Border Background="{StaticResource SuperficieAlta}" CornerRadius="5"
+                                            Padding="10,8" Margin="3,3">
+                                        <Grid>
+                                            <Grid.ColumnDefinitions>
+                                                <ColumnDefinition Width="*" />
+                                                <ColumnDefinition Width="Auto" />
+                                            </Grid.ColumnDefinitions>
+
+                                            <StackPanel Grid.Column="0" Margin="0,0,8,0">
+                                                <TextBlock Text="{Binding Nome}" FontWeight="SemiBold" />
+                                                <TextBlock Text="{Binding OQueE}" FontSize="11" Margin="0,3,0,0"
+                                                           Foreground="{StaticResource TextoSecundario}" />
+                                            </StackPanel>
+
+                                            <StackPanel Grid.Column="1" VerticalAlignment="Center">
+                                                <TextBlock HorizontalAlignment="Right" FontWeight="SemiBold">
+                                                    <Run Text="{Binding Bytes, Mode=OneWay, StringFormat={}{0:N0} bytes}" />
+                                                </TextBlock>
+                                                <Button Content="Como remover" Style="{StaticResource BotaoBase}"
+                                                        Padding="9,4" Margin="0,5,0,0"
+                                                        Command="{Binding DataContext.ExplicarEspecialCommand,
+                                                                  RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                                        CommandParameter="{Binding}" />
+                                            </StackPanel>
+                                        </Grid>
+                                    </Border>
+                                </DataTemplate>
+                            </ListBox.ItemTemplate>
+                        </ListBox>
+                    </Border>
+                </TabItem>
+            </TabControl>
+        </Grid>
+
+        <!-- Rodape -->
+        <StackPanel Grid.Row="3" Margin="0,12,0,0">
+            <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100" BorderThickness="0"
+                         Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                         Margin="0,0,0,8"
+                         Visibility="{Binding Varrendo, Converter={StaticResource BoolParaVisibilidade}}" />
+
+            <TextBlock Text="{Binding SobOMouse}" Foreground="{StaticResource Acento}" FontSize="12"
+                       TextTrimming="CharacterEllipsis"
+                       Visibility="{Binding SobOMouse, Converter={StaticResource TextoParaVisibilidade}}" />
+            <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}" FontSize="12"
+                       Margin="0,3,0,0" />
+        </StackPanel>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml.cs
new file mode 100644
index 0000000..fdbcdb9
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/EspacoPage.xaml.cs
@@ -0,0 +1,17 @@
+using System.Windows.Controls;
+using GameBoost.App.ViewModels;
+
+namespace GameBoost.App.Views;
+
+public partial class EspacoPage : UserControl
+{
+    public EspacoPage()
+    {
+        InitializeComponent();
+
+        // O treemap avisa por evento, e nao por binding: navegar e passar o
+        // mouse sao interacoes visuais, nao estado a ser observado.
+        Mapa.AoEntrarNaPasta += no => (DataContext as EspacoPageViewModel)?.Entrar(no);
+        Mapa.AoPassarOMouse += no => (DataContext as EspacoPageViewModel)?.MostrarNoRodape(no);
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml b/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml
new file mode 100644
index 0000000..f4d5a72
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml
@@ -0,0 +1,185 @@
+<UserControl x:Class="GameBoost.App.Views.FerramentasPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:scm="clr-namespace:System.ComponentModel;assembly=WindowsBase">
+
+    <UserControl.Resources>
+        <!-- Agrupa por categoria: Interface, Rede, Espaco, Seguranca, Diagnostico. -->
+        <CollectionViewSource x:Key="PorCategoria" Source="{Binding Ferramentas}">
+            <CollectionViewSource.GroupDescriptions>
+                <PropertyGroupDescription PropertyName="Categoria" />
+            </CollectionViewSource.GroupDescriptions>
+        </CollectionViewSource>
+    </UserControl.Resources>
+
+    <Grid Margin="26,22,26,22">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Grid.Row="0" Margin="0,0,0,16">
+            <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+            <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,0,0" />
+        </StackPanel>
+
+        <Grid Grid.Row="1">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <!-- Lista de ferramentas -->
+            <Border Grid.Column="0" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                    BorderThickness="1" CornerRadius="8">
+                <ListBox ItemsSource="{Binding Source={StaticResource PorCategoria}}"
+                         Background="Transparent" BorderThickness="0" Padding="8"
+                         HorizontalContentAlignment="Stretch"
+                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                         ItemContainerStyle="{StaticResource ItemDeAcao}">
+
+                    <ListBox.GroupStyle>
+                        <GroupStyle>
+                            <GroupStyle.HeaderTemplate>
+                                <DataTemplate>
+                                    <TextBlock Text="{Binding Name}" FontWeight="SemiBold" FontSize="12"
+                                               Foreground="{StaticResource TextoSecundario}"
+                                               Margin="6,12,0,4" />
+                                </DataTemplate>
+                            </GroupStyle.HeaderTemplate>
+                        </GroupStyle>
+                    </ListBox.GroupStyle>
+
+                    <ListBox.ItemTemplate>
+                        <DataTemplate>
+                            <Border Background="{StaticResource SuperficieAlta}" CornerRadius="6"
+                                    Padding="12,10" Margin="4,3">
+                                <Grid>
+                                    <Grid.ColumnDefinitions>
+                                        <ColumnDefinition Width="*" />
+                                        <ColumnDefinition Width="Auto" />
+                                        <ColumnDefinition Width="Auto" />
+                                    </Grid.ColumnDefinitions>
+                                    <Grid.RowDefinitions>
+                                        <RowDefinition Height="Auto" />
+                                        <RowDefinition Height="Auto" />
+                                    </Grid.RowDefinitions>
+
+                                    <StackPanel Grid.Row="0" Grid.Column="0">
+                                        <StackPanel Orientation="Horizontal">
+                                            <TextBlock Text="{Binding Titulo}" FontWeight="SemiBold" />
+
+                                            <Border Background="{StaticResource Borda}" CornerRadius="3"
+                                                    Padding="6,1" Margin="8,0,0,0" VerticalAlignment="Center"
+                                                    Visibility="{Binding PrecisaAdmin, Converter={StaticResource BoolParaVisibilidade}}">
+                                                <TextBlock Text="admin" FontSize="10"
+                                                           Foreground="{StaticResource TextoSecundario}" />
+                                            </Border>
+                                        </StackPanel>
+
+                                        <TextBlock Text="{Binding Descricao}" FontSize="12" Margin="0,3,12,0"
+                                                   Foreground="{StaticResource TextoSecundario}" />
+
+                                        <TextBlock Text="{Binding Duracao}" FontSize="11" Margin="0,3,0,0"
+                                                   Foreground="{StaticResource TextoDesabilitado}"
+                                                   Visibility="{Binding Duracao, Converter={StaticResource TextoParaVisibilidade}}" />
+                                    </StackPanel>
+
+                                    <Border Grid.Row="0" Grid.Column="1" CornerRadius="4" Padding="7,2"
+                                            VerticalAlignment="Top" Margin="0,1,10,0"
+                                            Background="{Binding Risco, Converter={StaticResource RiscoParaCor}}">
+                                        <TextBlock Text="{Binding TextoDeRisco}" FontSize="11"
+                                                   Foreground="#FF0D1117" FontWeight="SemiBold" />
+                                    </Border>
+
+                                    <StackPanel Grid.Row="0" Grid.Column="2" Orientation="Horizontal"
+                                                VerticalAlignment="Top">
+                                        <Button Padding="12,6"
+                                                Command="{Binding DataContext.ExecutarCommand,
+                                                          RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                                CommandParameter="{Binding}">
+                                            <Button.Style>
+                                                <Style TargetType="Button" BasedOn="{StaticResource BotaoBase}">
+                                                    <Setter Property="Content" Value="Executar" />
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding Rodando}" Value="True">
+                                                            <Setter Property="Content" Value="Rodando..." />
+                                                            <Setter Property="IsEnabled" Value="False" />
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </Button.Style>
+                                        </Button>
+
+                                        <Button Content="?" Width="30" Height="30" Padding="0" Margin="6,0,0,0"
+                                                Style="{StaticResource BotaoBase}"
+                                                Command="{Binding DataContext.ExplicarCommand,
+                                                          RelativeSource={RelativeSource AncestorType=ListBox}}"
+                                                CommandParameter="{Binding}"
+                                                ToolTip="O que faz, qual o risco, como desfazer" />
+                                    </StackPanel>
+
+                                    <!-- Resultado da ferramenta -->
+                                    <Border Grid.Row="1" Grid.ColumnSpan="3" CornerRadius="4" Padding="9,6"
+                                            Margin="0,9,0,0" Background="{StaticResource Superficie}"
+                                            Visibility="{Binding TemResultado, Converter={StaticResource BoolParaVisibilidade}}">
+                                        <TextBlock Text="{Binding Resultado}" FontSize="12">
+                                            <TextBlock.Style>
+                                                <Style TargetType="TextBlock">
+                                                    <Setter Property="Foreground" Value="{StaticResource RiscoBaixo}" />
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding Falhou}" Value="True">
+                                                            <Setter Property="Foreground" Value="{StaticResource RiscoAlto}" />
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </TextBlock.Style>
+                                        </TextBlock>
+                                    </Border>
+                                </Grid>
+                            </Border>
+                        </DataTemplate>
+                    </ListBox.ItemTemplate>
+                </ListBox>
+            </Border>
+
+            <!-- Saida longa: sfc, DISM, teste de disco, informacoes do sistema -->
+            <Border Grid.Column="1" Width="420" Margin="12,0,0,0"
+                    Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                    BorderThickness="1" CornerRadius="8"
+                    Visibility="{Binding TemSaida, Converter={StaticResource BoolParaVisibilidade}}">
+                <Grid>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="Auto" />
+                        <RowDefinition Height="*" />
+                        <RowDefinition Height="Auto" />
+                    </Grid.RowDefinitions>
+
+                    <TextBlock Grid.Row="0" Text="Saída" FontWeight="SemiBold" Margin="16,14,16,8" />
+
+                    <ScrollViewer Grid.Row="1" Margin="12,0,12,0" VerticalScrollBarVisibility="Auto">
+                        <TextBox Text="{Binding SaidaLonga, Mode=OneWay}" IsReadOnly="True"
+                                 Background="Transparent" BorderThickness="0"
+                                 Foreground="{StaticResource TextoSecundario}"
+                                 FontFamily="Consolas, Cascadia Mono, monospace" FontSize="11"
+                                 TextWrapping="Wrap" />
+                    </ScrollViewer>
+
+                    <StackPanel Grid.Row="2" Orientation="Horizontal" Margin="12,10,12,12">
+                        <Button Content="Copiar" Style="{StaticResource BotaoBase}" Padding="12,6"
+                                Command="{Binding CopiarSaidaCommand}" />
+                        <Button Content="Limpar" Style="{StaticResource BotaoBase}" Padding="12,6" Margin="6,0,0,0"
+                                Command="{Binding LimparSaidaCommand}" />
+                        <Button Content="Cancelar" Style="{StaticResource BotaoBase}" Padding="12,6" Margin="6,0,0,0"
+                                Command="{Binding CancelarCommand}"
+                                Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+                    </StackPanel>
+                </Grid>
+            </Border>
+        </Grid>
+
+        <TextBlock Grid.Row="2" Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                   FontSize="12" Margin="0,12,0,0" />
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml.cs
new file mode 100644
index 0000000..2e3f735
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/FerramentasPage.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class FerramentasPage : UserControl
+{
+    public FerramentasPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/InicioPage.xaml b/GameBoost/src/GameBoost.App/Views/InicioPage.xaml
new file mode 100644
index 0000000..b3b47e6
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/InicioPage.xaml
@@ -0,0 +1,274 @@
+<UserControl x:Class="GameBoost.App.Views.InicioPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <Grid Margin="26,22,26,0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Cabecalho -->
+        <StackPanel Grid.Row="0" Margin="0,0,0,14">
+            <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+            <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,0,0" />
+        </StackPanel>
+
+        <!-- Aviso de restauracao pendente -->
+        <Border Grid.Row="1" Background="#33D29922" BorderBrush="{StaticResource RiscoMedio}"
+                BorderThickness="1" CornerRadius="6" Padding="14,10" Margin="0,0,0,12"
+                Visibility="{Binding AvisoDeRestauracao, Converter={StaticResource TextoParaVisibilidade}}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+                <TextBlock Grid.Column="0" Text="{Binding AvisoDeRestauracao}" VerticalAlignment="Center" />
+                <Button Grid.Column="1" Content="Restaurar agora" Style="{StaticResource BotaoBase}"
+                        Command="{Binding ReverterTudoCommand}" Margin="12,0,0,0" />
+            </Grid>
+        </Border>
+
+        <!-- Pontuacao de saude e principais achados (secoes 5.12 e 5.5) -->
+        <Border Grid.Row="2" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,14">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto" />
+                    <ColumnDefinition Width="*" />
+                    <ColumnDefinition Width="Auto" />
+                </Grid.ColumnDefinitions>
+
+                <!-- Nota -->
+                <Border Grid.Column="0" Width="62" Height="62" CornerRadius="31"
+                        Background="{StaticResource SuperficieAlta}"
+                        BorderBrush="{StaticResource Borda}" BorderThickness="2">
+                    <Grid>
+                        <TextBlock Text="--" FontSize="19" FontWeight="Bold"
+                                   Foreground="{StaticResource TextoDesabilitado}"
+                                   HorizontalAlignment="Center" VerticalAlignment="Center"
+                                   Visibility="{Binding PontuacaoDisponivel, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+                        <TextBlock Text="{Binding NotaGeral}" FontSize="22" FontWeight="Bold"
+                                   Foreground="{StaticResource Acento}"
+                                   HorizontalAlignment="Center" VerticalAlignment="Center"
+                                   Visibility="{Binding PontuacaoDisponivel, Converter={StaticResource BoolParaVisibilidade}}" />
+                    </Grid>
+                </Border>
+
+                <StackPanel Grid.Column="1" Margin="16,0,12,0" VerticalAlignment="Center">
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock Text="Saude do sistema" FontWeight="SemiBold" />
+                        <TextBlock Text="{Binding Conceito}" Margin="8,0,0,0"
+                                   Foreground="{StaticResource Acento}"
+                                   Visibility="{Binding PontuacaoDisponivel, Converter={StaticResource BoolParaVisibilidade}}" />
+                    </StackPanel>
+
+                    <!-- Antes da analise -->
+                    <TextBlock Text="{Binding PontuacaoPlaceholder}"
+                               Foreground="{StaticResource TextoSecundario}" FontSize="12" Margin="0,3,0,0"
+                               Visibility="{Binding PontuacaoDisponivel, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+
+                    <!-- Notas por area -->
+                    <ItemsControl ItemsSource="{Binding Areas}" Margin="0,7,0,0"
+                                  Visibility="{Binding PontuacaoDisponivel, Converter={StaticResource BoolParaVisibilidade}}">
+                        <ItemsControl.ItemsPanel>
+                            <ItemsPanelTemplate><UniformGrid Rows="1" /></ItemsPanelTemplate>
+                        </ItemsControl.ItemsPanel>
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <StackPanel Margin="0,0,14,0">
+                                    <TextBlock Text="{Binding Nome}" FontSize="11"
+                                               Foreground="{StaticResource TextoSecundario}"
+                                               TextTrimming="CharacterEllipsis" />
+                                    <Grid Margin="0,3,0,0">
+                                        <Border Background="{StaticResource SuperficieAlta}" CornerRadius="3" Height="6" />
+                                        <Border Background="{StaticResource Acento}" CornerRadius="3" Height="6"
+                                                HorizontalAlignment="Left"
+                                                Width="{Binding Nota}" />
+                                    </Grid>
+                                    <TextBlock Text="{Binding Nota}" FontSize="11" Margin="0,2,0,0" />
+                                </StackPanel>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+
+                    <TextBlock Text="{Binding ProgressoDaAnalise}" FontSize="11" Margin="0,6,0,0"
+                               Foreground="{StaticResource TextoDesabilitado}"
+                               Visibility="{Binding ProgressoDaAnalise, Converter={StaticResource TextoParaVisibilidade}}" />
+                </StackPanel>
+
+                <StackPanel Grid.Column="2" VerticalAlignment="Center">
+                    <Button Content="Analisar" Style="{StaticResource BotaoBase}" Padding="14,7"
+                            Command="{Binding AnalisarSaudeCommand}"
+                            IsEnabled="{Binding Analisando, Converter={StaticResource InverterBool}}" />
+                    <Button Content="Exportar relatorio" Style="{StaticResource BotaoBase}" Padding="14,7" Margin="0,6,0,0"
+                            Command="{Binding ExportarRelatorioCommand}"
+                            IsEnabled="{Binding Analisando, Converter={StaticResource InverterBool}}"
+                            ToolTip="Gera uma pagina HTML para mandar a quem da suporte." />
+                </StackPanel>
+            </Grid>
+        </Border>
+
+        <!-- Lista do Modo Game: o mesmo template das demais paginas -->
+
+        <!--
+          Lista de restauracao (secao 5.1). O que nao esta marcado com estrela
+          nao reabre sozinho; ate agora o app anunciava "N aguardando" sem dar
+          onde clicar.
+        -->
+        <Border Grid.Row="3" Background="{StaticResource Superficie}"
+                BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8"
+                Padding="14,12" Margin="0,0,0,10"
+                Visibility="{Binding TemAppsParaReabrir, Converter={StaticResource BoolParaVisibilidade}}">
+            <StackPanel>
+                <TextBlock Text="Aguardando para reabrir" FontWeight="SemiBold" Margin="0,0,0,8" />
+
+                <ItemsControl ItemsSource="{Binding ParaReabrir}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <Grid Margin="0,4">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="*" />
+                                    <ColumnDefinition Width="Auto" />
+                                </Grid.ColumnDefinitions>
+
+                                <StackPanel Grid.Column="0" VerticalAlignment="Center">
+                                    <TextBlock Text="{Binding Nome}" FontWeight="SemiBold" />
+                                    <TextBlock Text="{Binding Detalhe}" FontSize="12"
+                                               Foreground="{StaticResource TextoSecundario}" />
+                                </StackPanel>
+
+                                <Button Grid.Column="1" Content="Reabrir" Padding="12,5"
+                                        Style="{StaticResource BotaoBase}"
+                                        Command="{Binding DataContext.ReabrirCommand,
+                                                  RelativeSource={RelativeSource AncestorType=UserControl}}"
+                                        CommandParameter="{Binding}" />
+                            </Grid>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </StackPanel>
+        </Border>
+
+        <Grid Grid.Row="4" Margin="0,0,0,10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <Border Grid.Column="0" Background="{StaticResource Superficie}"
+                    BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="6">
+                <Grid>
+                    <TextBox Text="{Binding Busca, UpdateSourceTrigger=PropertyChanged}"
+                             Background="Transparent" BorderThickness="0"
+                             Foreground="{StaticResource Texto}" CaretBrush="{StaticResource Texto}"
+                             Padding="12,8" VerticalContentAlignment="Center"
+                             AutomationProperties.Name="Buscar aplicativo" />
+
+                    <TextBlock Text="Buscar pelo nome..." IsHitTestVisible="False"
+                               Foreground="{StaticResource TextoSecundario}"
+                               Margin="13,0,0,0" VerticalAlignment="Center"
+                               Visibility="{Binding Busca, Converter={StaticResource TextoParaVisibilidade}, ConverterParameter=inverter}" />
+                </Grid>
+            </Border>
+
+            <StackPanel Grid.Column="1" Orientation="Horizontal" Margin="10,0,0,0">
+                <Button Content="Marcar todos" Style="{StaticResource BotaoBase}" Padding="10,7"
+                        Command="{Binding MarcarTodosCommand}" />
+                <Button Content="Limpar" Style="{StaticResource BotaoBase}" Padding="10,7" Margin="6,0,0,0"
+                        Command="{Binding DesmarcarTodosCommand}" />
+            </StackPanel>
+
+            <TextBlock Grid.Column="2" Text="{Binding TextoDoFiltro}" VerticalAlignment="Center"
+                       Margin="12,0,0,0" FontSize="12"
+                       Foreground="{StaticResource TextoSecundario}" />
+        </Grid>
+
+        <Border Grid.Row="5" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                BorderThickness="1" CornerRadius="8">
+            <Grid>
+                <ListBox ItemsSource="{Binding Itens}" Background="Transparent" BorderThickness="0"
+                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                         HorizontalContentAlignment="Stretch" Padding="6"
+                         ItemContainerStyle="{StaticResource ItemDeAcao}"
+                         ItemTemplate="{StaticResource TemplateDeActionItem}" />
+
+                <TextBlock Text="Nada na lista com esse texto."
+                           Foreground="{StaticResource TextoSecundario}"
+                           HorizontalAlignment="Center" VerticalAlignment="Center"
+                           Visibility="{Binding ListaVaziaPorBusca, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                <TextBlock Text="Clique em Varrer para ver o que esta aberto."
+                           Foreground="{StaticResource TextoSecundario}"
+                           HorizontalAlignment="Center" VerticalAlignment="Center"
+                           Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+            </Grid>
+        </Border>
+
+        <!-- Rodape: aqui os botoes sao os do Modo Game, nao o "Aplicar N" generico -->
+        <Border Grid.Row="6" Margin="0,14,0,0" Padding="0,0,0,18">
+            <StackPanel>
+                <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100"
+                             Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                             BorderThickness="0" Margin="0,0,0,10"
+                             Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <Button Grid.Column="0" Content="Varrer" Style="{StaticResource BotaoBase}"
+                            Command="{Binding VarrerCommand}"
+                            IsEnabled="{Binding Ocupado, Converter={StaticResource InverterBool}}" />
+
+                    <Button Grid.Column="1" Margin="8,0,0,0" Content="ATIVAR MODO GAME"
+                            Style="{StaticResource BotaoPrimario}"
+                            Command="{Binding AplicarCommand}" IsEnabled="{Binding PodeAgir}"
+                            Visibility="{Binding ModoGameAtivo, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+
+                    <Button Grid.Column="1" Margin="8,0,0,0" Content="DESLIGAR MODO GAME"
+                            Style="{StaticResource BotaoPrimario}"
+                            Command="{Binding ReverterCommand}" IsEnabled="{Binding PodeAgir}"
+                            Visibility="{Binding ModoGameAtivo, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                    <CheckBox Grid.Column="2" Margin="16,0,0,0" Content="Simular (nao altera nada)"
+                              IsChecked="{Binding DryRun}" VerticalAlignment="Center"
+                              ToolTip="Dry-run: produz o mesmo relatorio sem tocar no sistema." />
+
+                    <Button Grid.Column="4" Content="Reverter tudo" Style="{StaticResource BotaoBase}"
+                            Command="{Binding ReverterTudoCommand}" IsEnabled="{Binding EhAdministrador}"
+                            ToolTip="Desfaz todas as alteracoes de sistema feitas pelo GameBoost." />
+                </Grid>
+
+                <!--
+                  O Resumo e o texto da varredura e nao acompanha o que voce
+                  marca. Sozinho ele dizia "38 apps marcados" com um marcado.
+                  A contagem viva vem do TextoDaSelecao, ao lado.
+                -->
+                <StackPanel Orientation="Horizontal" Margin="0,12,0,0">
+                    <TextBlock Text="{Binding TextoDaSelecao}" FontWeight="SemiBold"
+                               Foreground="{StaticResource Acento}"
+                               Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}}" />
+                    <TextBlock Text="{Binding Resumo}" Margin="10,0,0,0"
+                               Foreground="{StaticResource TextoSecundario}"
+                               Visibility="{Binding Resumo, Converter={StaticResource TextoParaVisibilidade}}" />
+                </StackPanel>
+                <TextBlock Text="{Binding GanhoMedido}" Foreground="{StaticResource Acento}" Margin="0,2,0,0"
+                           Visibility="{Binding GanhoMedido, Converter={StaticResource TextoParaVisibilidade}}" />
+                <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                           FontSize="12" Margin="0,4,0,0" />
+            </StackPanel>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/InicioPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/InicioPage.xaml.cs
new file mode 100644
index 0000000..850f10a
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/InicioPage.xaml.cs
@@ -0,0 +1,12 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class InicioPage : UserControl
+{
+    public InicioPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/JogosPage.xaml b/GameBoost/src/GameBoost.App/Views/JogosPage.xaml
new file mode 100644
index 0000000..c98add0
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/JogosPage.xaml
@@ -0,0 +1,102 @@
+<UserControl x:Class="GameBoost.App.Views.JogosPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!--
+      Pagina Jogos (secoes 5.1 e 5.11): biblioteca dos launchers cruzada com
+      os perfis gravados. Um jogo sem perfil aparece igual aos outros: o
+      perfil nao e obrigatorio para nada.
+    -->
+    <Grid Margin="26,22,26,0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <Grid Grid.Row="0" Margin="0,0,0,14">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+                <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}"
+                           Margin="0,3,12,0" TextWrapping="Wrap" />
+            </StackPanel>
+
+            <Button Grid.Column="1" Content="Varrer" Style="{StaticResource BotaoBase}"
+                    VerticalAlignment="Top"
+                    AutomationProperties.Name="Varrer biblioteca de jogos"
+                    Command="{Binding VarrerCommand}"
+                    IsEnabled="{Binding Ocupado, Converter={StaticResource InverterBool}}" />
+        </Grid>
+
+        <StackPanel Grid.Row="1" Margin="0,0,0,12">
+            <Border Background="{StaticResource Superficie}" CornerRadius="6" Padding="14,10">
+                <TextBlock Text="{Binding Resumo}" FontWeight="SemiBold" TextWrapping="Wrap" />
+            </Border>
+
+            <Border Background="{StaticResource Superficie}" CornerRadius="6" Padding="14,10" Margin="0,8,0,0"
+                    Visibility="{Binding JogoEmExecucao, Converter={StaticResource TextoParaVisibilidade}}">
+                <TextBlock Text="{Binding JogoEmExecucao}" Foreground="{StaticResource Acento}" TextWrapping="Wrap" />
+            </Border>
+        </StackPanel>
+
+        <Border Grid.Row="2" Background="{StaticResource Superficie}"
+                BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="8">
+            <Grid>
+                <ListBox ItemsSource="{Binding Jogos}" SelectedItem="{Binding Selecionado}"
+                         Background="Transparent" BorderThickness="0" Padding="6"
+                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                         HorizontalContentAlignment="Stretch">
+                    <ListBox.ItemTemplate>
+                        <DataTemplate>
+                            <Grid Margin="6,8">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="*" />
+                                    <ColumnDefinition Width="Auto" />
+                                </Grid.ColumnDefinitions>
+
+                                <StackPanel Grid.Column="0">
+                                    <TextBlock Text="{Binding Nome}" FontWeight="SemiBold" />
+                                    <TextBlock Text="{Binding Detalhe}" FontSize="12"
+                                               Foreground="{StaticResource TextoSecundario}"
+                                               TextWrapping="Wrap" />
+                                </StackPanel>
+
+                                <Border Grid.Column="1" Background="{StaticResource Borda}" CornerRadius="3"
+                                        Padding="6,1" VerticalAlignment="Center"
+                                        Visibility="{Binding TemPerfil, Converter={StaticResource BoolParaVisibilidade}}">
+                                    <TextBlock Text="Perfil" FontSize="10"
+                                               Foreground="{StaticResource TextoSecundario}" />
+                                </Border>
+                            </Grid>
+                        </DataTemplate>
+                    </ListBox.ItemTemplate>
+                </ListBox>
+
+                <TextBlock Text="Clique em Varrer para ler a sua biblioteca."
+                           Foreground="{StaticResource TextoSecundario}"
+                           HorizontalAlignment="Center" VerticalAlignment="Center"
+                           Visibility="{Binding ListaVazia, Converter={StaticResource BoolParaVisibilidade}}" />
+            </Grid>
+        </Border>
+
+        <StackPanel Grid.Row="3" Margin="0,12,0,18">
+            <StackPanel Orientation="Horizontal">
+                <Button Content="Criar perfil" Style="{StaticResource BotaoPrimario}"
+                        Command="{Binding CriarPerfilCommand}" />
+                <Button Content="Ativa sozinho" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                        Command="{Binding AlternarAutomaticoCommand}" />
+                <Button Content="Remover perfil" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                        Command="{Binding RemoverPerfilCommand}" />
+            </StackPanel>
+
+            <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                       FontSize="12" Margin="0,10,0,0" TextWrapping="Wrap" MaxHeight="52" />
+        </StackPanel>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/JogosPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/JogosPage.xaml.cs
new file mode 100644
index 0000000..59805b8
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/JogosPage.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class JogosPage : UserControl
+{
+    public JogosPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml b/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml
new file mode 100644
index 0000000..34744a6
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml
@@ -0,0 +1,145 @@
+<UserControl x:Class="GameBoost.App.Views.ModuloPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!--
+      Padrao de pagina de modulo da secao 6, reutilizavel por qualquer IModule:
+      cabecalho com Varrer e resumo, lista generica de ActionItem agrupada por
+      categoria, rodape fixo com "Aplicar N selecionados" e "Reverter".
+    -->
+    <Grid Margin="26,22,26,0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Cabecalho -->
+        <Grid Grid.Row="0" Margin="0,0,0,16">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+                <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,3,12,0" />
+            </StackPanel>
+
+            <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Top">
+                <Button Content="Varrer" Style="{StaticResource BotaoBase}"
+                        Command="{Binding VarrerCommand}"
+                        IsEnabled="{Binding Ocupado, Converter={StaticResource InverterBool}}" />
+                <Button Content="Cancelar" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                        Command="{Binding CancelarCommand}"
+                        Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+            </StackPanel>
+        </Grid>
+
+        <!-- Resumo da varredura -->
+        <Border Grid.Row="1" Background="{StaticResource Superficie}" CornerRadius="6"
+                Padding="14,10" Margin="0,0,0,12"
+                Visibility="{Binding Resumo, Converter={StaticResource TextoParaVisibilidade}}">
+            <StackPanel>
+                <TextBlock Text="{Binding Resumo}" FontWeight="SemiBold" />
+                <TextBlock Text="{Binding GanhoMedido}" Foreground="{StaticResource Acento}" Margin="0,3,0,0"
+                           Visibility="{Binding GanhoMedido, Converter={StaticResource TextoParaVisibilidade}}" />
+            </StackPanel>
+        </Border>
+
+        <!-- Lista generica de ActionItem, agrupada por categoria -->
+        
+        <!-- Busca: entra em toda pagina de modulo pela classe base. -->
+        <Grid Grid.Row="2" Margin="0,0,0,10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <Border Grid.Column="0" Background="{StaticResource Superficie}"
+                    BorderBrush="{StaticResource Borda}" BorderThickness="1" CornerRadius="6">
+                <Grid>
+                    <TextBox Text="{Binding Busca, UpdateSourceTrigger=PropertyChanged}"
+                             Background="Transparent" BorderThickness="0"
+                             Foreground="{StaticResource Texto}" CaretBrush="{StaticResource Texto}"
+                             Padding="12,8" VerticalContentAlignment="Center"
+                             AutomationProperties.Name="Buscar na lista" />
+
+                    <TextBlock Text="Buscar pelo nome..." IsHitTestVisible="False"
+                               Foreground="{StaticResource TextoSecundario}"
+                               Margin="13,0,0,0" VerticalAlignment="Center"
+                               Visibility="{Binding Busca, Converter={StaticResource TextoParaVisibilidade}, ConverterParameter=inverter}" />
+                </Grid>
+            </Border>
+
+            <TextBlock Grid.Column="1" Text="{Binding TextoDoFiltro}" VerticalAlignment="Center"
+                       Margin="12,0,0,0" FontSize="12"
+                       Foreground="{StaticResource TextoSecundario}" />
+        </Grid>
+
+        <Border Grid.Row="3" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                BorderThickness="1" CornerRadius="8">
+            <Grid>
+                <ListBox ItemsSource="{Binding Itens}" Background="Transparent" BorderThickness="0"
+                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                         HorizontalContentAlignment="Stretch" Padding="6"
+                         ItemContainerStyle="{StaticResource ItemDeAcao}"
+                         ItemTemplate="{StaticResource TemplateDeActionItem}" />
+
+                <!-- Estado vazio: antes da primeira varredura -->
+                <TextBlock Text="Nada na lista com esse texto."
+                           Foreground="{StaticResource TextoSecundario}"
+                           HorizontalAlignment="Center" VerticalAlignment="Center"
+                           Visibility="{Binding ListaVaziaPorBusca, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                <TextBlock Text="Clique em Varrer para ver o que pode ser feito."
+                           Foreground="{StaticResource TextoSecundario}"
+                           HorizontalAlignment="Center" VerticalAlignment="Center"
+                           Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+            </Grid>
+        </Border>
+
+        <!-- Rodape fixo -->
+        <Border Grid.Row="4" Margin="0,14,0,0" Padding="0,0,0,18">
+            <StackPanel>
+                <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100"
+                             Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                             BorderThickness="0" Margin="0,0,0,10"
+                             Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <Button Grid.Column="0" Content="{Binding TextoAplicar}"
+                            Style="{StaticResource BotaoPrimario}"
+                            Command="{Binding AplicarCommand}" IsEnabled="{Binding PodeAgir}" />
+
+                    <Button Grid.Column="1" Content="Reverter" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                            Command="{Binding ReverterCommand}" IsEnabled="{Binding PodeAgir}" />
+
+                    <StackPanel Grid.Column="2" Orientation="Horizontal" Margin="16,0,0,0" VerticalAlignment="Center">
+                        <Button Content="Marcar todos" Style="{StaticResource BotaoBase}" Padding="10,6"
+                                Command="{Binding MarcarTodosCommand}" />
+                        <Button Content="Limpar" Style="{StaticResource BotaoBase}" Padding="10,6" Margin="6,0,0,0"
+                                Command="{Binding DesmarcarTodosCommand}" />
+                    </StackPanel>
+
+                    <CheckBox Grid.Column="4" Content="Simular (nao altera nada)" IsChecked="{Binding DryRun}"
+                              VerticalAlignment="Center"
+                              ToolTip="Dry-run: produz o mesmo relatorio sem tocar no sistema." />
+                </Grid>
+
+                <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                           FontSize="12" Margin="0,10,0,0" />
+            </StackPanel>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml.cs
new file mode 100644
index 0000000..676d192
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ModuloPage.xaml.cs
@@ -0,0 +1,12 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class ModuloPage : UserControl
+{
+    public ModuloPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml b/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml
new file mode 100644
index 0000000..836c0bb
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml
@@ -0,0 +1,65 @@
+<Window x:Class="GameBoost.App.Views.OnboardingWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="Bem-vindo ao GameBoost"
+        Height="480" Width="620"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="NoResize"
+        ShowInTaskbar="False"
+        Background="{StaticResource Fundo}"
+        Foreground="{StaticResource Texto}">
+
+    <!--
+      Onboarding da secao 6: tres telas dizendo o contrato, nao vendendo FPS.
+      Reversivel, sem telemetria, e o que faz diferenca de verdade.
+    -->
+    <Grid Margin="32,28,32,24">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Grid.Row="0" Margin="0,0,0,18">
+            <TextBlock Text="{Binding Passo}" FontSize="12"
+                       Foreground="{StaticResource TextoSecundario}" />
+            <TextBlock Text="{Binding Atual.Titulo}" FontSize="24" FontWeight="Bold"
+                       TextWrapping="Wrap" Margin="0,6,0,0" />
+        </StackPanel>
+
+        <TextBlock Grid.Row="1" Text="{Binding Atual.Texto}" TextWrapping="Wrap"
+                   FontSize="14" LineHeight="22"
+                   Foreground="{StaticResource TextoSecundario}" />
+
+        <StackPanel Grid.Row="2" Margin="0,16,0,18">
+            <TextBlock Text="{Binding Atual.Rodape}" FontStyle="Italic"
+                       Foreground="{StaticResource Acento}" />
+
+            <CheckBox Margin="0,14,0,0"
+                      Content="Rodar o relatório de saúde depois de fechar"
+                      IsChecked="{Binding AbrirRelatorio}"
+                      Visibility="{Binding EhUltima, Converter={StaticResource BoolParaVisibilidade}}" />
+        </StackPanel>
+
+        <Grid Grid.Row="3">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <Button Grid.Column="0" Content="Pular" Style="{StaticResource BotaoBase}"
+                    Command="{Binding PularCommand}" />
+
+            <Button Grid.Column="2" Content="Voltar" Style="{StaticResource BotaoBase}" Margin="0,0,8,0"
+                    Command="{Binding VoltarCommand}"
+                    IsEnabled="{Binding EhPrimeira, Converter={StaticResource InverterBool}}" />
+
+            <Button Grid.Column="3" Content="{Binding TextoDoAvancar}"
+                    Style="{StaticResource BotaoPrimario}"
+                    Command="{Binding AvancarCommand}" />
+        </Grid>
+    </Grid>
+</Window>
diff --git a/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml.cs b/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml.cs
new file mode 100644
index 0000000..5bee42c
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/OnboardingWindow.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows;
+
+namespace GameBoost.App.Views;
+
+public partial class OnboardingWindow : Window
+{
+    public OnboardingWindow()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml b/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml
new file mode 100644
index 0000000..5403d03
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml
@@ -0,0 +1,58 @@
+<UserControl x:Class="GameBoost.App.Views.PlaceholderPage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!-- Pagina de modulo que ainda nao existe: diz o que vai fazer e quando chega. -->
+    <Grid Margin="26,22,26,26">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+
+        <StackPanel Grid.Row="0" Margin="0,0,0,18">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" VerticalAlignment="Center" />
+                <Border Background="{StaticResource SuperficieAlta}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="12" Padding="10,3" Margin="12,0,0,0"
+                        VerticalAlignment="Center">
+                    <TextBlock Text="{Binding AvisoDeFase}" FontSize="11"
+                               Foreground="{StaticResource RiscoMedio}" FontWeight="SemiBold" />
+                </Border>
+            </StackPanel>
+            <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}" Margin="0,5,0,0" />
+        </StackPanel>
+
+        <Border Grid.Row="1" Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                BorderThickness="1" CornerRadius="8" Padding="24,20" VerticalAlignment="Top">
+            <StackPanel>
+                <TextBlock Text="O que esta pagina vai fazer" FontWeight="SemiBold" Margin="0,0,0,12" />
+
+                <ItemsControl ItemsSource="{Binding OQueVaiFazer}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <Grid Margin="0,0,0,9">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="Auto" />
+                                    <ColumnDefinition Width="*" />
+                                </Grid.ColumnDefinitions>
+                                <Ellipse Grid.Column="0" Width="5" Height="5" Margin="2,7,12,0"
+                                         Fill="{StaticResource Acento}" VerticalAlignment="Top" />
+                                <TextBlock Grid.Column="1" Text="{Binding}"
+                                           Foreground="{StaticResource TextoSecundario}" />
+                            </Grid>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+
+                <Border Background="{StaticResource SuperficieAlta}" CornerRadius="6" Padding="14,11" Margin="0,16,0,0">
+                    <StackPanel>
+                        <TextBlock Text="Nada aqui ainda altera o seu sistema."
+                                   Foreground="{StaticResource TextoSecundario}" FontSize="12" />
+                        <TextBlock Text="{Binding Referencia}"
+                                   Foreground="{StaticResource TextoDesabilitado}" FontSize="11" Margin="0,4,0,0" />
+                    </StackPanel>
+                </Border>
+            </StackPanel>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml.cs b/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml.cs
new file mode 100644
index 0000000..777e494
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/PlaceholderPage.xaml.cs
@@ -0,0 +1,12 @@
+using System.Windows;
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class PlaceholderPage : UserControl
+{
+    public PlaceholderPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/RedePage.xaml b/GameBoost/src/GameBoost.App/Views/RedePage.xaml
new file mode 100644
index 0000000..6ab5164
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/RedePage.xaml
@@ -0,0 +1,261 @@
+<UserControl x:Class="GameBoost.App.Views.RedePage"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <!--
+      Pagina de rede (secao 5.9), nos tres blocos que o spec descreve:
+      "Velocidade", "Posso jogar online?" (semaforo grande + causas) e
+      "Ajustes". A ordem importa: quem abre esta tela veio por causa da
+      segunda pergunta, entao ela fica no topo.
+    -->
+    <Grid Margin="26,22,26,0">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Cabecalho -->
+        <Grid Grid.Row="0" Margin="0,0,0,14">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0">
+                <TextBlock Text="{Binding Titulo}" FontSize="22" FontWeight="Bold" />
+                <TextBlock Text="{Binding Subtitulo}" Foreground="{StaticResource TextoSecundario}"
+                           Margin="0,3,12,0" TextWrapping="Wrap" />
+            </StackPanel>
+
+            <StackPanel Grid.Column="1" Orientation="Horizontal" VerticalAlignment="Top">
+                <Button Content="Medir" Style="{StaticResource BotaoBase}"
+                        AutomationProperties.Name="Medir a rede"
+                        Command="{Binding VarrerCommand}"
+                        IsEnabled="{Binding Ocupado, Converter={StaticResource InverterBool}}" />
+                <Button Content="Cancelar" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                        Command="{Binding CancelarCommand}"
+                        Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+            </StackPanel>
+        </Grid>
+
+        <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto"
+                      HorizontalScrollBarVisibility="Disabled">
+            <StackPanel>
+
+                <!-- ===== Posso jogar online? ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,12"
+                        Visibility="{Binding TemNat, Converter={StaticResource BoolParaVisibilidade}}">
+                    <StackPanel>
+                        <TextBlock Text="Posso jogar online?" FontWeight="SemiBold" Margin="0,0,0,10" />
+
+                        <StackPanel Orientation="Horizontal" Margin="0,0,0,8">
+                            <Ellipse Width="18" Height="18" VerticalAlignment="Center"
+                                     Fill="{Binding NatSemaforo, Converter={StaticResource SemaforoParaCor}}" />
+                            <TextBlock Text="{Binding Nat}" FontSize="20" FontWeight="Bold"
+                                       Margin="10,0,0,0" VerticalAlignment="Center" />
+                        </StackPanel>
+
+                        <TextBlock Text="{Binding NatExplicacao}" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}" Margin="0,0,0,10" />
+
+                        <ItemsControl ItemsSource="{Binding Causas}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <TextBlock Text="{Binding}" TextWrapping="Wrap" Margin="0,3"
+                                               Foreground="{StaticResource Texto}" />
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <TextBlock Margin="0,10,0,0" FontSize="12" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   Text="As portas de cada jogo e o passo a passo por marca de roteador estão em docs/PORTAS.md. O GameBoost corrige o que é do Windows e não mexe no seu roteador." />
+                    </StackPanel>
+                </Border>
+
+                <!-- ===== Velocidade ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,12">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+
+                        <StackPanel Grid.Column="0">
+                            <TextBlock Text="Velocidade" FontWeight="SemiBold" Margin="0,0,0,6" />
+                            <TextBlock Text="{Binding Velocidade}" TextWrapping="Wrap"
+                                       Foreground="{StaticResource TextoSecundario}" />
+                        </StackPanel>
+
+                        <Button Grid.Column="1" VerticalAlignment="Center" Margin="12,0,0,0"
+                                Content="{Binding TextoDoBotaoDeVelocidade}"
+                                Style="{StaticResource BotaoBase}"
+                                Command="{Binding TestarVelocidadeCommand}"
+                                IsEnabled="{Binding MedindoVelocidade, Converter={StaticResource InverterBool}}" />
+                    </Grid>
+                </Border>
+
+                <!-- ===== Latencia ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,12"
+                        Visibility="{Binding TemMedicao, Converter={StaticResource BoolParaVisibilidade}}">
+                    <StackPanel>
+                        <TextBlock Text="Latência" FontWeight="SemiBold" Margin="0,0,0,8" />
+
+                        <ItemsControl ItemsSource="{Binding Pings}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <Grid Margin="0,3">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="*" />
+                                            <ColumnDefinition Width="90" />
+                                            <ColumnDefinition Width="90" />
+                                            <ColumnDefinition Width="70" />
+                                            <ColumnDefinition Width="Auto" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <TextBlock Grid.Column="0" Text="{Binding Alvo}" TextTrimming="CharacterEllipsis" />
+                                        <TextBlock Grid.Column="1" Text="{Binding Latencia}" FontWeight="SemiBold" />
+                                        <TextBlock Grid.Column="2" Text="{Binding Jitter}"
+                                                   Foreground="{StaticResource TextoSecundario}" />
+                                        <TextBlock Grid.Column="3" Text="{Binding Perda}"
+                                                   Foreground="{StaticResource TextoSecundario}" />
+                                        <TextBlock Grid.Column="4" Text="{Binding Leitura}"
+                                                   Foreground="{StaticResource Acento}" />
+                                    </Grid>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <TextBlock Text="{Binding Wifi}" Margin="0,8,0,0" TextWrapping="Wrap"
+                                   Foreground="{StaticResource Acento}"
+                                   Visibility="{Binding Wifi, Converter={StaticResource TextoParaVisibilidade}}" />
+
+                        <TextBlock Margin="0,8,0,0" FontSize="12" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   Text="Jitter é a variação entre um pacote e o seguinte. É ele, e não a média, que causa a sensação de travada no jogo." />
+                    </StackPanel>
+                </Border>
+
+                <!-- ===== DNS ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,12"
+                        Visibility="{Binding TemMedicao, Converter={StaticResource BoolParaVisibilidade}}">
+                    <StackPanel>
+                        <TextBlock Text="Servidores de DNS" FontWeight="SemiBold" Margin="0,0,0,8" />
+
+                        <ItemsControl ItemsSource="{Binding Dns}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <Grid Margin="0,3">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="160" />
+                                            <ColumnDefinition Width="130" />
+                                            <ColumnDefinition Width="90" />
+                                            <ColumnDefinition Width="*" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <TextBlock Grid.Column="0" Text="{Binding Nome}"
+                                                   FontWeight="{Binding EmUso, Converter={StaticResource BoolParaPeso}}" />
+                                        <TextBlock Grid.Column="1" Text="{Binding Endereco}"
+                                                   Foreground="{StaticResource TextoSecundario}" />
+                                        <TextBlock Grid.Column="2" Text="{Binding Tempo}" FontWeight="SemiBold" />
+                                        <TextBlock Grid.Column="3" Text="{Binding Comparacao}"
+                                                   Foreground="{StaticResource TextoSecundario}"
+                                                   TextTrimming="CharacterEllipsis" />
+                                    </Grid>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <TextBlock Margin="0,8,0,0" FontSize="12" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   Text="DNS rápido faz página abrir mais rápido. Não muda o ping do jogo: o jogo resolve o nome uma vez e depois fala direto com o servidor." />
+                    </StackPanel>
+                </Border>
+
+                <!-- ===== Quem esta conectado ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" Padding="16,14" Margin="0,0,0,12"
+                        Visibility="{Binding TemMedicao, Converter={StaticResource BoolParaVisibilidade}}">
+                    <StackPanel>
+                        <TextBlock Text="Quem está falando com a internet agora" FontWeight="SemiBold" Margin="0,0,0,8" />
+
+                        <ItemsControl ItemsSource="{Binding Conexoes}">
+                            <ItemsControl.ItemTemplate>
+                                <DataTemplate>
+                                    <Grid Margin="0,3">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="*" />
+                                            <ColumnDefinition Width="110" />
+                                            <ColumnDefinition Width="150" />
+                                        </Grid.ColumnDefinitions>
+
+                                        <TextBlock Grid.Column="0" Text="{Binding Processo}" TextTrimming="CharacterEllipsis" />
+                                        <TextBlock Grid.Column="1" Text="{Binding Conexoes}" />
+                                        <TextBlock Grid.Column="2" Text="{Binding Destino}"
+                                                   Foreground="{StaticResource TextoSecundario}" />
+                                    </Grid>
+                                </DataTemplate>
+                            </ItemsControl.ItemTemplate>
+                        </ItemsControl>
+
+                        <TextBlock Margin="0,8,0,0" FontSize="12" TextWrapping="Wrap"
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   Text="São conexões abertas, não velocidade. Medir banda por processo exigiria um coletor de eventos rodando o tempo todo, e isso custaria mais CPU do que o problema vale." />
+                    </StackPanel>
+                </Border>
+
+                <!-- ===== Ajustes ===== -->
+                <Border Background="{StaticResource Superficie}" BorderBrush="{StaticResource Borda}"
+                        BorderThickness="1" CornerRadius="8" MinHeight="120">
+                    <Grid>
+                        <ItemsControl ItemsSource="{Binding Itens}" Padding="6"
+                                      ItemTemplate="{StaticResource TemplateDeActionItem}" />
+
+                        <TextBlock Text="Clique em Medir para ver a sua rede."
+                                   Foreground="{StaticResource TextoSecundario}"
+                                   HorizontalAlignment="Center" VerticalAlignment="Center"
+                                   Visibility="{Binding JaVarreu, Converter={StaticResource BoolParaVisibilidade}, ConverterParameter=inverter}" />
+                    </Grid>
+                </Border>
+            </StackPanel>
+        </ScrollViewer>
+
+        <!-- Rodape fixo -->
+        <Border Grid.Row="2" Margin="0,14,0,0" Padding="0,0,0,18">
+            <StackPanel>
+                <ProgressBar Height="3" Value="{Binding Progresso}" Maximum="100"
+                             Background="{StaticResource Superficie}" Foreground="{StaticResource Acento}"
+                             BorderThickness="0" Margin="0,0,0,10"
+                             Visibility="{Binding Ocupado, Converter={StaticResource BoolParaVisibilidade}}" />
+
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="Auto" />
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <Button Grid.Column="0" Content="{Binding TextoAplicar}"
+                            Style="{StaticResource BotaoPrimario}"
+                            Command="{Binding AplicarCommand}" IsEnabled="{Binding PodeAgir}" />
+
+                    <Button Grid.Column="1" Content="Reverter" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                            Command="{Binding ReverterCommand}" IsEnabled="{Binding PodeAgir}" />
+
+                    <CheckBox Grid.Column="3" Content="Simular (nao altera nada)" IsChecked="{Binding DryRun}"
+                              VerticalAlignment="Center"
+                              ToolTip="Dry-run: produz o mesmo relatorio sem tocar no sistema." />
+                </Grid>
+
+                <TextBlock Text="{Binding Status}" Foreground="{StaticResource TextoSecundario}"
+                           FontSize="12" Margin="0,10,0,0" TextWrapping="Wrap" MaxHeight="52" />
+            </StackPanel>
+        </Border>
+    </Grid>
+</UserControl>
diff --git a/GameBoost/src/GameBoost.App/Views/RedePage.xaml.cs b/GameBoost/src/GameBoost.App/Views/RedePage.xaml.cs
new file mode 100644
index 0000000..0ec390c
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/RedePage.xaml.cs
@@ -0,0 +1,11 @@
+using System.Windows.Controls;
+
+namespace GameBoost.App.Views;
+
+public partial class RedePage : UserControl
+{
+    public RedePage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml b/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml
new file mode 100644
index 0000000..9a88b95
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml
@@ -0,0 +1,141 @@
+<Window x:Class="GameBoost.App.Views.ShellWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="GameBoost"
+        Height="760" Width="1180"
+        MinHeight="600" MinWidth="900"
+        WindowStartupLocation="CenterScreen"
+        Background="{StaticResource Fundo}"
+        TextOptions.TextFormattingMode="Display">
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="212" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+
+        <!-- Navegacao lateral -->
+        <Border Grid.Column="0" Background="{StaticResource Superficie}"
+                BorderBrush="{StaticResource Borda}" BorderThickness="0,0,1,0">
+            <DockPanel>
+                <StackPanel DockPanel.Dock="Top" Margin="20,22,20,18">
+                    <TextBlock Text="GameBoost" FontSize="19" FontWeight="Bold" />
+                    <TextBlock Text="Mostra o que faz e desfaz tudo."
+                               Foreground="{StaticResource TextoSecundario}" FontSize="11" Margin="0,2,0,0" />
+                </StackPanel>
+
+                <Border DockPanel.Dock="Bottom" Margin="14,10,14,14" Padding="10,8"
+                        Background="{StaticResource SuperficieAlta}" CornerRadius="6">
+                    <TextBlock Text="{Binding AvisoDePrivilegio}" FontSize="11"
+                               Foreground="{StaticResource TextoSecundario}" />
+                </Border>
+
+                <ListBox ItemsSource="{Binding Paginas}"
+                         SelectedItem="{Binding PaginaAtual, Mode=TwoWay}"
+                         Background="Transparent" BorderThickness="0"
+                         HorizontalContentAlignment="Stretch"
+                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                         Padding="8,0">
+                    <ListBox.ItemContainerStyle>
+                        <Style TargetType="ListBoxItem">
+                            <Setter Property="Padding" Value="0" />
+                            <Setter Property="Margin" Value="0,1" />
+                            <!-- Sem isto o leitor de tela anuncia o nome da classe do ViewModel. -->
+                            <Setter Property="AutomationProperties.Name" Value="{Binding Nome}" />
+                            <Setter Property="AutomationProperties.HelpText" Value="{Binding Subtitulo}" />
+                            <Setter Property="Template">
+                                <Setter.Value>
+                                    <ControlTemplate TargetType="ListBoxItem">
+                                        <Border x:Name="Caixa" Background="Transparent" CornerRadius="6" Padding="10,9">
+                                            <Grid>
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="Auto" />
+                                                    <ColumnDefinition Width="*" />
+                                                    <ColumnDefinition Width="Auto" />
+                                                </Grid.ColumnDefinitions>
+
+                                                <TextBlock x:Name="Glifo" Grid.Column="0"
+                                                           Text="{Binding Icone}"
+                                                           FontFamily="Segoe Fluent Icons, Segoe MDL2 Assets"
+                                                           FontSize="15" Width="22"
+                                                           Foreground="{StaticResource TextoSecundario}"
+                                                           VerticalAlignment="Center" />
+
+                                                <TextBlock x:Name="Rotulo" Grid.Column="1"
+                                                           Text="{Binding Nome}" VerticalAlignment="Center"
+                                                           Foreground="{StaticResource Texto}" />
+
+                                                <!-- Marca discreta nas paginas que ainda nao existem -->
+                                                <Ellipse x:Name="Ponto" Grid.Column="2" Width="6" Height="6"
+                                                         Fill="{StaticResource TextoDesabilitado}"
+                                                         VerticalAlignment="Center" Margin="6,0,2,0"
+                                                         Visibility="Collapsed" />
+                                            </Grid>
+                                        </Border>
+                                        <ControlTemplate.Triggers>
+                                            <DataTrigger Binding="{Binding Implementada}" Value="False">
+                                                <Setter TargetName="Rotulo" Property="Foreground" Value="{StaticResource TextoSecundario}" />
+                                                <Setter TargetName="Ponto" Property="Visibility" Value="Visible" />
+                                            </DataTrigger>
+                                            <Trigger Property="IsMouseOver" Value="True">
+                                                <Setter TargetName="Caixa" Property="Background" Value="{StaticResource SuperficieAlta}" />
+                                            </Trigger>
+                                            <Trigger Property="IsSelected" Value="True">
+                                                <Setter TargetName="Caixa" Property="Background" Value="{StaticResource SuperficieAlta}" />
+                                                <Setter TargetName="Glifo" Property="Foreground" Value="{StaticResource Acento}" />
+                                                <Setter TargetName="Rotulo" Property="Foreground" Value="{StaticResource Texto}" />
+                                                <Setter TargetName="Rotulo" Property="FontWeight" Value="SemiBold" />
+                                            </Trigger>
+                                        </ControlTemplate.Triggers>
+                                    </ControlTemplate>
+                                </Setter.Value>
+                            </Setter>
+                        </Style>
+                    </ListBox.ItemContainerStyle>
+                </ListBox>
+            </DockPanel>
+        </Border>
+
+        <Grid Grid.Column="1">
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="*" />
+            </Grid.RowDefinitions>
+
+            <!--
+              Convite da deteccao automatica (secao 5.1). Fica acima da pagina,
+              sobre qualquer tela: quem esta no meio de outra coisa precisa ver
+              que um jogo foi detectado sem ter de procurar.
+
+              Existe junto com o balao da bandeja, nao no lugar dele. Com o jogo
+              em tela cheia o Windows engole o balao, e a faixa fica esperando
+              na janela para quando a pessoa voltar.
+            -->
+            <Border Grid.Row="0" Background="#332EC49A" BorderBrush="{StaticResource Acento}"
+                    BorderThickness="1" CornerRadius="6" Padding="14,10" Margin="26,18,26,0"
+                    Visibility="{Binding Convite, Converter={StaticResource TextoParaVisibilidade}}">
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*" />
+                        <ColumnDefinition Width="Auto" />
+                    </Grid.ColumnDefinitions>
+
+                    <TextBlock Grid.Column="0" Text="{Binding Convite}" TextWrapping="Wrap"
+                               VerticalAlignment="Center" FontWeight="SemiBold" />
+
+                    <StackPanel Grid.Column="1" Orientation="Horizontal" Margin="12,0,0,0">
+                        <Button Content="Ativar Modo Game" Style="{StaticResource BotaoPrimario}"
+                                AutomationProperties.Name="Ativar Modo Game para o jogo detectado"
+                                Command="{Binding AceitarConviteCommand}" />
+                        <Button Content="Agora nao" Style="{StaticResource BotaoBase}" Margin="8,0,0,0"
+                                Command="{Binding RecusarConviteCommand}" />
+                    </StackPanel>
+                </Grid>
+            </Border>
+
+
+            <!-- Pagina atual: o DataTemplate certo vem do App.xaml -->
+            <ContentControl Grid.Row="1" Content="{Binding PaginaAtual}" Margin="0" />
+        </Grid>
+    </Grid>
+</Window>
diff --git a/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml.cs b/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml.cs
new file mode 100644
index 0000000..a6829ee
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/Views/ShellWindow.xaml.cs
@@ -0,0 +1,49 @@
+using System.ComponentModel;
+using System.Windows;
+
+namespace GameBoost.App.Views;
+
+public partial class ShellWindow : Window
+{
+    public ShellWindow()
+    {
+        InitializeComponent();
+    }
+
+    /// <summary>
+    /// Bandeja ligada, quando existe. Com ela, fechar a janela esconde em vez
+    /// de sair.
+    /// </summary>
+    public Services.BandejaDoSistema? Bandeja { get; set; }
+
+    /// <summary>
+    /// Fechar pelo X esconde para a bandeja, mas **só quando a bandeja está
+    /// visível**: se ela não estiver, o X fecha de verdade, senão o app viraria
+    /// um processo que não dá para encerrar pela interface.
+    ///
+    /// O aviso aparece uma vez. Programa que some sem dizer para onde foi é o
+    /// motivo de as pessoas irem no Gerenciador de Tarefas.
+    /// </summary>
+    protected override void OnClosing(CancelEventArgs e)
+    {
+        if (App.Current is App app && app.EsconderEmVezDeFechar)
+        {
+            e.Cancel = true;
+            Hide();
+
+            if (!_jaAvisou)
+            {
+                _jaAvisou = true;
+                Bandeja?.Avisar("GameBoost continua aberto",
+                    "Ele fica na bandeja, ao lado do relógio. Para sair de vez, clique com o "
+                  + "botão direito no ícone e escolha Sair.");
+            }
+
+            return;
+        }
+
+        base.OnClosing(e);
+    }
+
+    private bool _jaAvisou;
+}
diff --git a/GameBoost/src/GameBoost.App/app-dev.manifest b/GameBoost/src/GameBoost.App/app-dev.manifest
new file mode 100644
index 0000000..249928c
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/app-dev.manifest
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <!--
+    Manifesto de DESENVOLVIMENTO. Igual ao app.manifest, menos a elevacao:
+    aqui o nivel e asInvoker, entao o exe abre sem UAC e cai no modo somente
+    leitura (varreduras funcionam, acoes ficam desabilitadas).
+
+    Serve para rodar e inspecionar a UI numa sessao comum. Nunca vai para
+    Release: o alvo ConferirElevacaoNoRelease do csproj falha se alguem tentar.
+
+    CUIDADO: o parser de manifesto do Windows rejeita o arquivo inteiro se um
+    comentario contiver dois hifens seguidos, e o erro aparece so em tempo de
+    execucao, como "configuracao lado a lado incorreta". Por isso os nomes dos
+    parametros de linha de comando nao sao citados aqui.
+  -->
+  <assemblyIdentity version="2.0.0.0" name="GameBoost.app" />
+
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2</dpiAwareness>
+      <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/GameBoost/src/GameBoost.App/app.manifest b/GameBoost/src/GameBoost.App/app.manifest
new file mode 100644
index 0000000..ab9cd45
--- /dev/null
+++ b/GameBoost/src/GameBoost.App/app.manifest
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="2.0.0.0" name="GameBoost.app" />
+
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <!-- Encerrar processos, controlar servicos e purgar a Standby List exigem elevacao. -->
+        <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /><!-- Windows 10 e 11 -->
+    </application>
+  </compatibility>
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2</dpiAwareness>
+      <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/GameBoost/src/GameBoost.Cli/CommandLineOptions.cs b/GameBoost/src/GameBoost.Cli/CommandLineOptions.cs
new file mode 100644
index 0000000..a34ca29
--- /dev/null
+++ b/GameBoost/src/GameBoost.Cli/CommandLineOptions.cs
@@ -0,0 +1,148 @@
+namespace GameBoost.Cli;
+
+public enum CliCommand
+{
+    None,
+    Scan,
+    Report,
+    Clean,
+    RevertAll,
+    GameModeOn,
+    GameModeOff,
+    Help
+}
+
+/// <summary>
+/// Parser dos argumentos da secao 8 do spec. Sem dependencia externa: um
+/// parser de 80 linhas custa menos que arrastar System.CommandLine para um
+/// publish single-file.
+/// </summary>
+public sealed class CommandLineOptions
+{
+    public CliCommand Comando { get; private set; } = CliCommand.None;
+    public string? ArquivoDeSaida { get; private set; }
+    public string? Preset { get; private set; }
+    public IReadOnlyList<string> Categorias { get; private set; } = Array.Empty<string>();
+
+    /// <summary>Combina com qualquer comando: produz o mesmo relatorio sem tocar em nada.</summary>
+    public bool DryRun { get; private set; }
+
+    public bool Json { get; private set; }
+    public string? Erro { get; private set; }
+
+    public bool EhCli => Comando != CliCommand.None;
+
+    public static CommandLineOptions Parse(string[] args)
+    {
+        var o = new CommandLineOptions();
+        if (args.Length == 0)
+            return o;
+
+        for (var i = 0; i < args.Length; i++)
+        {
+            var arg = args[i];
+            var proximo = i + 1 < args.Length ? args[i + 1] : null;
+            var proximoEhValor = proximo is not null && !proximo.StartsWith("--", StringComparison.Ordinal);
+
+            switch (arg.ToLowerInvariant())
+            {
+                case "--scan":
+                    o.Comando = CliCommand.Scan;
+                    if (proximoEhValor) { o.ArquivoDeSaida = proximo; i++; }
+                    break;
+
+                case "--report":
+                    o.Comando = CliCommand.Report;
+                    if (proximoEhValor) { o.ArquivoDeSaida = proximo; i++; }
+                    break;
+
+                case "--clean":
+                    o.Comando = CliCommand.Clean;
+                    break;
+
+                case "--revert-all":
+                    o.Comando = CliCommand.RevertAll;
+                    break;
+
+                case "--gamemode":
+                    if (!proximoEhValor)
+                    {
+                        o.Erro = "--gamemode exige on ou off.";
+                        return o;
+                    }
+
+                    o.Comando = proximo!.ToLowerInvariant() switch
+                    {
+                        "on" => CliCommand.GameModeOn,
+                        "off" => CliCommand.GameModeOff,
+                        _ => CliCommand.None
+                    };
+
+                    if (o.Comando == CliCommand.None)
+                        o.Erro = $"Valor invalido para --gamemode: {proximo}. Use on ou off.";
+
+                    i++;
+                    break;
+
+                case "--preset":
+                    if (proximoEhValor) { o.Preset = proximo!.ToLowerInvariant(); i++; }
+                    else o.Erro = "--preset exige um valor (seguro ou completo).";
+                    break;
+
+                case "--categorias":
+                    if (proximoEhValor)
+                    {
+                        o.Categorias = proximo!.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                        i++;
+                    }
+                    else
+                    {
+                        o.Erro = "--categorias exige a lista separada por virgula.";
+                    }
+                    break;
+
+                case "--dry-run":
+                    o.DryRun = true;
+                    break;
+
+                case "--json":
+                    o.Json = true;
+                    break;
+
+                case "--help":
+                case "-h":
+                case "/?":
+                    o.Comando = CliCommand.Help;
+                    break;
+
+                default:
+                    if (arg.StartsWith("--", StringComparison.Ordinal))
+                        o.Erro = $"Argumento desconhecido: {arg}";
+                    break;
+            }
+        }
+
+        if (o.Preset is not null && o.Preset is not ("seguro" or "completo"))
+            o.Erro = $"Preset invalido: {o.Preset}. Use seguro ou completo.";
+
+        return o;
+    }
+
+    public static string TextoDeAjuda => """
+        GameBoost - central de otimizacao e manutencao do PC gamer
+
+        Uso:
+          GameBoost.exe                          abre a interface grafica
+          GameBoost.exe --scan [arquivo]         relatorio de varredura do Modo Game
+          GameBoost.exe --report saida.html      relatorio de saude completo
+          GameBoost.exe --clean --preset seguro  limpeza com preset (seguro | completo)
+          GameBoost.exe --clean --categorias temp,wu,wer
+          GameBoost.exe --revert-all             reverte tudo do state-backup
+          GameBoost.exe --gamemode on|off        liga ou desliga o Modo Game
+
+        Modificadores:
+          --dry-run    combina com qualquer comando, nao altera nada
+          --json       saida em JSON em vez de texto
+          --help       esta ajuda
+        """;
+}
diff --git a/GameBoost/src/GameBoost.Cli/CommandRunner.cs b/GameBoost/src/GameBoost.Cli/CommandRunner.cs
new file mode 100644
index 0000000..b15f150
--- /dev/null
+++ b/GameBoost/src/GameBoost.Cli/CommandRunner.cs
@@ -0,0 +1,348 @@
+using System.Text;
+using System.Text.Json;
+using GameBoost.Core;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.Cleaner;
+using GameBoost.Core.Modules.HealthReport;
+using GameBoost.Core.State;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GameBoost.Cli;
+
+/// <summary>
+/// Executa os comandos de linha. Vive numa biblioteca para que o mesmo
+/// GameBoost.exe atenda a UI e a CLI, como na v1 (--scan sem instalar nada a parte).
+/// </summary>
+public sealed class CommandRunner
+{
+    private readonly IServiceProvider _services;
+    private readonly TextWriter _saida;
+
+    public CommandRunner(IServiceProvider services, TextWriter saida)
+    {
+        _services = services;
+        _saida = saida;
+    }
+
+    public async Task<int> ExecutarAsync(CommandLineOptions opcoes, CancellationToken ct = default)
+    {
+        if (opcoes.Erro is not null)
+        {
+            _saida.WriteLine($"Erro: {opcoes.Erro}");
+            _saida.WriteLine();
+            _saida.WriteLine(CommandLineOptions.TextoDeAjuda);
+            return 2;
+        }
+
+        return opcoes.Comando switch
+        {
+            CliCommand.Help => Ajuda(),
+            CliCommand.Scan => await ScanAsync(opcoes, ct),
+            CliCommand.GameModeOn => await GameModeAsync(opcoes, ligar: true, ct),
+            CliCommand.GameModeOff => await GameModeAsync(opcoes, ligar: false, ct),
+            CliCommand.RevertAll => ReverterTudo(opcoes),
+            CliCommand.Report => await ReportAsync(opcoes, ct),
+            CliCommand.Clean => await CleanAsync(opcoes, ct),
+            _ => Ajuda()
+        };
+    }
+
+    private int Ajuda()
+    {
+        _saida.WriteLine(CommandLineOptions.TextoDeAjuda);
+        return 0;
+    }
+
+    private int NaoImplementado(string comando, string fase)
+    {
+        _saida.WriteLine($"{comando} ainda nao esta disponivel. Chega na {fase}.");
+        return 3;
+    }
+
+    /// <summary>
+    /// Presets da secao 8. "seguro" leva so o que o catalogo ja marca por
+    /// padrao; "completo" leva tudo que nao esta bloqueado, e por isso avisa
+    /// antes do que esta levando junto.
+    /// </summary>
+    private async Task<int> CleanAsync(CommandLineOptions opcoes, CancellationToken ct)
+    {
+        if (!opcoes.DryRun && !CoreServices.RodandoComoAdministrador())
+            _saida.WriteLine("Aviso: sem privilegios de administrador, partes do sistema ficam de fora.");
+
+        var modulo = _services.GetRequiredService<CleanerModule>();
+
+        _saida.WriteLine("Medindo o que pode ser liberado...");
+        var scan = await modulo.ScanAsync(
+            new Progress<ModuleProgress>(p => _saida.WriteLine($"  {p.Percentual,3}%  {p.Etapa}")), ct);
+
+        _saida.WriteLine();
+        _saida.WriteLine(scan.Resumo);
+        _saida.WriteLine();
+
+        var selecionados = Selecionar(scan, opcoes).ToList();
+
+        foreach (var item in scan.Itens)
+        {
+            var marca = item.Bloqueado ? "[x]" : selecionados.Contains(item.Id) ? "[*]" : "[ ]";
+            _saida.WriteLine($"  {marca} {item.Titulo,-42} {item.GanhoEstimado,10}   risco {item.Risco}");
+
+            if (item.MotivoBloqueio is not null)
+                _saida.WriteLine($"      {item.MotivoBloqueio}");
+        }
+
+        if (selecionados.Count == 0)
+        {
+            _saida.WriteLine();
+            _saida.WriteLine("Nada selecionado. Use --preset seguro, --preset completo ou --categorias.");
+            return 0;
+        }
+
+        _saida.WriteLine();
+        var resultado = await modulo.ApplyAsync(selecionados, opcoes.DryRun, ct);
+
+        foreach (var acao in resultado.Acoes)
+            _saida.WriteLine($"  {(acao.Sucesso ? "ok  " : "FALHA")} {acao.Detalhe}");
+
+        _saida.WriteLine();
+        _saida.WriteLine(resultado.Resumo);
+        _saida.WriteLine(resultado.GanhoMedido);
+
+        return resultado.Falhas > 0 ? 1 : 0;
+    }
+
+    private static IEnumerable<string> Selecionar(ScanResult scan, CommandLineOptions opcoes)
+    {
+        var disponiveis = scan.Itens.Where(i => !i.Bloqueado);
+
+        if (opcoes.Categorias.Count > 0)
+        {
+            // Casa pelo sufixo do id: "temp" pega temp-usuario e temp-sistema.
+            return disponiveis
+                .Where(i => opcoes.Categorias.Any(c =>
+                    i.Id.Contains(c, StringComparison.OrdinalIgnoreCase)
+                    || i.Categoria.Equals(c, StringComparison.OrdinalIgnoreCase)))
+                .Select(i => i.Id);
+        }
+
+        return opcoes.Preset switch
+        {
+            "completo" => disponiveis.Select(i => i.Id),
+            "seguro" => disponiveis.Where(i => i.PreMarcado).Select(i => i.Id),
+            _ => Enumerable.Empty<string>()
+        };
+    }
+
+    private async Task<int> ReportAsync(CommandLineOptions opcoes, CancellationToken ct)
+    {
+        var modulo = _services.GetRequiredService<HealthReportModule>();
+
+        _saida.WriteLine("Medindo a maquina por alguns segundos...");
+
+        var progresso = new Progress<ModuleProgress>(p => _saida.WriteLine($"  {p.Percentual,3}%  {p.Etapa}"));
+        var relatorio = await modulo.GerarAsync(progresso, ct);
+
+        var destino = opcoes.ArquivoDeSaida;
+
+        if (destino is null)
+        {
+            _saida.WriteLine();
+            _saida.WriteLine(opcoes.Json ? HtmlReportWriter.GerarJson(relatorio) : FormatarRelatorio(relatorio));
+            return 0;
+        }
+
+        // A extensao decide o formato, e --json continua valendo por cima dela.
+        var json = opcoes.Json || destino.EndsWith(".json", StringComparison.OrdinalIgnoreCase);
+        var conteudo = json ? HtmlReportWriter.GerarJson(relatorio) : HtmlReportWriter.GerarHtml(relatorio);
+
+        File.WriteAllText(destino, conteudo, new UTF8Encoding(false));
+
+        _saida.WriteLine();
+        _saida.WriteLine($"Nota geral: {relatorio.Pontuacao.NotaGeral} ({relatorio.Pontuacao.Conceito})");
+        _saida.WriteLine($"Relatorio gravado em {Path.GetFullPath(destino)}");
+        return 0;
+    }
+
+    private static string FormatarRelatorio(HealthSnapshot relatorio)
+    {
+        var sb = new StringBuilder();
+        var p = relatorio.Pontuacao;
+
+        sb.AppendLine("GameBoost - relatorio de saude");
+        sb.AppendLine($"Gerado em {relatorio.Momento:dd/MM/yyyy HH:mm:ss}");
+        sb.AppendLine();
+        sb.AppendLine($"Nota geral: {p.NotaGeral}/100  ({p.Conceito})");
+        sb.AppendLine();
+
+        foreach (var area in p.Areas)
+            sb.AppendLine($"  {area.Nome,-26} {area.Nota,3}/100  {area.Conceito}");
+
+        sb.AppendLine();
+
+        if (p.Principais.Count == 0)
+        {
+            sb.AppendLine("Nada fora do lugar. A maquina esta bem cuidada.");
+        }
+        else
+        {
+            sb.AppendLine("Principais achados:");
+            sb.AppendLine();
+
+            foreach (var f in p.Principais)
+            {
+                var marca = f.Severidade switch
+                {
+                    FindingSeverity.Critico => "[!]",
+                    FindingSeverity.Atencao => "[*]",
+                    _ => "[ ]"
+                };
+
+                sb.AppendLine($"  {marca} {f.Titulo}");
+                sb.AppendLine($"      {f.Detalhe}");
+                if (f.TextoDaAcao is not null)
+                    sb.AppendLine($"      Sugestao: {f.TextoDaAcao}");
+                sb.AppendLine();
+            }
+        }
+
+        sb.AppendLine("Nada foi alterado. Este comando so le o sistema.");
+        return sb.ToString();
+    }
+
+    private async Task<int> ScanAsync(CommandLineOptions opcoes, CancellationToken ct)
+    {
+        var modulo = _services.GetRequiredService<GameModeModule>();
+        var resultado = await modulo.ScanAsync(null, ct);
+
+        var texto = opcoes.Json
+            ? SerializarScan(resultado)
+            : FormatarScan(resultado);
+
+        if (opcoes.ArquivoDeSaida is not null)
+        {
+            File.WriteAllText(opcoes.ArquivoDeSaida, texto, new UTF8Encoding(false));
+            _saida.WriteLine($"Relatorio gravado em {Path.GetFullPath(opcoes.ArquivoDeSaida)}");
+        }
+        else
+        {
+            _saida.WriteLine(texto);
+        }
+
+        return 0;
+    }
+
+    private static string FormatarScan(ScanResult resultado)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("GameBoost - relatorio de varredura");
+        sb.AppendLine($"Gerado em {resultado.Momento:dd/MM/yyyy HH:mm:ss}");
+        sb.AppendLine($"Administrador: {(CoreServices.RodandoComoAdministrador() ? "sim" : "nao (somente leitura)")}");
+        sb.AppendLine();
+        sb.AppendLine(resultado.Resumo);
+        sb.AppendLine();
+
+        foreach (var aviso in resultado.Avisos)
+            sb.AppendLine($"  aviso: {aviso}");
+
+        if (resultado.Avisos.Count > 0)
+            sb.AppendLine();
+
+        foreach (var grupo in resultado.Itens.GroupBy(i => i.Categoria))
+        {
+            sb.AppendLine($"== {grupo.Key} ==");
+            foreach (var item in grupo)
+            {
+                var marca = item.Bloqueado ? "[x]" : item.PreMarcado ? "[*]" : "[ ]";
+                sb.AppendLine($"  {marca} {item.Titulo,-28} {item.GanhoEstimado,-22} risco {item.Risco}");
+                sb.AppendLine($"      {item.Descricao}");
+                if (item.MotivoBloqueio is not null)
+                    sb.AppendLine($"      protegido: {item.MotivoBloqueio}");
+            }
+
+            sb.AppendLine();
+        }
+
+        sb.AppendLine("Legenda: [*] vem pre-marcado  [ ] aparece desmarcado  [x] protegido, nao selecionavel");
+        sb.AppendLine("Nenhum processo foi encerrado. Este comando so le o sistema.");
+        return sb.ToString();
+    }
+
+    private static string SerializarScan(ScanResult resultado) =>
+        JsonSerializer.Serialize(new
+        {
+            gerado = resultado.Momento,
+            resumo = resultado.Resumo,
+            avisos = resultado.Avisos,
+            itens = resultado.Itens.Select(i => new
+            {
+                i.Id, i.Categoria, i.Titulo, i.Descricao,
+                risco = i.Risco.ToString(),
+                i.GanhoBytes, i.GanhoEstimado, i.PreMarcado, i.Bloqueado, i.MotivoBloqueio
+            })
+        }, new JsonSerializerOptions { WriteIndented = true });
+
+    private async Task<int> GameModeAsync(CommandLineOptions opcoes, bool ligar, CancellationToken ct)
+    {
+        if (!opcoes.DryRun && !CoreServices.RodandoComoAdministrador())
+        {
+            _saida.WriteLine("Este comando precisa de privilegios de administrador.");
+            return 4;
+        }
+
+        var modulo = _services.GetRequiredService<GameModeModule>();
+
+        if (ligar)
+        {
+            var scan = await modulo.ScanAsync(null, ct);
+            var selecionados = scan.Itens.Where(i => i.PreMarcado && !i.Bloqueado).Select(i => i.Id).ToList();
+
+            _saida.WriteLine($"Ativando o Modo Game com {selecionados.Count} apps pre-marcados...");
+            var resultado = await modulo.ApplyAsync(selecionados, opcoes.DryRun, ct);
+            Imprimir(resultado);
+            return resultado.Falhas > 0 ? 1 : 0;
+        }
+
+        _saida.WriteLine("Desligando o Modo Game...");
+        var desligar = await modulo.RevertAsync(Array.Empty<string>(), opcoes.DryRun, ct);
+        Imprimir(desligar);
+        return desligar.Falhas > 0 ? 1 : 0;
+    }
+
+    private int ReverterTudo(CommandLineOptions opcoes)
+    {
+        var rollback = _services.GetRequiredService<IRollbackEngine>();
+        var backup = _services.GetRequiredService<IStateBackup>();
+
+        if (!backup.TemPendencias)
+        {
+            _saida.WriteLine("Nada a reverter: nenhuma alteracao pendente no state-backup.");
+            return 0;
+        }
+
+        var resultados = rollback.ReverterTudo(opcoes.DryRun);
+
+        foreach (var r in resultados)
+            _saida.WriteLine($"  {(r.Sucesso ? "ok  " : "FALHA")} {r.Detalhe}");
+
+        var falhas = resultados.Count(r => !r.Sucesso);
+        _saida.WriteLine();
+        _saida.WriteLine(opcoes.DryRun
+            ? $"Dry-run: {resultados.Count} alteracoes seriam revertidas."
+            : $"{resultados.Count - falhas} de {resultados.Count} alteracoes revertidas.");
+
+        return falhas > 0 ? 1 : 0;
+    }
+
+    private void Imprimir(ApplyResult resultado)
+    {
+        foreach (var acao in resultado.Acoes)
+            _saida.WriteLine($"  {(acao.Sucesso ? "ok  " : "FALHA")} {acao.Detalhe}");
+
+        _saida.WriteLine();
+        _saida.WriteLine(resultado.Resumo);
+
+        if (!string.IsNullOrWhiteSpace(resultado.GanhoMedido))
+            _saida.WriteLine(resultado.GanhoMedido);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Cli/GameBoost.Cli.csproj b/GameBoost/src/GameBoost.Cli/GameBoost.Cli.csproj
new file mode 100644
index 0000000..e9e9c3a
--- /dev/null
+++ b/GameBoost/src/GameBoost.Cli/GameBoost.Cli.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0-windows</TargetFramework>
+    <RootNamespace>GameBoost.Cli</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GameBoost.Core\GameBoost.Core.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IClock.cs b/GameBoost/src/GameBoost.Core/Abstractions/IClock.cs
new file mode 100644
index 0000000..b3aa00c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IClock.cs
@@ -0,0 +1,12 @@
+namespace GameBoost.Core.Abstractions;
+
+/// <summary>Relogio injetavel. Existe para tornar tempo testavel (regra 10 nao se aplica, mas testes exigem).</summary>
+public interface IClock
+{
+    DateTimeOffset Now { get; }
+}
+
+public sealed class SystemClock : IClock
+{
+    public DateTimeOffset Now => DateTimeOffset.Now;
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IFileSystem.cs b/GameBoost/src/GameBoost.Core/Abstractions/IFileSystem.cs
new file mode 100644
index 0000000..6887d7c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IFileSystem.cs
@@ -0,0 +1,19 @@
+namespace GameBoost.Core.Abstractions;
+
+/// <summary>
+/// Toda escrita em disco passa por aqui. Os testes usam um fake que registra
+/// cada caminho tocado, garantindo a regra 2 (nunca deletar fora da whitelist).
+/// </summary>
+public interface IFileSystem
+{
+    bool FileExists(string path);
+    bool DirectoryExists(string path);
+    string ReadAllText(string path);
+    void WriteAllText(string path, string content);
+    void CreateDirectory(string path);
+    void DeleteFile(string path);
+    void MoveFile(string source, string destination, bool overwrite);
+    long GetFileSize(string path);
+    IEnumerable<string> EnumerateFiles(string path, string pattern, SearchOption option);
+    IEnumerable<string> EnumerateDirectories(string path);
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IMemoryService.cs b/GameBoost/src/GameBoost.Core/Abstractions/IMemoryService.cs
new file mode 100644
index 0000000..fd6f3ff
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IMemoryService.cs
@@ -0,0 +1,15 @@
+namespace GameBoost.Core.Abstractions;
+
+public sealed record MemorySnapshot(long TotalBytes, long AvailableBytes, long StandbyBytes)
+{
+    public long UsedBytes => TotalBytes - AvailableBytes;
+    public double UsedPercent => TotalBytes == 0 ? 0 : UsedBytes * 100.0 / TotalBytes;
+}
+
+public interface IMemoryService
+{
+    MemorySnapshot GetSnapshot();
+
+    /// <summary>Purga a Standby List do kernel. Exige SeProfileSingleProcessPrivilege (admin).</summary>
+    bool PurgeStandbyList();
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IPowerService.cs b/GameBoost/src/GameBoost.Core/Abstractions/IPowerService.cs
new file mode 100644
index 0000000..00728da
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IPowerService.cs
@@ -0,0 +1,10 @@
+namespace GameBoost.Core.Abstractions;
+
+public sealed record PowerPlan(Guid Id, string Name);
+
+public interface IPowerService
+{
+    PowerPlan? GetActivePlan();
+    IReadOnlyList<PowerPlan> GetPlans();
+    bool SetActivePlan(Guid planId);
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IProcessService.cs b/GameBoost/src/GameBoost.Core/Abstractions/IProcessService.cs
new file mode 100644
index 0000000..f9d6b02
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IProcessService.cs
@@ -0,0 +1,55 @@
+namespace GameBoost.Core.Abstractions;
+
+/// <summary>Instantaneo de um processo. Struct de dados pura, sem handle preso.</summary>
+public sealed record ProcessInfo(
+    int Pid,
+    string Name,
+    string? ExecutablePath,
+    string? CommandLine,
+    long WorkingSetBytes,
+    string? WindowTitle,
+    string? Company,
+    int SessionId);
+
+public interface IProcessService
+{
+    IReadOnlyList<ProcessInfo> GetProcesses();
+    ProcessInfo? GetProcess(int pid);
+
+    /// <summary>Pede o fechamento normal (WM_CLOSE). Retorna true se o processo saiu dentro do timeout.</summary>
+    bool TryCloseGracefully(int pid, TimeSpan timeout);
+
+    /// <summary>Finaliza a forca. So deve ser chamado depois de TryCloseGracefully falhar.</summary>
+    bool Kill(int pid);
+
+    bool SetPriority(int pid, ProcessPriority priority);
+    ProcessPriority? GetPriority(int pid);
+
+    /// <summary>
+    /// Restringe o processo a um conjunto de nucleos, por indice.
+    ///
+    /// Lista vazia devolve o processo a todos os nucleos, que e como reverter.
+    /// Devolve false quando algum indice nao existe nesta maquina: um perfil
+    /// gravado num PC de 16 nucleos nao pode derrubar o jogo num de 4.
+    /// </summary>
+    bool SetAffinity(int pid, IReadOnlyList<int> nucleos);
+
+    /// <summary>Nucleos em que o processo pode rodar agora.</summary>
+    IReadOnlyList<int> GetAffinity(int pid);
+
+    /// <summary>Relanca um executavel na sessao do usuario. Usado para reabrir os apps essenciais.</summary>
+    bool Start(string executablePath, string? arguments, string? workingDirectory);
+
+    /// <summary>EmptyWorkingSet no processo. Retorna quantos bytes sairam do working set.</summary>
+    long TrimWorkingSet(int pid);
+}
+
+/// <summary>Realtime nao existe de proposito: travaria o Windows (secao 1 do spec).</summary>
+public enum ProcessPriority
+{
+    Idle,
+    BelowNormal,
+    Normal,
+    AboveNormal,
+    High
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IRegistryService.cs b/GameBoost/src/GameBoost.Core/Abstractions/IRegistryService.cs
new file mode 100644
index 0000000..4f3c77c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IRegistryService.cs
@@ -0,0 +1,33 @@
+namespace GameBoost.Core.Abstractions;
+
+public enum RegistryRoot
+{
+    ClassesRoot,
+    CurrentUser,
+    LocalMachine,
+    Users
+}
+
+/// <summary>
+/// Acesso ao registro. Toda escrita exige que o chamador ja tenha gravado o
+/// valor anterior num ChangeRecord (regra 1).
+/// </summary>
+public interface IRegistryService
+{
+    object? GetValue(RegistryRoot root, string subKey, string valueName);
+    void SetValue(RegistryRoot root, string subKey, string valueName, object value, RegistryValueKindLite kind);
+    void DeleteValue(RegistryRoot root, string subKey, string valueName);
+    bool KeyExists(RegistryRoot root, string subKey);
+    IReadOnlyList<string> GetSubKeyNames(RegistryRoot root, string subKey);
+    IReadOnlyList<string> GetValueNames(RegistryRoot root, string subKey);
+}
+
+public enum RegistryValueKindLite
+{
+    String,
+    ExpandString,
+    DWord,
+    QWord,
+    Binary,
+    MultiString
+}
diff --git a/GameBoost/src/GameBoost.Core/Abstractions/IServiceControllerService.cs b/GameBoost/src/GameBoost.Core/Abstractions/IServiceControllerService.cs
new file mode 100644
index 0000000..a672e20
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Abstractions/IServiceControllerService.cs
@@ -0,0 +1,21 @@
+namespace GameBoost.Core.Abstractions;
+
+public enum ServiceStartMode
+{
+    Boot,
+    System,
+    Automatic,
+    Manual,
+    Disabled
+}
+
+public sealed record ServiceInfo(string Name, string DisplayName, bool IsRunning, ServiceStartMode StartMode);
+
+public interface IServiceControllerService
+{
+    ServiceInfo? GetService(string name);
+    IReadOnlyList<ServiceInfo> GetServices();
+    bool Stop(string name, TimeSpan timeout);
+    bool Start(string name, TimeSpan timeout);
+    bool SetStartMode(string name, ServiceStartMode mode);
+}
diff --git a/GameBoost/src/GameBoost.Core/CoreServices.cs b/GameBoost/src/GameBoost.Core/CoreServices.cs
new file mode 100644
index 0000000..96e9d73
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/CoreServices.cs
@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.Cleaner;
+using GameBoost.Core.Modules.DiskAnalyzer;
+using GameBoost.Core.Modules.Startup;
+using GameBoost.Core.Modules.Drivers;
+using GameBoost.Core.Modules.Network;
+using GameBoost.Core.Modules.Profiles;
+using GameBoost.Core.Modules.Tweaks;
+using GameBoost.Core.Modules.Uninstaller;
+using GameBoost.Core.Modules.Tools;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Modules.HealthReport;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Services;
+using GameBoost.Core.Settings;
+using GameBoost.Core.State;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GameBoost.Core;
+
+/// <summary>
+/// Composicao unica do Core. App e CLI montam o mesmo grafo de servicos, entao
+/// os dois se comportam igual (regra 4.2: nada de static).
+/// </summary>
+public static class CoreServices
+{
+    /// <param name="paths">
+    /// Deixe nulo em producao para resolver %LOCALAPPDATA% (ou .\data no modo
+    /// portatil). Os testes de integracao passam uma pasta temporaria para nao
+    /// escrever nos dados reais do usuario.
+    /// </param>
+    public static IServiceCollection AddGameBoostCore(this IServiceCollection services, AppPaths? paths = null)
+    {
+        paths ??= AppPaths.Resolve();
+        paths.EnsureDirectories();
+
+        services.AddSingleton(paths);
+        services.AddSingleton<IClock, SystemClock>();
+        services.AddSingleton<IFileSystem, WindowsFileSystem>();
+        services.AddSingleton<IGameBoostLogger, StructuredLogger>();
+
+        services.AddSingleton<ISettingsStore, SettingsStore>();
+        services.AddSingleton(sp => sp.GetRequiredService<ISettingsStore>().Load());
+
+        services.AddSingleton<IRegistryService, WindowsRegistryService>();
+        services.AddSingleton<IProcessService, WindowsProcessService>();
+        services.AddSingleton<IPowerService, WindowsPowerService>();
+        services.AddSingleton<IMemoryService, WindowsMemoryService>();
+        services.AddSingleton<IServiceControllerService, WindowsServiceControllerService>();
+
+        services.AddSingleton<AntivirusDetector>();
+        services.AddSingleton<ISafetyGuard>(sp =>
+        {
+            using var atual = Process.GetCurrentProcess();
+            Native.NativeMethodsBridge.TryGetSessionId(atual.Id, out var sessao);
+
+            return new SafetyGuard(
+                sp.GetRequiredService<AppSettings>(),
+                sessao,
+                atual.Id,
+                sp.GetRequiredService<AntivirusDetector>().Detectar());
+        });
+
+        services.AddSingleton<IStateBackup, StateBackup>();
+        services.AddSingleton<IRollbackEngine, RollbackEngine>();
+        services.AddSingleton<ISessionStore, SessionStore>();
+
+        // Fase 1: diagnostico de gargalos e relatorio de saude.
+        services.AddSingleton<ITemperatureProvider, WmiTemperatureProvider>();
+        services.AddSingleton<IMetricsCollector, WindowsMetricsCollector>();
+        services.AddSingleton<SystemFactsReader>();
+        services.AddSingleton<FindingEngine>(sp => new FindingEngine(
+            sp.GetRequiredService<IGameBoostLogger>(),
+            sp.GetRequiredService<IClock>()));
+        services.AddSingleton<BottleneckMonitor>();
+        services.AddSingleton<HealthReportModule>();
+
+        // Fase 2: limpeza.
+        services.AddSingleton<CleanupHistory>();
+        services.AddSingleton<CleanerModule>();
+        services.AddSingleton<QuickToolsService>();
+
+        // Fase 3: analisador de espaco.
+        services.AddSingleton<DiskScanner>();
+        services.AddSingleton<GameLibrary>();
+
+        // Fase 4: desinstalador.
+        services.AddSingleton<AppInventory>();
+        services.AddSingleton<LeftoverScanner>();
+        services.AddSingleton<WingetService>();
+        services.AddSingleton<UninstallerModule>();
+        services.AddSingleton<StartupModule>();
+
+        // Fase 5: tweaks e servicos.
+        services.AddSingleton<TweaksModule>();
+        services.AddSingleton<NetworkDiagnostics>();
+        services.AddSingleton<NatDiagnostics>();
+        services.AddSingleton<SpeedTest>();
+        services.AddSingleton<NetworkModule>();
+        services.AddSingleton<GpuDriverInfo>();
+
+        // Fase 6: perfis por jogo.
+        services.AddSingleton<ProfileStore>();
+        services.AddSingleton<GameWatcher>();
+        services.AddSingleton<ProfileRunner>();
+
+        // Fase 7: atualizacao do proprio app.
+        services.AddSingleton<Updates.UpdateService>();
+
+        services.AddSingleton<SystemSilencer>();
+        services.AddSingleton<GameDetector>();
+        services.AddSingleton<GameModeModule>();
+        services.AddSingleton<IModule>(sp => sp.GetRequiredService<GameModeModule>());
+
+        return services;
+    }
+
+    /// <summary>
+    /// Varreduras funcionam sem admin; as acoes ficam desabilitadas com aviso
+    /// (modo somente leitura da secao 4.2).
+    /// </summary>
+    public static bool RodandoComoAdministrador()
+    {
+        try
+        {
+            using var identidade = System.Security.Principal.WindowsIdentity.GetCurrent();
+            var principal = new System.Security.Principal.WindowsPrincipal(identidade);
+            return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or InvalidOperationException)
+        {
+            return false;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/GameBoost.Core.csproj b/GameBoost/src/GameBoost.Core/GameBoost.Core.csproj
new file mode 100644
index 0000000..e7c8cc7
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/GameBoost.Core.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0-windows</TargetFramework>
+    <UseWPF>false</UseWPF>
+    <RootNamespace>GameBoost.Core</RootNamespace>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+    <PackageReference Include="System.Diagnostics.PerformanceCounter" Version="9.0.5" />
+    <PackageReference Include="System.Management" Version="9.0.5" />
+    <PackageReference Include="System.ServiceProcess.ServiceController" Version="9.0.5" />
+    <PackageReference Include="Velopack" Version="1.2.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <!-- O projeto de teste precisa alcancar helpers internos como o ROT13. -->
+    <InternalsVisibleTo Include="GameBoost.Tests" />
+  </ItemGroup>
+
+</Project>
diff --git a/GameBoost/src/GameBoost.Core/Logging/IGameBoostLogger.cs b/GameBoost/src/GameBoost.Core/Logging/IGameBoostLogger.cs
new file mode 100644
index 0000000..dbbf30d
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Logging/IGameBoostLogger.cs
@@ -0,0 +1,29 @@
+namespace GameBoost.Core.Logging;
+
+public enum LogLevel
+{
+    Debug,
+    Info,
+    Warn,
+    Error
+}
+
+/// <summary>
+/// Regra 8: toda acao grava linha estruturada (timestamp, modulo, acao, alvo, resultado).
+/// </summary>
+public interface IGameBoostLogger
+{
+    void Log(LogLevel level, string modulo, string acao, string? alvo, string resultado, Exception? ex = null);
+}
+
+public static class LoggerExtensions
+{
+    public static void Info(this IGameBoostLogger log, string modulo, string acao, string? alvo, string resultado)
+        => log.Log(LogLevel.Info, modulo, acao, alvo, resultado);
+
+    public static void Warn(this IGameBoostLogger log, string modulo, string acao, string? alvo, string resultado)
+        => log.Log(LogLevel.Warn, modulo, acao, alvo, resultado);
+
+    public static void Error(this IGameBoostLogger log, string modulo, string acao, string? alvo, string resultado, Exception? ex = null)
+        => log.Log(LogLevel.Error, modulo, acao, alvo, resultado, ex);
+}
diff --git a/GameBoost/src/GameBoost.Core/Logging/StructuredLogger.cs b/GameBoost/src/GameBoost.Core/Logging/StructuredLogger.cs
new file mode 100644
index 0000000..ef167d3
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Logging/StructuredLogger.cs
@@ -0,0 +1,76 @@
+using System.Text;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Logging;
+
+/// <summary>
+/// Log texto legivel, rotacionado em 5 MB x 5 arquivos (secao 7 do spec).
+/// Serializado por lock: as varreduras rodam em varias Tasks ao mesmo tempo.
+/// </summary>
+public sealed class StructuredLogger : IGameBoostLogger
+{
+    private const long MaxBytes = 5 * 1024 * 1024;
+    private const int MaxArquivos = 5;
+
+    private readonly AppPaths _paths;
+    private readonly IClock _clock;
+    private readonly object _gate = new();
+
+    public StructuredLogger(AppPaths paths, IClock clock)
+    {
+        _paths = paths;
+        _clock = clock;
+    }
+
+    public void Log(LogLevel level, string modulo, string acao, string? alvo, string resultado, Exception? ex = null)
+    {
+        var linha = new StringBuilder()
+            .Append(_clock.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"))
+            .Append(" | ").Append(level.ToString().ToUpperInvariant().PadRight(5))
+            .Append(" | ").Append(modulo)
+            .Append(" | ").Append(acao)
+            .Append(" | ").Append(string.IsNullOrEmpty(alvo) ? "-" : alvo)
+            .Append(" | ").Append(resultado);
+
+        if (ex is not null)
+            linha.Append(" | ").Append(ex.GetType().Name).Append(": ").Append(ex.Message);
+
+        lock (_gate)
+        {
+            try
+            {
+                Directory.CreateDirectory(_paths.RootDirectory);
+                Rotacionar();
+                File.AppendAllText(_paths.LogFile, linha.ToString() + Environment.NewLine, Encoding.UTF8);
+            }
+            catch (IOException)
+            {
+                // Log nunca derruba o app. Falha de disco e engolida de proposito.
+            }
+            catch (UnauthorizedAccessException)
+            {
+            }
+        }
+    }
+
+    private void Rotacionar()
+    {
+        var atual = _paths.LogFile;
+        if (!File.Exists(atual) || new FileInfo(atual).Length < MaxBytes)
+            return;
+
+        var maisAntigo = $"{atual}.{MaxArquivos}";
+        if (File.Exists(maisAntigo))
+            File.Delete(maisAntigo);
+
+        for (var i = MaxArquivos - 1; i >= 1; i--)
+        {
+            var origem = $"{atual}.{i}";
+            if (File.Exists(origem))
+                File.Move(origem, $"{atual}.{i + 1}", overwrite: true);
+        }
+
+        File.Move(atual, $"{atual}.1", overwrite: true);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/ActionItem.cs b/GameBoost/src/GameBoost.Core/Modules/ActionItem.cs
new file mode 100644
index 0000000..bbf5d20
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/ActionItem.cs
@@ -0,0 +1,42 @@
+namespace GameBoost.Core.Modules;
+
+/// <summary>
+/// Unidade acionavel de qualquer modulo. A UI e generica: uma lista de ActionItem
+/// com checkbox, badge de risco e botao "?" com a explicacao (secao 4.2 do spec).
+/// </summary>
+public sealed class ActionItem
+{
+    public required string Id { get; init; }
+    public required string Categoria { get; init; }
+    public required string Titulo { get; init; }
+    public required string Descricao { get; init; }
+    public RiskLevel Risco { get; init; } = RiskLevel.Baixo;
+
+    /// <summary>Texto honesto do ganho. Proibido inventar numero (regra 4).</summary>
+    public string GanhoEstimado { get; init; } = string.Empty;
+
+    /// <summary>Bytes que este item deve liberar, quando mensuravel. 0 = nao se aplica.</summary>
+    public long GanhoBytes { get; init; }
+
+    /// <summary>Nada que possa causar perda vem marcado (regra 3).</summary>
+    public bool PreMarcado { get; init; }
+
+    public required string ComoDesfazer { get; init; }
+
+    /// <summary>Itens protegidos aparecem na lista mas nao podem ser selecionados (regra 6).</summary>
+    public bool Bloqueado { get; init; }
+
+    public string? MotivoBloqueio { get; init; }
+
+    /// <summary>
+    /// Texto do selo quando o item esta bloqueado. O padrao e "Protegido", mas
+    /// nem todo bloqueio e protecao: um ajuste que so precisa de elevacao
+    /// aparece bloqueado e **nao** e protegido — chamar os dois da mesma coisa
+    /// faz o usuario achar que o GameBoost se recusa a mexer, quando na verdade
+    /// basta reabrir como administrador.
+    /// </summary>
+    public string RotuloBloqueio { get; init; } = "Protegido";
+
+    /// <summary>Carga util especifica do modulo (ex.: o ProcessInfo por tras do item).</summary>
+    public object? Payload { get; init; }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/BottleneckMonitor.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/BottleneckMonitor.cs
new file mode 100644
index 0000000..1760abd
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/BottleneckMonitor.cs
@@ -0,0 +1,169 @@
+using System.Diagnostics;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+public sealed record MonitorTick(MetricsSnapshot Snapshot, IReadOnlyList<Finding> Findings);
+
+/// <summary>
+/// Coleta a cada 1 s com buffer de 5 min (secao 5.5).
+///
+/// Roda numa Task propria, nunca na thread da UI (regra 10). Se um tique
+/// atrasa, o proximo nao se acumula: o intervalo e medido do fim de um ciclo
+/// ao inicio do seguinte, entao a coleta nunca vira uma fila de trabalho
+/// atrasado quando a maquina esta sob carga.
+/// </summary>
+public sealed class BottleneckMonitor : IDisposable
+{
+    public static readonly TimeSpan Intervalo = TimeSpan.FromSeconds(1);
+    public static readonly TimeSpan Janela = TimeSpan.FromMinutes(5);
+
+    private readonly IMetricsCollector _coletor;
+    private readonly FindingEngine _motor;
+    private readonly SystemFactsReader _fatos;
+    private readonly GameDetector _detector;
+    private readonly IGameBoostLogger _log;
+
+    private readonly MetricsBuffer _buffer = new((int)(Janela.TotalSeconds / Intervalo.TotalSeconds));
+    private CancellationTokenSource? _cts;
+    private Thread? _thread;
+
+    /// <summary>Disparado a cada coleta. O assinante e responsavel por voltar para a UI.</summary>
+    public event Action<MonitorTick>? AoColetar;
+
+    public BottleneckMonitor(
+        IMetricsCollector coletor,
+        FindingEngine motor,
+        SystemFactsReader fatos,
+        GameDetector detector,
+        IGameBoostLogger log)
+    {
+        _coletor = coletor;
+        _motor = motor;
+        _fatos = fatos;
+        _detector = detector;
+        _log = log;
+    }
+
+    public bool Rodando => _thread is { IsAlive: true };
+
+    public MetricsBuffer Buffer => _buffer;
+
+    public MetricsSnapshot? Ultimo => _buffer.Ultimo;
+
+    /// <summary>
+    /// Custo medio de CPU da propria coleta, para provar o orcamento da secao 5.5.
+    /// Medido pelo tempo de CPU da thread de coleta, nao pelo tempo de parede.
+    /// </summary>
+    public double CustoMedioDeCpuPercent { get; private set; }
+
+    /// <summary>Duracao media de um ciclo em milissegundos, util para diagnosticar lentidao.</summary>
+    public double DuracaoMediaDoCicloMs { get; private set; }
+
+    public void Iniciar()
+    {
+        if (Rodando)
+            return;
+
+        _cts = new CancellationTokenSource();
+        var token = _cts.Token;
+
+        // Thread dedicada, e nao Task no pool, por dois motivos: o custo da
+        // coleta e medido por GetThreadTimes, que so faz sentido se for sempre
+        // a mesma thread (um await devolveria a continuacao em outra), e a
+        // prioridade abaixo do normal garante que o monitor cede lugar para o
+        // jogo em vez de disputar com ele.
+        _thread = new Thread(() => Laco(token))
+        {
+            IsBackground = true,
+            Name = "GameBoost.Bottleneck",
+            Priority = ThreadPriority.BelowNormal
+        };
+
+        _thread.Start();
+
+        _log.Info("Bottleneck", "Iniciar", null, $"coleta a cada {Intervalo.TotalSeconds:0}s, janela de {Janela.TotalMinutes:0} min");
+    }
+
+    public void Parar()
+    {
+        _cts?.Cancel();
+
+        _thread?.Join(TimeSpan.FromSeconds(3));
+        _thread = null;
+        _log.Info("Bottleneck", "Parar", null,
+            $"custo medio de CPU da coleta: {CustoMedioDeCpuPercent:0.000}%, ciclo medio de {DuracaoMediaDoCicloMs:0} ms");
+    }
+
+    private void Laco(CancellationToken ct)
+    {
+        var cronometro = new Stopwatch();
+        var nucleos = Environment.ProcessorCount;
+        var amostrasDeCusto = 0;
+        var cpuDaThreadAntes = Native.NativeMethodsBridge.TempoDeCpuDaThreadAtual();
+
+        // Primeira coleta e so linha de base dos deltas: nao gera finding.
+        try
+        {
+            _coletor.Coletar();
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+        {
+            _log.Error("Bottleneck", "Coletar", null, "falha na leitura inicial", ex);
+        }
+
+        while (!ct.IsCancellationRequested)
+        {
+            if (ct.WaitHandle.WaitOne(Intervalo))
+                return;
+
+            cronometro.Restart();
+            cpuDaThreadAntes = Native.NativeMethodsBridge.TempoDeCpuDaThreadAtual();
+
+            try
+            {
+                var snapshot = _coletor.Coletar();
+                _buffer.Adicionar(snapshot);
+
+                var jogo = _detector.DetectarPorNome(snapshot.Processos.Select(p => p.Nome));
+
+                var contexto = new FindingContext
+                {
+                    Atual = snapshot,
+                    Historico = _buffer.Todos(),
+                    Fatos = _fatos.Ler(),
+                    JogoEmExecucao = jogo
+                };
+
+                var findings = _motor.Avaliar(contexto);
+                AoColetar?.Invoke(new MonitorTick(snapshot, findings));
+            }
+            catch (Exception ex) when (ex is InvalidOperationException
+                                          or UnauthorizedAccessException
+                                          or System.ComponentModel.Win32Exception)
+            {
+                _log.Error("Bottleneck", "Coletar", null, "falha numa coleta, o laco continua", ex);
+            }
+
+            cronometro.Stop();
+
+            // Custo real: tempo de CPU consumido pela thread de coleta sobre o
+            // intervalo, dividido pelos nucleos (100% = a maquina inteira).
+            // Usar o cronometro aqui contaria espera de WMI como se fosse CPU.
+            var cpuDaThread = (Native.NativeMethodsBridge.TempoDeCpuDaThreadAtual() - cpuDaThreadAntes).TotalMilliseconds;
+            var custo = cpuDaThread / Intervalo.TotalMilliseconds * 100.0 / nucleos;
+
+            amostrasDeCusto++;
+            CustoMedioDeCpuPercent += (custo - CustoMedioDeCpuPercent) / amostrasDeCusto;
+            DuracaoMediaDoCicloMs += (cronometro.Elapsed.TotalMilliseconds - DuracaoMediaDoCicloMs) / amostrasDeCusto;
+        }
+    }
+
+    public void Dispose()
+    {
+        Parar();
+        _cts?.Dispose();
+        (_coletor as IDisposable)?.Dispose();
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Finding.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Finding.cs
new file mode 100644
index 0000000..b70aaeb
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Finding.cs
@@ -0,0 +1,64 @@
+namespace GameBoost.Core.Modules.Bottleneck;
+
+public enum FindingSeverity
+{
+    Informativo,
+    Atencao,
+    Critico
+}
+
+/// <summary>Para onde o botao do finding leva.</summary>
+public enum FindingAcao
+{
+    Nenhuma,
+    AbrirModoGame,
+    LimparRam,
+    PurgarStandby,
+    AbrirAnalisadorDeDisco,
+    AbrirInicializacao,
+    AbrirTweaks,
+    AtivarAltoDesempenho,
+    AbrirConfiguracoesDeVideo,
+    AbrirSegurancaDoWindows,
+    AbrirSiteDoDriver,
+    ReaplicarPerfil
+}
+
+/// <summary>
+/// Um diagnostico em linguagem humana (secao 5.5). O texto e escrito para o
+/// usuario, nao para o desenvolvedor: "seu Chrome esta usando 38% da CPU",
+/// nao "cpu_usage_threshold_exceeded".
+/// </summary>
+public sealed record Finding
+{
+    /// <summary>Estavel por regra e alvo: e o que o debounce usa para nao repetir.</summary>
+    public required string Id { get; init; }
+
+    public required string RegraId { get; init; }
+    public required string Titulo { get; init; }
+    public required string Detalhe { get; init; }
+    public FindingSeverity Severidade { get; init; } = FindingSeverity.Informativo;
+
+    /// <summary>Ordena a lista. Quanto maior, mais alto aparece.</summary>
+    public int Impacto { get; init; }
+
+    public FindingAcao Acao { get; init; } = FindingAcao.Nenhuma;
+    public string? TextoDaAcao { get; init; }
+
+    /// <summary>Area do Relatorio de Saude que este finding penaliza.</summary>
+    public HealthArea Area { get; init; } = HealthArea.Desempenho;
+
+    /// <summary>Quanto tira da nota daquela area, de 0 a 100.</summary>
+    public int Penalidade { get; init; }
+
+    public DateTimeOffset Momento { get; init; }
+}
+
+/// <summary>Areas pontuadas no Relatorio de Saude (secao 5.12).</summary>
+public enum HealthArea
+{
+    Desempenho,
+    Espaco,
+    Inicializacao,
+    ConfiguracaoParaJogos
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/FindingEngine.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/FindingEngine.cs
new file mode 100644
index 0000000..af4074c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/FindingEngine.cs
@@ -0,0 +1,128 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.Bottleneck.Rules;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Roda todas as regras e devolve os findings ordenados por impacto.
+///
+/// O debounce de 30 s (criterio de aceite da secao 5.5) impede que a lista
+/// pisque a cada segundo: um finding que ja esta na tela nao e reemitido, e um
+/// que sumiu so e esquecido depois da janela, evitando que oscile na fronteira
+/// do limite.
+/// </summary>
+public sealed class FindingEngine
+{
+    public static readonly TimeSpan JanelaDeDebounce = TimeSpan.FromSeconds(30);
+
+    private readonly IReadOnlyList<IFindingRule> _regras;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+    private readonly Dictionary<string, (Finding Finding, DateTimeOffset VistoPorUltimo)> _ativos = new();
+    private readonly object _gate = new();
+
+    public FindingEngine(IGameBoostLogger log, IClock relogio, IReadOnlyList<IFindingRule>? regras = null)
+    {
+        _log = log;
+        _relogio = relogio;
+        _regras = regras ?? RegrasPadrao();
+    }
+
+    /// <summary>Todas as regras da tabela da secao 5.5.</summary>
+    public static IReadOnlyList<IFindingRule> RegrasPadrao() => new IFindingRule[]
+    {
+        new ProcessoDevorandoCpuRule(),
+        new RamNoLimiteRule(),
+        new StandbyListInchadaRule(),
+        new DiscoDoSistemaCheioRule(),
+        new GpuNoLimiteRule(),
+        new GargaloDeCpuEmJogoRule(),
+        new ThrottlingTermicoRule(),
+        new ProcessoDeSistemaOcupandoDiscoRule(),
+        new PlanoDeEnergiaBalanceadoRule(),
+        new DriverDeVideoAntigoRule(),
+        new InicializacaoLotadaRule(),
+        new GravacaoEmSegundoPlanoRule(),
+        new PerfilDesfeitoPorUpdateRule(),
+        new MonitorEmTaxaBaixaRule(),
+        new VbsAtivoRule(),
+        new JogoEmHddRule(),
+        new MemoriaSingleChannelRule()
+    };
+
+    public int QuantidadeDeRegras => _regras.Count;
+
+    /// <summary>
+    /// Avalia o contexto e devolve a lista atual de findings, ja com debounce.
+    /// Uma regra que lance excecao e isolada: as demais continuam valendo.
+    /// </summary>
+    public IReadOnlyList<Finding> Avaliar(FindingContext contexto)
+    {
+        var agora = contexto.Atual.Momento;
+        var encontrados = new List<Finding>();
+
+        foreach (var regra in _regras)
+        {
+            try
+            {
+                var finding = regra.Avaliar(contexto);
+                if (finding is not null)
+                    encontrados.Add(finding);
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or ArgumentException or FormatException)
+            {
+                _log.Error("Bottleneck", "Regra", regra.Id, "falhou ao avaliar", ex);
+            }
+        }
+
+        lock (_gate)
+        {
+            foreach (var finding in encontrados)
+            {
+                if (_ativos.TryGetValue(finding.Id, out var existente))
+                {
+                    // Ja esta na tela: atualiza o texto, mantem a posicao.
+                    _ativos[finding.Id] = (finding, agora);
+                }
+                else
+                {
+                    _ativos[finding.Id] = (finding, agora);
+                    _log.Info("Bottleneck", "Finding", finding.RegraId, finding.Titulo);
+                }
+            }
+
+            // Some so depois da janela: evita piscar na fronteira do limite.
+            var expirados = _ativos
+                .Where(kv => agora - kv.Value.VistoPorUltimo > JanelaDeDebounce)
+                .Select(kv => kv.Key)
+                .ToList();
+
+            foreach (var id in expirados)
+                _ativos.Remove(id);
+
+            return _ativos.Values
+                .Select(v => v.Finding)
+                .OrderByDescending(f => f.Severidade)
+                .ThenByDescending(f => f.Impacto)
+                .ToList();
+        }
+    }
+
+    public IReadOnlyList<Finding> Atuais()
+    {
+        lock (_gate)
+        {
+            return _ativos.Values
+                .Select(v => v.Finding)
+                .OrderByDescending(f => f.Severidade)
+                .ThenByDescending(f => f.Impacto)
+                .ToList();
+        }
+    }
+
+    public void Limpar()
+    {
+        lock (_gate) _ativos.Clear();
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/GpuCounterReader.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/GpuCounterReader.cs
new file mode 100644
index 0000000..a1a6dfe
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/GpuCounterReader.cs
@@ -0,0 +1,84 @@
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Uso e memoria da GPU pelos contadores "GPU Engine" e "GPU Adapter Memory"
+/// (Windows 10 1709+).
+///
+/// Uma consulta PDH com curinga cobre todas as instancias de uma vez. A
+/// primeira versao criava um PerformanceCounter por instancia e o ciclo de
+/// coleta passava de 1 segundo com jogo e navegadores abertos, estourando o
+/// orcamento da secao 5.5.
+///
+/// Se os contadores nao existirem, a GPU vira "indisponivel" e nada mais
+/// quebra: a UI diz isso em vez de mostrar zero (regra 4).
+/// </summary>
+internal sealed class GpuCounterReader : IDisposable
+{
+    private const string CaminhoDeUso = @"\GPU Engine(*engtype_3D)\Utilization Percentage";
+    private const string CaminhoDeMemoria = @"\GPU Adapter Memory(*)\Dedicated Usage";
+
+    private readonly IGameBoostLogger _log;
+    private PdhQuery? _uso;
+    private PdhQuery? _memoria;
+    private bool _iniciado;
+    private bool _descartado;
+
+    public GpuCounterReader(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    private void GarantirIniciado()
+    {
+        if (_iniciado || _descartado)
+            return;
+
+        _iniciado = true;
+
+        _uso = PdhQuery.Abrir(CaminhoDeUso);
+        _memoria = PdhQuery.Abrir(CaminhoDeMemoria);
+
+        if (_uso is null)
+            _log.Warn("Bottleneck", "GPU", null,
+                "contadores de GPU indisponiveis nesta maquina: o uso de GPU fica sem medida");
+    }
+
+    public Medida LerUso()
+    {
+        GarantirIniciado();
+
+        if (_uso is null)
+            return Medida.Indisponivel;
+
+        var valores = _uso.Coletar();
+        if (valores.Count == 0)
+            return Medida.De(0);
+
+        // Cada engine reporta a propria ocupacao; a placa esta tao ocupada
+        // quanto a engine mais carregada, nao quanto a soma delas.
+        return Medida.De(Math.Clamp(valores.Max(), 0, 100));
+    }
+
+    public Medida LerMemoria()
+    {
+        GarantirIniciado();
+
+        if (_memoria is null)
+            return Medida.Indisponivel;
+
+        var valores = _memoria.Coletar();
+        return valores.Count == 0 ? Medida.Indisponivel : Medida.De(valores.Sum());
+    }
+
+    public void Dispose()
+    {
+        _descartado = true;
+        _uso?.Dispose();
+        _memoria?.Dispose();
+        _uso = null;
+        _memoria = null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/IFindingRule.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/IFindingRule.cs
new file mode 100644
index 0000000..627202b
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/IFindingRule.cs
@@ -0,0 +1,92 @@
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Tudo que uma regra precisa saber. Passar um contexto em vez de servicos vivos
+/// e o que torna cada regra testavel com um snapshot sintetico, sem tocar no
+/// Windows (secao 11).
+/// </summary>
+public sealed class FindingContext
+{
+    public required MetricsSnapshot Atual { get; init; }
+
+    /// <summary>Historico recente, do mais antigo para o mais novo.</summary>
+    public IReadOnlyList<MetricsSnapshot> Historico { get; init; } = Array.Empty<MetricsSnapshot>();
+
+    /// <summary>Fatos do sistema que nao mudam a cada segundo.</summary>
+    public SystemFacts Fatos { get; init; } = new();
+
+    /// <summary>Nome do jogo em execucao, quando ha um.</summary>
+    public string? JogoEmExecucao { get; init; }
+
+    public bool EmJogo => !string.IsNullOrEmpty(JogoEmExecucao);
+
+    /// <summary>Media de uma metrica na janela pedida. Null se nao houver amostras.</summary>
+    public double? MediaNaJanela(TimeSpan janela, Func<MetricsSnapshot, double?> seletor)
+    {
+        var corte = Atual.Momento - janela;
+        var valores = Historico
+            .Where(s => s.Momento >= corte)
+            .Select(seletor)
+            .Where(v => v.HasValue)
+            .Select(v => v!.Value)
+            .ToList();
+
+        return valores.Count == 0 ? null : valores.Average();
+    }
+
+    /// <summary>True se a condicao valeu em toda a janela e houve amostras suficientes.</summary>
+    public bool SustentadoPor(TimeSpan janela, Func<MetricsSnapshot, bool> condicao, int minimoDeAmostras = 5)
+    {
+        var corte = Atual.Momento - janela;
+        var amostras = Historico.Where(s => s.Momento >= corte).ToList();
+
+        if (amostras.Count < minimoDeAmostras)
+            return false;
+
+        return amostras.All(condicao);
+    }
+}
+
+/// <summary>
+/// Fatos lidos uma vez (ou raramente), nao a cada segundo: plano de energia,
+/// build do Windows, driver de video, taxa de atualizacao do monitor.
+/// </summary>
+public sealed class SystemFacts
+{
+    public Guid? PlanoDeEnergiaAtivo { get; init; }
+    public string? NomeDoPlanoDeEnergia { get; init; }
+    public bool PlanoEhBalanceado { get; init; }
+
+    public string? BuildDoWindows { get; init; }
+    public string? BuildAnteriormenteVisto { get; init; }
+    public int TweaksDesfeitosPorUpdate { get; init; }
+
+    public string? FabricanteDaGpu { get; init; }
+    public string? VersaoDoDriver { get; init; }
+    public DateTimeOffset? DataDoDriver { get; init; }
+
+    public int TaxaDeAtualizacaoAtual { get; init; }
+    public int TaxaDeAtualizacaoMaxima { get; init; }
+
+    public bool VbsAtivo { get; init; }
+    public bool GameDvrAtivo { get; init; }
+    public bool GameBarOverlayAtivo { get; init; }
+
+    public int ItensNaInicializacao { get; init; }
+    public bool JogoEmHdd { get; init; }
+    public string? JogoEmHddNome { get; init; }
+    public int PentesDeMemoria { get; init; }
+    public bool DefenderVarrendo { get; init; }
+    public bool WindowsSearchIndexando { get; init; }
+}
+
+/// <summary>
+/// Uma regra de diagnostico. Devolve null quando nao ha nada a dizer.
+/// Cada regra da tabela da secao 5.5 e uma classe destas, testada isoladamente.
+/// </summary>
+public interface IFindingRule
+{
+    string Id { get; }
+
+    Finding? Avaliar(FindingContext contexto);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsBuffer.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsBuffer.cs
new file mode 100644
index 0000000..1d85f6d
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsBuffer.cs
@@ -0,0 +1,96 @@
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Janela deslizante dos ultimos 5 minutos (secao 5.5). Tamanho fixo: o buffer
+/// nunca cresce, entao a coleta continua cabendo no orcamento de 60 MB.
+/// </summary>
+public sealed class MetricsBuffer
+{
+    private readonly MetricsSnapshot?[] _itens;
+    private readonly object _gate = new();
+    private int _proximo;
+    private int _quantidade;
+
+    public MetricsBuffer(int capacidade = 300)
+    {
+        if (capacidade <= 0)
+            throw new ArgumentOutOfRangeException(nameof(capacidade));
+
+        Capacidade = capacidade;
+        _itens = new MetricsSnapshot?[capacidade];
+    }
+
+    public int Capacidade { get; }
+
+    public int Quantidade
+    {
+        get { lock (_gate) return _quantidade; }
+    }
+
+    public MetricsSnapshot? Ultimo
+    {
+        get
+        {
+            lock (_gate)
+            {
+                if (_quantidade == 0)
+                    return null;
+
+                var indice = (_proximo - 1 + Capacidade) % Capacidade;
+                return _itens[indice];
+            }
+        }
+    }
+
+    public void Adicionar(MetricsSnapshot snapshot)
+    {
+        lock (_gate)
+        {
+            _itens[_proximo] = snapshot;
+            _proximo = (_proximo + 1) % Capacidade;
+
+            if (_quantidade < Capacidade)
+                _quantidade++;
+        }
+    }
+
+    /// <summary>Do mais antigo para o mais recente.</summary>
+    public IReadOnlyList<MetricsSnapshot> Todos()
+    {
+        lock (_gate)
+        {
+            var resultado = new List<MetricsSnapshot>(_quantidade);
+            var inicio = (_proximo - _quantidade + Capacidade) % Capacidade;
+
+            for (var i = 0; i < _quantidade; i++)
+            {
+                var item = _itens[(inicio + i) % Capacidade];
+                if (item is not null)
+                    resultado.Add(item);
+            }
+
+            return resultado;
+        }
+    }
+
+    /// <summary>Os ultimos N segundos, para o grafico e para as regras de duracao.</summary>
+    public IReadOnlyList<MetricsSnapshot> Ultimos(TimeSpan janela)
+    {
+        var todos = Todos();
+        if (todos.Count == 0)
+            return todos;
+
+        var corte = todos[^1].Momento - janela;
+        return todos.Where(s => s.Momento >= corte).ToList();
+    }
+
+    public void Limpar()
+    {
+        lock (_gate)
+        {
+            Array.Clear(_itens);
+            _proximo = 0;
+            _quantidade = 0;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsSnapshot.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsSnapshot.cs
new file mode 100644
index 0000000..ac82ad4
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/MetricsSnapshot.cs
@@ -0,0 +1,75 @@
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Valor que pode nao estar disponivel nesta maquina. Existe para a UI dizer
+/// "indisponivel" em vez de mostrar zero, que seria mentira (regra 4).
+/// </summary>
+public readonly record struct Medida(double Valor, bool Disponivel)
+{
+    public static Medida Indisponivel { get; } = new(0, false);
+
+    public static Medida De(double valor) => new(valor, true);
+
+    public double OuZero => Disponivel ? Valor : 0;
+
+    public override string ToString() => Disponivel ? Valor.ToString("0.0") : "indisponivel";
+}
+
+/// <summary>Consumo de um processo num instante.</summary>
+public sealed record ProcessUsage(
+    int Pid,
+    string Nome,
+    double CpuPercent,
+    long WorkingSetBytes,
+    long IoBytesPorSegundo,
+    int Instancias)
+{
+    public string NomeExibido => Instancias > 1 ? $"{Nome} ({Instancias})" : Nome;
+}
+
+/// <summary>Um instante completo da maquina. Imutavel: vai direto para o buffer.</summary>
+public sealed record MetricsSnapshot
+{
+    public required DateTimeOffset Momento { get; init; }
+
+    // CPU
+    public double CpuPercent { get; init; }
+    public Medida CpuFrequenciaPercent { get; init; } = Medida.Indisponivel;
+    public int NucleosLogicos { get; init; }
+
+    // Memoria
+    public long RamTotalBytes { get; init; }
+    public long RamDisponivelBytes { get; init; }
+    public long StandbyBytes { get; init; }
+    public long CommitBytes { get; init; }
+
+    // GPU
+    public Medida GpuPercent { get; init; } = Medida.Indisponivel;
+    public Medida GpuMemoriaBytes { get; init; } = Medida.Indisponivel;
+
+    // Disco
+    public Medida DiscoOcupadoPercent { get; init; } = Medida.Indisponivel;
+    public Medida DiscoBytesPorSegundo { get; init; } = Medida.Indisponivel;
+    public double DiscoSistemaUsadoPercent { get; init; }
+
+    // Rede
+    public Medida RedeBytesPorSegundo { get; init; } = Medida.Indisponivel;
+
+    // Temperaturas
+    public Medida TemperaturaCpu { get; init; } = Medida.Indisponivel;
+    public Medida TemperaturaGpu { get; init; } = Medida.Indisponivel;
+
+    public IReadOnlyList<ProcessUsage> Processos { get; init; } = Array.Empty<ProcessUsage>();
+
+    public double RamUsadaPercent => RamTotalBytes == 0
+        ? 0
+        : (RamTotalBytes - RamDisponivelBytes) * 100.0 / RamTotalBytes;
+
+    public double RamDisponivelPercent => RamTotalBytes == 0
+        ? 0
+        : RamDisponivelBytes * 100.0 / RamTotalBytes;
+
+    public double StandbyPercent => RamTotalBytes == 0
+        ? 0
+        : StandbyBytes * 100.0 / RamTotalBytes;
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeConfiguracao.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeConfiguracao.cs
new file mode 100644
index 0000000..e3ab921
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeConfiguracao.cs
@@ -0,0 +1,291 @@
+namespace GameBoost.Core.Modules.Bottleneck.Rules;
+
+/// <summary>"Plano Balanceado ativo durante o jogo" — item nº 1 do consenso de 2026.</summary>
+public sealed class PlanoDeEnergiaBalanceadoRule : IFindingRule
+{
+    public string Id => "plano-balanceado";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Fatos.PlanoEhBalanceado)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = ctx.EmJogo
+                ? "Plano de energia Balanceado ativo durante o jogo"
+                : "Plano de energia Balanceado ativo",
+            Detalhe = "No modo Balanceado a CPU baixa o clock quando acha que pode. Alto desempenho evita "
+                    + "isso e e o ajuste de maior ganho real, alem de ser o mais facil de desfazer.",
+            Severidade = ctx.EmJogo ? FindingSeverity.Atencao : FindingSeverity.Informativo,
+            Impacto = ctx.EmJogo ? 80 : 45,
+            Acao = FindingAcao.AtivarAltoDesempenho,
+            TextoDaAcao = "Ativar Alto desempenho",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 20,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Driver NVIDIA de fev/2026" — driver velho. Nunca instala nada.</summary>
+public sealed class DriverDeVideoAntigoRule : IFindingRule
+{
+    public const int MesesLimite = 6;
+
+    public string Id => "driver-antigo";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (ctx.Fatos.DataDoDriver is not { } data)
+            return null;
+
+        var meses = (int)((ctx.Atual.Momento - data).TotalDays / 30.0);
+        if (meses < MesesLimite)
+            return null;
+
+        var fabricante = ctx.Fatos.FabricanteDaGpu ?? "de video";
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"Driver {fabricante} com {meses} meses",
+            Detalhe = $"Instalado em {data:MM/yyyy}. Driver atualizado costuma render FPS em jogos novos. "
+                    + "O GameBoost nunca instala driver sozinho: abre a pagina oficial do fabricante.",
+            Severidade = FindingSeverity.Atencao,
+            Impacto = 50,
+            Acao = FindingAcao.AbrirSiteDoDriver,
+            TextoDaAcao = "Abrir pagina oficial",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 15,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"23 programas iniciam com o Windows".</summary>
+public sealed class InicializacaoLotadaRule : IFindingRule
+{
+    public const int Limite = 12;
+
+    public string Id => "inicializacao-lotada";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        var quantidade = ctx.Fatos.ItensNaInicializacao;
+        if (quantidade < Limite)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"{quantidade} programas iniciam com o Windows",
+            Detalhe = "Podar a inicializacao e, junto com o plano de energia, o ajuste de maior valor e o "
+                    + "mais facil de reverter. Cada item desativado tambem libera RAM o dia inteiro.",
+            Severidade = quantidade >= 20 ? FindingSeverity.Atencao : FindingSeverity.Informativo,
+            Impacto = Math.Min(quantidade * 3, 65),
+            Acao = FindingAcao.AbrirInicializacao,
+            TextoDaAcao = "Abrir Inicializacao",
+            Area = HealthArea.Inicializacao,
+            Penalidade = Math.Min((quantidade - Limite) * 4, 40),
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Gravacao em segundo plano ativa" — Game DVR ligado.</summary>
+public sealed class GravacaoEmSegundoPlanoRule : IFindingRule
+{
+    public string Id => "game-dvr-ativo";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Fatos.GameDvrAtivo && !ctx.Fatos.GameBarOverlayAtivo)
+            return null;
+
+        var oQue = ctx.Fatos.GameDvrAtivo && ctx.Fatos.GameBarOverlayAtivo
+            ? "A gravacao em segundo plano e o overlay da Game Bar estao ligados"
+            : ctx.Fatos.GameDvrAtivo
+                ? "A gravacao em segundo plano esta ligada"
+                : "O overlay da Game Bar esta ligado";
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = "Gravacao em segundo plano ativa",
+            Detalhe = $"{oQue}. Consome CPU e GPU o tempo todo, mesmo sem voce gravar nada. "
+                    + "O Modo Game desliga e devolve ao sair.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 35,
+            Acao = FindingAcao.AbrirModoGame,
+            TextoDaAcao = "Desativar no Modo Game",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 10,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>
+/// "A atualizacao 26H2 desfez 4 ajustes seus" — o diferencial que nenhum
+/// concorrente tem (secao 3.6).
+/// </summary>
+public sealed class PerfilDesfeitoPorUpdateRule : IFindingRule
+{
+    public string Id => "perfil-desfeito-por-update";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        var fatos = ctx.Fatos;
+
+        if (string.IsNullOrEmpty(fatos.BuildDoWindows) || string.IsNullOrEmpty(fatos.BuildAnteriormenteVisto))
+            return null;
+
+        if (fatos.BuildDoWindows == fatos.BuildAnteriormenteVisto)
+            return null;
+
+        if (fatos.TweaksDesfeitosPorUpdate <= 0)
+            return null;
+
+        var plural = fatos.TweaksDesfeitosPorUpdate == 1 ? "ajuste seu" : "ajustes seus";
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"A atualizacao {fatos.BuildDoWindows} desfez {fatos.TweaksDesfeitosPorUpdate} {plural}",
+            Detalhe = "Atualizacoes grandes do Windows resetam Game Mode, plano de energia, efeitos visuais e "
+                    + "Game Bar. O GameBoost guardou como estava e pode reaplicar.",
+            Severidade = FindingSeverity.Atencao,
+            Impacto = 75,
+            Acao = FindingAcao.ReaplicarPerfil,
+            TextoDaAcao = "Reaplicar perfil",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 15,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Seu monitor de 165 Hz esta em 60 Hz" — acontece muito apos troca de driver.</summary>
+public sealed class MonitorEmTaxaBaixaRule : IFindingRule
+{
+    public string Id => "monitor-taxa-baixa";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        var atual = ctx.Fatos.TaxaDeAtualizacaoAtual;
+        var maxima = ctx.Fatos.TaxaDeAtualizacaoMaxima;
+
+        if (atual <= 0 || maxima <= 0 || atual >= maxima)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"Seu monitor de {maxima} Hz esta em {atual} Hz",
+            Detalhe = "O Windows costuma voltar para 60 Hz depois de atualizar driver ou trocar de cabo. "
+                    + "Corrigir isso e o ganho de fluidez mais barato que existe.",
+            Severidade = FindingSeverity.Atencao,
+            Impacto = 88,
+            Acao = FindingAcao.AbrirConfiguracoesDeVideo,
+            TextoDaAcao = "Abrir configuracoes de video",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 20,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>
+/// "Isolamento do nucleo ativo" — informa e mede, nunca desliga (secao 3.4).
+/// </summary>
+public sealed class VbsAtivoRule : IFindingRule
+{
+    public string Id => "vbs-ativo";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Fatos.VbsAtivo)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = "Isolamento do nucleo (VBS) ativo",
+            Detalhe = "Vem ligado por padrao no Windows 11 e a comunidade mede de 5 a 15% de FPS em jogos "
+                    + "limitados por CPU. E protecao real contra malware de kernel: vale desligar so em PC "
+                    + "exclusivo de jogo, nunca em maquina de trabalho ou banco. O GameBoost nao altera isto; "
+                    + "a decisao e sua, nas Configuracoes do Windows.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 25,
+            Acao = FindingAcao.AbrirSegurancaDoWindows,
+            TextoDaAcao = "Abrir Seguranca do Windows",
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 0,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Jogo instalado em HDD. Mova para SSD".</summary>
+public sealed class JogoEmHddRule : IFindingRule
+{
+    public string Id => "jogo-em-hdd";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Fatos.JogoEmHdd)
+            return null;
+
+        var nome = ctx.Fatos.JogoEmHddNome ?? "Um jogo";
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"{nome} esta instalado em HDD",
+            Detalhe = "Lancamentos de 2025 e 2026 assumem SSD e engasgam em disco mecanico, principalmente ao "
+                    + "carregar textura. Mover para SSD resolve engasgo que nenhum ajuste de software resolve.",
+            Severidade = FindingSeverity.Atencao,
+            Impacto = 72,
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 15,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>Memoria em single channel: metade da banda, sem custo nenhum para descobrir.</summary>
+public sealed class MemoriaSingleChannelRule : IFindingRule
+{
+    public string Id => "memoria-single-channel";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (ctx.Fatos.PentesDeMemoria != 1)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = "Memoria em canal unico",
+            Detalhe = "Ha um unico pente de RAM instalado. Com dois pentes iguais em canal duplo, a banda de "
+                    + "memoria dobra, e isso costuma render FPS de verdade em jogos limitados por CPU e em "
+                    + "notebooks com video integrado.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 55,
+            Area = HealthArea.ConfiguracaoParaJogos,
+            Penalidade = 10,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeRecurso.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeRecurso.cs
new file mode 100644
index 0000000..2241d81
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/Rules/RegrasDeRecurso.cs
@@ -0,0 +1,316 @@
+namespace GameBoost.Core.Modules.Bottleneck.Rules;
+
+/// <summary>Formatacao compartilhada pelas regras. Texto para gente, nao para log.</summary>
+internal static class Fmt
+{
+    public static string Bytes(long bytes) => GameMode.GameModeModule.Formatar(bytes);
+
+    public static string Bytes(double bytes) => GameMode.GameModeModule.Formatar((long)bytes);
+
+    public static string Percent(double valor) => $"{valor:0}%";
+}
+
+/// <summary>"Chrome esta usando 38% da CPU" — processo pesado fora do jogo.</summary>
+public sealed class ProcessoDevorandoCpuRule : IFindingRule
+{
+    public const double Limite = 25.0;
+    private static readonly TimeSpan Janela = TimeSpan.FromSeconds(30);
+
+    public string Id => "processo-cpu-alta";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        var vilao = ctx.Atual.Processos
+            .Where(p => p.CpuPercent >= Limite)
+            .Where(p => !EhOJogo(p, ctx))
+            .MaxBy(p => p.CpuPercent);
+
+        if (vilao is null)
+            return null;
+
+        // Um pico de 1 segundo nao e problema. So vale se persistir.
+        var sustentado = ctx.SustentadoPor(Janela,
+            s => s.Processos.Any(p => p.Nome.Equals(vilao.Nome, StringComparison.OrdinalIgnoreCase)
+                                   && p.CpuPercent >= Limite));
+
+        if (!sustentado)
+            return null;
+
+        var instancias = vilao.Instancias > 1 ? $" em {vilao.Instancias} processos" : string.Empty;
+
+        return new Finding
+        {
+            Id = $"{Id}:{vilao.Nome}",
+            RegraId = Id,
+            Titulo = $"{vilao.Nome} esta usando {Fmt.Percent(vilao.CpuPercent)} da CPU",
+            Detalhe = $"Ha pelo menos 30 segundos{instancias}, ocupando {Fmt.Bytes(vilao.WorkingSetBytes)} de RAM. "
+                    + "Fechar antes de jogar libera CPU para o jogo.",
+            Severidade = vilao.CpuPercent >= 50 ? FindingSeverity.Critico : FindingSeverity.Atencao,
+            Impacto = (int)vilao.CpuPercent,
+            Acao = FindingAcao.AbrirModoGame,
+            TextoDaAcao = "Ver no Modo Game",
+            Area = HealthArea.Desempenho,
+            Penalidade = vilao.CpuPercent >= 50 ? 20 : 10,
+            Momento = ctx.Atual.Momento
+        };
+    }
+
+    private static bool EhOJogo(ProcessUsage p, FindingContext ctx)
+        => ctx.JogoEmExecucao is not null
+           && p.Nome.Equals(ctx.JogoEmExecucao, StringComparison.OrdinalIgnoreCase);
+}
+
+/// <summary>"So 1,2 GB de RAM livre" — memoria no limite.</summary>
+public sealed class RamNoLimiteRule : IFindingRule
+{
+    public const double LimitePercent = 10.0;
+
+    public string Id => "ram-no-limite";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (ctx.Atual.RamTotalBytes == 0 || ctx.Atual.RamDisponivelPercent >= LimitePercent)
+            return null;
+
+        var maiores = ctx.Atual.Processos
+            .OrderByDescending(p => p.WorkingSetBytes)
+            .Take(2)
+            .ToList();
+
+        var culpados = maiores.Count == 2
+            ? $"{maiores[0].Nome} e {maiores[1].Nome} usam {Fmt.Bytes(maiores[0].WorkingSetBytes + maiores[1].WorkingSetBytes)}."
+            : string.Empty;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"So {Fmt.Bytes(ctx.Atual.RamDisponivelBytes)} de RAM livre",
+            Detalhe = $"{Fmt.Percent(ctx.Atual.RamUsadaPercent)} da memoria em uso. {culpados}".Trim(),
+            Severidade = FindingSeverity.Critico,
+            Impacto = 90,
+            Acao = FindingAcao.LimparRam,
+            TextoDaAcao = "Limpar RAM",
+            Area = HealthArea.Desempenho,
+            Penalidade = 25,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"6 GB de RAM presos em cache do sistema" — Standby List inchada.</summary>
+public sealed class StandbyListInchadaRule : IFindingRule
+{
+    public const double LimitePercent = 40.0;
+
+    public string Id => "standby-inchada";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (ctx.Atual.StandbyBytes == 0 || ctx.Atual.StandbyPercent < LimitePercent)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"{Fmt.Bytes(ctx.Atual.StandbyBytes)} de RAM presos em cache do sistema",
+            Detalhe = "A Standby List guarda dados ja usados por precaucao. Liberar ajuda quando falta RAM, "
+                    + "mas nao aumenta FPS por si so.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 40,
+            Acao = FindingAcao.PurgarStandby,
+            TextoDaAcao = "Purgar Standby",
+            Area = HealthArea.Desempenho,
+            Penalidade = 5,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"C: com 94% de uso" — disco do sistema cheio.</summary>
+public sealed class DiscoDoSistemaCheioRule : IFindingRule
+{
+    public const double LimitePercent = 90.0;
+
+    public string Id => "disco-cheio";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (ctx.Atual.DiscoSistemaUsadoPercent < LimitePercent)
+            return null;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"Disco do sistema com {Fmt.Percent(ctx.Atual.DiscoSistemaUsadoPercent)} de uso",
+            Detalhe = "SSD muito cheio perde desempenho de escrita, e o Windows precisa de espaco livre "
+                    + "para arquivo de paginacao e atualizacoes.",
+            Severidade = ctx.Atual.DiscoSistemaUsadoPercent >= 95 ? FindingSeverity.Critico : FindingSeverity.Atencao,
+            Impacto = 70,
+            Acao = FindingAcao.AbrirAnalisadorDeDisco,
+            TextoDaAcao = "Ver o que ocupa espaco",
+            Area = HealthArea.Espaco,
+            Penalidade = ctx.Atual.DiscoSistemaUsadoPercent >= 95 ? 40 : 20,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"GPU no maximo" — o gargalo e a placa de video.</summary>
+public sealed class GpuNoLimiteRule : IFindingRule
+{
+    public const double LimitePercent = 95.0;
+
+    public string Id => "gpu-no-limite";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Atual.GpuPercent.Disponivel || ctx.Atual.GpuPercent.Valor < LimitePercent)
+            return null;
+
+        if (!ctx.SustentadoPor(TimeSpan.FromSeconds(20),
+                s => s.GpuPercent.Disponivel && s.GpuPercent.Valor >= LimitePercent))
+        {
+            return null;
+        }
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = "Placa de video no limite",
+            Detalhe = "A GPU esta em 100%. Se o FPS estiver baixo, o caminho e reduzir resolucao ou "
+                    + "qualidade grafica, ou ligar DLSS/FSR. Fechar programas nao ajuda neste caso.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 60,
+            Area = HealthArea.Desempenho,
+            Penalidade = 0,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Gargalo de CPU: o processador nao alimenta a placa de video".</summary>
+public sealed class GargaloDeCpuEmJogoRule : IFindingRule
+{
+    public string Id => "gargalo-cpu-em-jogo";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.EmJogo || !ctx.Atual.GpuPercent.Disponivel)
+            return null;
+
+        if (ctx.Atual.CpuPercent < 95 || ctx.Atual.GpuPercent.Valor >= 60)
+            return null;
+
+        if (!ctx.SustentadoPor(TimeSpan.FromSeconds(15),
+                s => s.CpuPercent >= 90 && s.GpuPercent.Disponivel && s.GpuPercent.Valor < 70))
+        {
+            return null;
+        }
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = "Gargalo de CPU",
+            Detalhe = $"A CPU esta em {Fmt.Percent(ctx.Atual.CpuPercent)} e a GPU em "
+                    + $"{Fmt.Percent(ctx.Atual.GpuPercent.Valor)}: o processador nao consegue preparar quadros "
+                    + "rapido o suficiente e a placa de video fica esperando. Fechar apps em segundo plano ajuda.",
+            Severidade = FindingSeverity.Atencao,
+            Impacto = 85,
+            Acao = FindingAcao.AbrirModoGame,
+            TextoDaAcao = "Abrir Modo Game",
+            Area = HealthArea.Desempenho,
+            Penalidade = 15,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"CPU a 97 graus reduzindo clock" — throttling termico.</summary>
+public sealed class ThrottlingTermicoRule : IFindingRule
+{
+    public const double LimiteTemperatura = 90.0;
+
+    public string Id => "throttling-termico";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        if (!ctx.Atual.TemperaturaCpu.Disponivel || ctx.Atual.TemperaturaCpu.Valor < LimiteTemperatura)
+            return null;
+
+        if (ctx.Atual.CpuPercent < 70)
+            return null;
+
+        var frequencia = ctx.Atual.CpuFrequenciaPercent;
+        var reduzindo = frequencia.Disponivel && frequencia.Valor < 80;
+
+        return new Finding
+        {
+            Id = Id,
+            RegraId = Id,
+            Titulo = $"CPU a {ctx.Atual.TemperaturaCpu.Valor:0} graus",
+            Detalhe = reduzindo
+                ? "O processador esta reduzindo a velocidade para nao superaquecer. Sinal de cooler sujo "
+                + "ou pasta termica velha."
+                : "Temperatura alta sob carga. Se o FPS cair de repente durante o jogo, o motivo e este.",
+            Severidade = FindingSeverity.Critico,
+            Impacto = 95,
+            Area = HealthArea.Desempenho,
+            Penalidade = 20,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
+
+/// <summary>"Windows Defender fazendo varredura completa" — informativo, nunca desativar.</summary>
+public sealed class ProcessoDeSistemaOcupandoDiscoRule : IFindingRule
+{
+    private static readonly IReadOnlyDictionary<string, string> Conhecidos =
+        new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["MsMpEng"] = "O Windows Defender esta varrendo arquivos",
+            ["SearchIndexer"] = "O Windows Search esta indexando arquivos",
+            ["SearchHost"] = "A busca do Windows esta trabalhando",
+            ["TiWorker"] = "O Windows esta instalando uma atualizacao",
+            ["TrustedInstaller"] = "O Windows esta instalando uma atualizacao",
+            ["wuauclt"] = "O Windows Update esta trabalhando",
+            ["CompatTelRunner"] = "O Windows esta coletando dados de compatibilidade"
+        };
+
+    public string Id => "sistema-ocupando-disco";
+
+    public Finding? Avaliar(FindingContext ctx)
+    {
+        var culpado = ctx.Atual.Processos
+            .Where(p => Conhecidos.ContainsKey(p.Nome) && p.CpuPercent >= 8)
+            .MaxBy(p => p.CpuPercent);
+
+        if (culpado is null)
+            return null;
+
+        if (!ctx.SustentadoPor(TimeSpan.FromSeconds(20),
+                s => s.Processos.Any(p => p.Nome.Equals(culpado.Nome, StringComparison.OrdinalIgnoreCase)
+                                       && p.CpuPercent >= 5)))
+        {
+            return null;
+        }
+
+        return new Finding
+        {
+            Id = $"{Id}:{culpado.Nome}",
+            RegraId = Id,
+            Titulo = Conhecidos[culpado.Nome],
+            Detalhe = $"Usando {Fmt.Percent(culpado.CpuPercent)} da CPU. E uma tarefa normal do Windows e "
+                    + "termina sozinha. O GameBoost nao desativa protecao nem atualizacao.",
+            Severidade = FindingSeverity.Informativo,
+            Impacto = 30,
+            Area = HealthArea.Desempenho,
+            Penalidade = 0,
+            Momento = ctx.Atual.Momento
+        };
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/SystemFactsReader.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/SystemFactsReader.cs
new file mode 100644
index 0000000..bb14354
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/SystemFactsReader.cs
@@ -0,0 +1,352 @@
+using System.Management;
+using System.Runtime.InteropServices;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Services;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+/// <summary>
+/// Le os fatos que nao mudam a cada segundo: plano de energia, driver de video,
+/// taxa do monitor, VBS, pentes de memoria, build do Windows.
+///
+/// Roda em cache com validade propria para nao pagar WMI a cada tique da coleta.
+/// </summary>
+public sealed class SystemFactsReader
+{
+    private static readonly TimeSpan Validade = TimeSpan.FromMinutes(2);
+
+    private readonly IPowerService _power;
+    private readonly IRegistryService _registro;
+    private readonly ISettingsStore _settingsStore;
+    private readonly AppSettings _settings;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    private SystemFacts? _cache;
+    private DateTimeOffset _lidoEm;
+
+    public SystemFactsReader(
+        IPowerService power,
+        IRegistryService registro,
+        ISettingsStore settingsStore,
+        AppSettings settings,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _power = power;
+        _registro = registro;
+        _settingsStore = settingsStore;
+        _settings = settings;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public SystemFacts Ler(bool forcar = false)
+    {
+        if (!forcar && _cache is not null && _relogio.Now - _lidoEm < Validade)
+            return _cache;
+
+        var plano = Seguro(() => _power.GetActivePlan(), null);
+        var (fabricante, versao, data) = LerDriverDeVideo();
+        var (atual, maxima) = LerTaxaDeAtualizacao();
+        var build = LerBuildDoWindows();
+
+        var fatos = new SystemFacts
+        {
+            PlanoDeEnergiaAtivo = plano?.Id,
+            NomeDoPlanoDeEnergia = plano?.Name,
+            PlanoEhBalanceado = plano is not null && plano.Id == WindowsPowerService.Balanceado,
+
+            BuildDoWindows = build,
+            BuildAnteriormenteVisto = _settings.UltimaBuildDoWindows,
+            TweaksDesfeitosPorUpdate = ContarTweaksDesfeitos(build),
+
+            FabricanteDaGpu = fabricante,
+            VersaoDoDriver = versao,
+            DataDoDriver = data,
+
+            TaxaDeAtualizacaoAtual = atual,
+            TaxaDeAtualizacaoMaxima = maxima,
+
+            VbsAtivo = LerVbs(),
+            GameDvrAtivo = LerDword(RegistryRoot.CurrentUser, @"System\GameConfigStore", "GameDVR_Enabled") != 0,
+            GameBarOverlayAtivo = LerDword(RegistryRoot.CurrentUser, @"Software\Microsoft\GameBar", "UseNexusForGameBarEnabled") != 0,
+
+            ItensNaInicializacao = ContarItensDeInicializacao(),
+            PentesDeMemoria = ContarPentesDeMemoria()
+        };
+
+        _cache = fatos;
+        _lidoEm = _relogio.Now;
+
+        // Guarda a build para a proxima execucao comparar.
+        if (!string.IsNullOrEmpty(build) && _settings.UltimaBuildDoWindows != build)
+        {
+            _settings.UltimaBuildDoWindows = build;
+            Seguro<object?>(() => { _settingsStore.Save(_settings); return null; }, null);
+        }
+
+        return fatos;
+    }
+
+    /// <summary>
+    /// Quantos tweaks do GameBoost nao batem mais com o que ele aplicou. Uma
+    /// atualizacao grande do Windows reseta Game Mode, Game DVR e Game Bar.
+    /// </summary>
+    private int ContarTweaksDesfeitos(string? buildAtual)
+    {
+        if (string.IsNullOrEmpty(buildAtual)
+            || string.IsNullOrEmpty(_settings.UltimaBuildDoWindows)
+            || _settings.UltimaBuildDoWindows == buildAtual)
+        {
+            return 0;
+        }
+
+        var desfeitos = 0;
+        foreach (var tweak in GameMode.SystemSilencer.Tweaks)
+        {
+            var valor = _registro.GetValue(tweak.Root, tweak.SubKey, tweak.ValueName);
+            if (valor is int atual && atual != tweak.ValorDesejado)
+                desfeitos++;
+        }
+
+        return desfeitos;
+    }
+
+    private int LerDword(RegistryRoot root, string chave, string valor)
+    {
+        var lido = Seguro(() => _registro.GetValue(root, chave, valor), null);
+        return lido is int i ? i : -1;
+    }
+
+    private bool LerVbs()
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher(
+                @"root\Microsoft\Windows\DeviceGuard",
+                "SELECT SecurityServicesRunning FROM Win32_DeviceGuard");
+
+            foreach (var item in consulta.Get())
+            {
+                using var mo = (ManagementObject)item;
+                if (mo["SecurityServicesRunning"] is not uint[] servicos)
+                    continue;
+
+                // 1 = Credential Guard, 2 = HVCI (Memory Integrity).
+                if (servicos.Contains(2u))
+                    return true;
+            }
+        }
+        catch (Exception ex) when (ex is ManagementException or UnauthorizedAccessException)
+        {
+            _log.Warn("Bottleneck", "VBS", null, $"Win32_DeviceGuard indisponivel: {ex.Message}");
+        }
+
+        return false;
+    }
+
+    private (string? Fabricante, string? Versao, DateTimeOffset? Data) LerDriverDeVideo()
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher(
+                "SELECT Name, DriverVersion, DriverDate FROM Win32_VideoController");
+
+            foreach (var item in consulta.Get())
+            {
+                using var mo = (ManagementObject)item;
+                var nome = mo["Name"] as string ?? string.Empty;
+
+                // Ignora adaptadores virtuais (RDP, Parsec, Meta).
+                if (nome.Contains("Remote", StringComparison.OrdinalIgnoreCase)
+                    || nome.Contains("Virtual", StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                var fabricante = nome.Contains("NVIDIA", StringComparison.OrdinalIgnoreCase) ? "NVIDIA"
+                    : nome.Contains("AMD", StringComparison.OrdinalIgnoreCase) || nome.Contains("Radeon", StringComparison.OrdinalIgnoreCase) ? "AMD"
+                    : nome.Contains("Intel", StringComparison.OrdinalIgnoreCase) ? "Intel"
+                    : null;
+
+                DateTimeOffset? data = null;
+                if (mo["DriverDate"] is string bruto && bruto.Length >= 8)
+                {
+                    // WMI datetime: yyyyMMddHHmmss.ffffff+UUU
+                    if (DateTime.TryParseExact(bruto[..8], "yyyyMMdd", null,
+                            System.Globalization.DateTimeStyles.None, out var parseada))
+                    {
+                        data = new DateTimeOffset(parseada, TimeSpan.Zero);
+                    }
+                }
+
+                return (fabricante, mo["DriverVersion"] as string, data);
+            }
+        }
+        catch (Exception ex) when (ex is ManagementException or UnauthorizedAccessException)
+        {
+            _log.Warn("Bottleneck", "Driver", null, ex.Message);
+        }
+
+        return (null, null, null);
+    }
+
+    // ---------------- Monitor ----------------
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct DEVMODE
+    {
+        private const int CCHDEVICENAME = 32;
+        private const int CCHFORMNAME = 32;
+
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHDEVICENAME)]
+        public string dmDeviceName;
+        public ushort dmSpecVersion;
+        public ushort dmDriverVersion;
+        public ushort dmSize;
+        public ushort dmDriverExtra;
+        public uint dmFields;
+        public int dmPositionX;
+        public int dmPositionY;
+        public uint dmDisplayOrientation;
+        public uint dmDisplayFixedOutput;
+        public short dmColor;
+        public short dmDuplex;
+        public short dmYResolution;
+        public short dmTTOption;
+        public short dmCollate;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCHFORMNAME)]
+        public string dmFormName;
+        public ushort dmLogPixels;
+        public uint dmBitsPerPel;
+        public uint dmPelsWidth;
+        public uint dmPelsHeight;
+        public uint dmDisplayFlags;
+        public uint dmDisplayFrequency;
+        public uint dmICMMethod;
+        public uint dmICMIntent;
+        public uint dmMediaType;
+        public uint dmDitherType;
+        public uint dmReserved1;
+        public uint dmReserved2;
+        public uint dmPanningWidth;
+        public uint dmPanningHeight;
+    }
+
+    private const int ENUM_CURRENT_SETTINGS = -1;
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern bool EnumDisplaySettingsW(string? deviceName, int modeNum, ref DEVMODE devMode);
+
+    /// <summary>
+    /// Taxa atual e a maior que o monitor aceita na resolucao em uso. O Windows
+    /// volta para 60 Hz com frequencia depois de atualizar driver.
+    /// </summary>
+    private (int Atual, int Maxima) LerTaxaDeAtualizacao()
+    {
+        try
+        {
+            var atual = new DEVMODE { dmSize = (ushort)Marshal.SizeOf<DEVMODE>() };
+            if (!EnumDisplaySettingsW(null, ENUM_CURRENT_SETTINGS, ref atual))
+                return (0, 0);
+
+            var taxaAtual = (int)atual.dmDisplayFrequency;
+            var maxima = taxaAtual;
+
+            for (var i = 0; ; i++)
+            {
+                var modo = new DEVMODE { dmSize = (ushort)Marshal.SizeOf<DEVMODE>() };
+                if (!EnumDisplaySettingsW(null, i, ref modo))
+                    break;
+
+                // So compara modos da resolucao em uso: 640x480 a 200 Hz nao conta.
+                if (modo.dmPelsWidth == atual.dmPelsWidth && modo.dmPelsHeight == atual.dmPelsHeight)
+                    maxima = Math.Max(maxima, (int)modo.dmDisplayFrequency);
+            }
+
+            return (taxaAtual, maxima);
+        }
+        catch (Exception ex) when (ex is EntryPointNotFoundException or DllNotFoundException)
+        {
+            return (0, 0);
+        }
+    }
+
+    private int ContarItensDeInicializacao()
+    {
+        var total = 0;
+
+        foreach (var (root, chave) in new[]
+                 {
+                     (RegistryRoot.CurrentUser, @"Software\Microsoft\Windows\CurrentVersion\Run"),
+                     (RegistryRoot.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"),
+                     (RegistryRoot.LocalMachine, @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run")
+                 })
+        {
+            total += Seguro(() => _registro.GetValueNames(root, chave).Count, 0);
+        }
+
+        foreach (var pasta in new[]
+                 {
+                     Environment.GetFolderPath(Environment.SpecialFolder.Startup),
+                     Environment.GetFolderPath(Environment.SpecialFolder.CommonStartup)
+                 })
+        {
+            total += Seguro(() =>
+            {
+                if (string.IsNullOrEmpty(pasta) || !Directory.Exists(pasta))
+                    return 0;
+
+                return Directory.EnumerateFiles(pasta)
+                    .Count(f => !f.EndsWith(".ini", StringComparison.OrdinalIgnoreCase));
+            }, 0);
+        }
+
+        return total;
+    }
+
+    private int ContarPentesDeMemoria()
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher("SELECT Capacity FROM Win32_PhysicalMemory");
+            return consulta.Get().Count;
+        }
+        catch (Exception ex) when (ex is ManagementException or UnauthorizedAccessException)
+        {
+            return 0;
+        }
+    }
+
+    private string? LerBuildDoWindows()
+    {
+        var chave = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion";
+        var display = Seguro(() => _registro.GetValue(RegistryRoot.LocalMachine, chave, "DisplayVersion"), null) as string;
+        var build = Seguro(() => _registro.GetValue(RegistryRoot.LocalMachine, chave, "CurrentBuildNumber"), null) as string;
+
+        if (!string.IsNullOrEmpty(display))
+            return display;
+
+        return string.IsNullOrEmpty(build) ? Environment.OSVersion.Version.Build.ToString() : build;
+    }
+
+    private T Seguro<T>(Func<T> acao, T padrao)
+    {
+        try
+        {
+            return acao();
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException
+                                      or ManagementException
+                                      or IOException
+                                      or InvalidOperationException
+                                      or System.Security.SecurityException)
+        {
+            _log.Warn("Bottleneck", "Fatos", null, ex.Message);
+            return padrao;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/TemperatureProvider.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/TemperatureProvider.cs
new file mode 100644
index 0000000..d0c5a7e
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/TemperatureProvider.cs
@@ -0,0 +1,75 @@
+using System.Management;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+public interface ITemperatureProvider
+{
+    Medida LerCpu();
+    Medida LerGpu();
+
+    /// <summary>Explica por que a temperatura nao esta disponivel, para a UI ser honesta.</summary>
+    string? MotivoIndisponivel { get; }
+}
+
+/// <summary>
+/// Temperatura pelo WMI (MSAcpi_ThermalZoneTemperature).
+///
+/// Funciona em parte das maquinas e so para a zona termica da placa-mae, que
+/// nem sempre acompanha o die da CPU. Placas de video nao aparecem aqui.
+/// A leitura boa depende de LibreHardwareMonitorLib, que precisa carregar um
+/// driver em modo kernel; fica para quando a Fase 1 estiver validada, e ate la
+/// a UI diz "indisponivel" em vez de inventar numero (regra 4).
+/// </summary>
+public sealed class WmiTemperatureProvider : ITemperatureProvider
+{
+    private readonly IGameBoostLogger _log;
+    private bool _tentou;
+
+    public WmiTemperatureProvider(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public string? MotivoIndisponivel { get; private set; } =
+        "Temperatura exige um driver de sensores. O Windows nao expoe o valor do die da CPU sem ele.";
+
+    public Medida LerCpu()
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher(
+                @"root\WMI", "SELECT CurrentTemperature FROM MSAcpi_ThermalZoneTemperature");
+
+            foreach (var item in consulta.Get())
+            {
+                using var mo = (ManagementObject)item;
+                var decimosDeKelvin = Convert.ToDouble(mo["CurrentTemperature"]);
+
+                // O WMI reporta em decimos de Kelvin.
+                var celsius = decimosDeKelvin / 10.0 - 273.15;
+
+                // Zona termica as vezes devolve valor absurdo; nao vale mentir.
+                if (celsius is > 0 and < 125)
+                {
+                    MotivoIndisponivel = null;
+                    return Medida.De(celsius);
+                }
+            }
+        }
+        catch (Exception ex) when (ex is ManagementException or UnauthorizedAccessException)
+        {
+            if (!_tentou)
+                _log.Warn("Bottleneck", "Temperatura", null, $"MSAcpi_ThermalZoneTemperature indisponivel: {ex.Message}");
+        }
+        finally
+        {
+            _tentou = true;
+        }
+
+        return Medida.Indisponivel;
+    }
+
+    /// <summary>Sem driver de sensores nao ha como ler a GPU. Honesto e dizer isso.</summary>
+    public Medida LerGpu() => Medida.Indisponivel;
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Bottleneck/WindowsMetricsCollector.cs b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/WindowsMetricsCollector.cs
new file mode 100644
index 0000000..eee9198
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Bottleneck/WindowsMetricsCollector.cs
@@ -0,0 +1,254 @@
+using System.Net.NetworkInformation;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.Bottleneck;
+
+public interface IMetricsCollector
+{
+    /// <summary>Um instante da maquina. A primeira chamada e so a linha de base dos deltas.</summary>
+    MetricsSnapshot Coletar();
+}
+
+/// <summary>
+/// Coleta um instante da maquina a cada chamada.
+///
+/// Tudo que tem API nativa usa API nativa (regra 9), e cada fonte falha de
+/// forma isolada: se a GPU nao puder ser lida, o resto do snapshot continua
+/// valido e a GPU vira "indisponivel" na UI, nunca zero (regra 4).
+/// </summary>
+public sealed class WindowsMetricsCollector : IMetricsCollector, IDisposable
+{
+    private readonly IMemoryService _memoria;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+    private readonly int _nucleos = Environment.ProcessorCount;
+
+    private SystemInformation.SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[] _cpuAnterior = Array.Empty<SystemInformation.SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION>();
+    private Dictionary<int, (TimeSpan Cpu, long Io)> _processosAnteriores = new();
+    private DateTimeOffset _momentoAnterior;
+    private long _redeAnterior = -1;
+
+    private readonly GpuCounterReader _gpu;
+    private readonly ITemperatureProvider _temperaturas;
+
+    public WindowsMetricsCollector(
+        IMemoryService memoria,
+        IGameBoostLogger log,
+        IClock relogio,
+        ITemperatureProvider? temperaturas = null)
+    {
+        _memoria = memoria;
+        _log = log;
+        _relogio = relogio;
+        _gpu = new GpuCounterReader(log);
+        _temperaturas = temperaturas ?? new WmiTemperatureProvider(log);
+    }
+
+    public MetricsSnapshot Coletar()
+    {
+        var agora = _relogio.Now;
+        var intervalo = _momentoAnterior == default
+            ? TimeSpan.Zero
+            : agora - _momentoAnterior;
+
+        var cpu = LerCpu();
+        var memoria = _memoria.GetSnapshot();
+        var standby = SystemInformation.LerStandbyList() ?? 0;
+        var processos = LerProcessos(intervalo);
+        var rede = LerRede(intervalo);
+        var disco = LerDiscoDoSistema();
+
+        _momentoAnterior = agora;
+
+        return new MetricsSnapshot
+        {
+            Momento = agora,
+            CpuPercent = cpu,
+            NucleosLogicos = _nucleos,
+            RamTotalBytes = memoria.TotalBytes,
+            RamDisponivelBytes = memoria.AvailableBytes,
+            StandbyBytes = standby,
+            GpuPercent = _gpu.LerUso(),
+            GpuMemoriaBytes = _gpu.LerMemoria(),
+            DiscoSistemaUsadoPercent = disco,
+            RedeBytesPorSegundo = rede,
+            TemperaturaCpu = _temperaturas.LerCpu(),
+            TemperaturaGpu = _temperaturas.LerGpu(),
+            Processos = processos
+        };
+    }
+
+    /// <summary>
+    /// Uso de CPU pelo delta de tempo ocioso: 100 - (idle / total). E como o
+    /// proprio Gerenciador de Tarefas calcula.
+    /// </summary>
+    private double LerCpu()
+    {
+        var atual = SystemInformation.LerTemposDeProcessador(_nucleos);
+        if (atual.Length == 0)
+            return 0;
+
+        if (_cpuAnterior.Length != atual.Length)
+        {
+            _cpuAnterior = atual;
+            return 0;
+        }
+
+        long idle = 0, total = 0;
+        for (var i = 0; i < atual.Length; i++)
+        {
+            var deltaIdle = atual[i].IdleTime - _cpuAnterior[i].IdleTime;
+            // KernelTime ja inclui o tempo ocioso.
+            var deltaTotal = (atual[i].KernelTime - _cpuAnterior[i].KernelTime)
+                           + (atual[i].UserTime - _cpuAnterior[i].UserTime);
+
+            idle += deltaIdle;
+            total += deltaTotal;
+        }
+
+        _cpuAnterior = atual;
+
+        if (total <= 0)
+            return 0;
+
+        var uso = 100.0 * (total - idle) / total;
+        return Math.Clamp(uso, 0, 100);
+    }
+
+    /// <summary>
+    /// CPU e memoria por processo, numa unica chamada ao kernel, agrupado por
+    /// nome: o Chrome com 40 processos vira uma linha so, que e o que o usuario
+    /// quer ver.
+    ///
+    /// Usa NtQuerySystemInformation em vez de Process.GetProcesses() por causa
+    /// do orcamento da secao 5.5. Ver Native/ProcessInformation.cs.
+    /// </summary>
+    private IReadOnlyList<ProcessUsage> LerProcessos(TimeSpan intervalo)
+    {
+        var brutos = ProcessInformation.Listar();
+
+        if (brutos.Count == 0)
+            return Array.Empty<ProcessUsage>();
+
+        var atuais = new Dictionary<int, (TimeSpan Cpu, long Io)>(brutos.Count);
+        var porNome = new Dictionary<string, (double Cpu, long Ram, long Io, int Qtd)>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var bruto in brutos)
+        {
+            if (bruto.Pid <= 4)
+                continue;
+
+            var cpuTotal = TimeSpan.FromTicks(bruto.TempoDeCpu100ns);
+            atuais[bruto.Pid] = (cpuTotal, 0);
+
+            double cpuPercent = 0;
+            if (intervalo > TimeSpan.Zero && _processosAnteriores.TryGetValue(bruto.Pid, out var antes))
+            {
+                var delta = (cpuTotal - antes.Cpu).TotalMilliseconds;
+
+                // Normaliza pelo numero de nucleos: 100% = a maquina inteira.
+                cpuPercent = delta / (intervalo.TotalMilliseconds * _nucleos) * 100.0;
+                cpuPercent = Math.Clamp(cpuPercent, 0, 100);
+            }
+
+            var nome = Safety.ProtectedProcesses.Normalizar(bruto.Nome);
+
+            if (porNome.TryGetValue(nome, out var acumulado))
+            {
+                porNome[nome] = (acumulado.Cpu + cpuPercent,
+                                 acumulado.Ram + bruto.WorkingSetBytes,
+                                 acumulado.Io,
+                                 acumulado.Qtd + 1);
+            }
+            else
+            {
+                porNome[nome] = (cpuPercent, bruto.WorkingSetBytes, 0, 1);
+            }
+        }
+
+        _processosAnteriores = atuais;
+
+        return porNome
+            .Select(kv => new ProcessUsage(0, kv.Key, kv.Value.Cpu, kv.Value.Ram, kv.Value.Io, kv.Value.Qtd))
+            .OrderByDescending(u => u.CpuPercent)
+            .ThenByDescending(u => u.WorkingSetBytes)
+            .ToList();
+    }
+
+    private NetworkInterface[]? _interfaces;
+    private DateTimeOffset _interfacesLidasEm;
+
+    private Medida LerRede(TimeSpan intervalo)
+    {
+        try
+        {
+            // Enumerar interfaces custa caro e a lista quase nunca muda:
+            // revalida a cada 30 s em vez de a cada segundo.
+            if (_interfaces is null || _relogio.Now - _interfacesLidasEm > TimeSpan.FromSeconds(30))
+            {
+                _interfaces = NetworkInterface.GetAllNetworkInterfaces()
+                    .Where(i => i.NetworkInterfaceType != NetworkInterfaceType.Loopback)
+                    .ToArray();
+                _interfacesLidasEm = _relogio.Now;
+            }
+
+            long total = 0;
+            foreach (var iface in _interfaces)
+            {
+                if (iface.OperationalStatus != OperationalStatus.Up)
+                    continue;
+
+                var stats = iface.GetIPStatistics();
+                total += stats.BytesReceived + stats.BytesSent;
+            }
+
+            if (_redeAnterior < 0 || intervalo <= TimeSpan.Zero)
+            {
+                _redeAnterior = total;
+                return Medida.Indisponivel;
+            }
+
+            var delta = total - _redeAnterior;
+            _redeAnterior = total;
+
+            // Contador reiniciou (interface caiu e voltou).
+            if (delta < 0)
+                return Medida.Indisponivel;
+
+            return Medida.De(delta / intervalo.TotalSeconds);
+        }
+        catch (NetworkInformationException ex)
+        {
+            _log.Warn("Bottleneck", "LerRede", null, ex.Message);
+            return Medida.Indisponivel;
+        }
+    }
+
+    private static double LerDiscoDoSistema()
+    {
+        try
+        {
+            var raiz = Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.Windows));
+            if (string.IsNullOrEmpty(raiz))
+                return 0;
+
+            var unidade = new DriveInfo(raiz);
+            if (!unidade.IsReady || unidade.TotalSize == 0)
+                return 0;
+
+            return (unidade.TotalSize - unidade.TotalFreeSpace) * 100.0 / unidade.TotalSize;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
+        {
+            return 0;
+        }
+    }
+
+    public void Dispose()
+    {
+        _gpu.Dispose();
+        (_temperaturas as IDisposable)?.Dispose();
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanerModule.cs b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanerModule.cs
new file mode 100644
index 0000000..1f2d714
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanerModule.cs
@@ -0,0 +1,485 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Native;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Cleaner;
+
+/// <summary>O que uma varredura encontrou num alvo.</summary>
+public sealed record AchadoDeLimpeza(
+    CleanupTarget Alvo,
+    IReadOnlyList<string> Arquivos,
+    long Bytes,
+    int Ignorados,
+    string? Bloqueio);
+
+/// <summary>
+/// Limpeza de temporários e caches (seção 5.2).
+///
+/// Duas camadas de proteção, sempre: o caminho precisa vir do
+/// <see cref="CleanupCatalog"/> e, mesmo assim, cada arquivo passa pelo
+/// SafetyGuard com a whitelist antes de ser removido. O módulo nunca deriva
+/// caminho por conta própria.
+/// </summary>
+public sealed class CleanerModule : IModule
+{
+    public const string ModuloId = "cleaner";
+
+    private readonly IFileSystem _fs;
+    private readonly IProcessService _processos;
+    private readonly IServiceControllerService _servicos;
+    private readonly ISafetyGuard _guard;
+    private readonly CleanupHistory _historico;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    private readonly Dictionary<string, AchadoDeLimpeza> _ultimaVarredura = new(StringComparer.OrdinalIgnoreCase);
+
+    public CleanerModule(
+        IFileSystem fs,
+        IProcessService processos,
+        IServiceControllerService servicos,
+        ISafetyGuard guard,
+        CleanupHistory historico,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _fs = fs;
+        _processos = processos;
+        _servicos = servicos;
+        _guard = guard;
+        _historico = historico;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Limpeza";
+    public string Descricao => "Libera espaço mostrando exatamente o que sai e quanto ocupa.";
+
+    // ------------------------------------------------------------------
+    // Varredura
+    // ------------------------------------------------------------------
+
+    public Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+        => Task.Run(() => Varrer(progress, ct), ct);
+
+    private ScanResult Varrer(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        var alvos = CleanupCatalog.Todos();
+
+        // Varredura pode LER onde a remocao nao pode apagar: e o que permite
+        // mostrar uma sugestao sem ganhar permissao de remover.
+        var whitelist = CleanupCatalog.RaizesParaMedir();
+        var abertos = ProcessosAbertos();
+
+        var itens = new List<ActionItem>();
+        var avisos = new List<string>();
+
+        _ultimaVarredura.Clear();
+
+        for (var i = 0; i < alvos.Count; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var alvo = alvos[i];
+            progress?.Report(new ModuleProgress(
+                $"Medindo {alvo.Titulo}", (int)(100.0 * i / alvos.Count)));
+
+            var achado = Medir(alvo, whitelist, abertos, ct);
+            if (achado is null)
+                continue;
+
+            _ultimaVarredura[alvo.Id] = achado;
+            itens.Add(MontarItem(achado));
+        }
+
+        var total = itens.Where(i => i.PreMarcado).Sum(i => i.GanhoBytes);
+        var totalGeral = _ultimaVarredura.Values
+            .Where(a => !a.Alvo.ApenasSugestao)
+            .Sum(a => a.Bytes);
+
+        if (itens.Count == 0)
+            avisos.Add("Nada encontrado para limpar. A máquina já está em dia.");
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens.OrderByDescending(i => i.GanhoBytes).ToList(),
+            Momento = _relogio.Now,
+            Avisos = avisos,
+            Resumo = itens.Count == 0
+                ? "Nada para limpar."
+                : $"Até {GameModeModule.Formatar(total)} liberáveis com o que está marcado, "
+                + $"{GameModeModule.Formatar(totalGeral)} no total encontrado."
+        };
+    }
+
+    private AchadoDeLimpeza? Medir(
+        CleanupTarget alvo,
+        IReadOnlyList<string> whitelist,
+        IReadOnlySet<string> abertos,
+        CancellationToken ct)
+    {
+        var raiz = alvo.Raiz();
+
+        if (string.IsNullOrWhiteSpace(raiz) || !_fs.DirectoryExists(raiz))
+            return null;
+
+        // Primeira camada: o proprio caminho do catalogo precisa passar.
+        var veredito = _guard.CheckPath(raiz, whitelist);
+        if (veredito.Protegido)
+        {
+            _log.Warn(ModuloId, "Medir", raiz, $"alvo recusado pela blindagem: {veredito.Explicacao}");
+            return null;
+        }
+
+        var bloqueio = alvo.ExigeFechado
+            .Where(p => abertos.Contains(p))
+            .Select(p => $"Feche o {p} antes: o cache está em uso.")
+            .FirstOrDefault();
+
+        var arquivos = new List<string>();
+        long bytes = 0;
+        var ignorados = 0;
+        var corte = _relogio.Now - alvo.IdadeMinima;
+
+        try
+        {
+            var opcao = alvo.Recursivo ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+
+            foreach (var arquivo in _fs.EnumerateFiles(raiz, alvo.Padrao, opcao))
+            {
+                ct.ThrowIfCancellationRequested();
+
+                // Segunda camada: cada arquivo, um por um.
+                if (_guard.CheckPath(arquivo, whitelist).Protegido)
+                {
+                    ignorados++;
+                    continue;
+                }
+
+                try
+                {
+                    if (alvo.IdadeMinima > TimeSpan.Zero)
+                    {
+                        var escrito = File.GetLastWriteTimeUtc(arquivo);
+                        if (escrito > corte.UtcDateTime)
+                        {
+                            ignorados++;
+                            continue;
+                        }
+                    }
+
+                    bytes += _fs.GetFileSize(arquivo);
+                    arquivos.Add(arquivo);
+                }
+                catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+                {
+                    ignorados++;
+                }
+            }
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or DirectoryNotFoundException or IOException)
+        {
+            _log.Warn(ModuloId, "Medir", raiz, ex.Message);
+            return null;
+        }
+
+        if (arquivos.Count == 0)
+            return null;
+
+        return new AchadoDeLimpeza(alvo, arquivos, bytes, ignorados, bloqueio);
+    }
+
+    private ActionItem MontarItem(AchadoDeLimpeza achado)
+    {
+        var alvo = achado.Alvo;
+
+        var descricao = $"{achado.Arquivos.Count} arquivos, {GameModeModule.Formatar(achado.Bytes)}.";
+
+        if (achado.Ignorados > 0)
+            descricao += $" {achado.Ignorados} ignorados (em uso, recentes ou protegidos).";
+
+        if (alvo.Advertencia is not null)
+            descricao += $" {alvo.Advertencia}";
+
+        var bloqueado = achado.Bloqueio is not null || alvo.ApenasSugestao;
+
+        var comoDesfazer = alvo.Modo == RemocaoModo.Lixeira
+            ? alvo.ComoDesfazer + " Os arquivos vão para a Lixeira, então dá para recuperar."
+            : alvo.ComoDesfazer;
+
+        return new ActionItem
+        {
+            Id = $"clean:{alvo.Id}",
+            Categoria = alvo.Categoria,
+            Titulo = alvo.Titulo,
+            Descricao = descricao,
+            Risco = alvo.Risco,
+            GanhoBytes = achado.Bytes,
+            GanhoEstimado = GameModeModule.Formatar(achado.Bytes),
+            PreMarcado = alvo.PreMarcadoPadrao && !bloqueado,
+            Bloqueado = bloqueado,
+            MotivoBloqueio = achado.Bloqueio
+                ?? (alvo.ApenasSugestao ? alvo.Advertencia ?? "Apenas informativo." : null),
+            ComoDesfazer = comoDesfazer,
+            Payload = achado
+        };
+    }
+
+    private IReadOnlySet<string> ProcessosAbertos()
+    {
+        try
+        {
+            return _processos.GetProcesses()
+                .Select(p => ProtectedProcesses.Normalizar(p.Name))
+                .ToHashSet(StringComparer.OrdinalIgnoreCase);
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+        {
+            return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Limpeza
+    // ------------------------------------------------------------------
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Limpar(itemIds, dryRun, ct), ct);
+
+    private ApplyResult Limpar(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+    {
+        var acoes = new List<AppliedAction>();
+
+        // Na remocao vale so a whitelist estrita: Downloads fica de fora.
+        var whitelist = CleanupCatalog.RaizesPermitidas();
+
+        long liberadoTotal = 0;
+        var removidosTotal = 0;
+        var emUsoTotal = 0;
+        var categorias = new List<string>();
+
+        foreach (var itemId in itemIds)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var id = itemId.StartsWith("clean:", StringComparison.Ordinal) ? itemId[6..] : itemId;
+
+            if (!_ultimaVarredura.TryGetValue(id, out var achado))
+            {
+                acoes.Add(new AppliedAction(itemId, false, "Item não encontrado: varra de novo.", null));
+                continue;
+            }
+
+            if (achado.Alvo.ApenasSugestao)
+            {
+                acoes.Add(new AppliedAction(itemId, false,
+                    $"{achado.Alvo.Titulo} é apenas informativo: o GameBoost não remove nada daí.", null));
+                continue;
+            }
+
+            if (achado.Bloqueio is not null)
+            {
+                acoes.Add(new AppliedAction(itemId, false, achado.Bloqueio, null));
+                continue;
+            }
+
+            var resultado = LimparAlvo(achado, whitelist, dryRun, ct);
+            acoes.Add(resultado.Acao);
+
+            liberadoTotal += resultado.Bytes;
+            removidosTotal += resultado.Removidos;
+            emUsoTotal += resultado.EmUso;
+
+            if (resultado.Removidos > 0)
+                categorias.Add(achado.Alvo.Titulo);
+        }
+
+        if (!dryRun && removidosTotal > 0)
+        {
+            _historico.Registrar(new CleanupEntry
+            {
+                Data = _relogio.Now,
+                Categorias = categorias,
+                BytesLiberados = liberadoTotal,
+                ArquivosRemovidos = removidosTotal
+            });
+        }
+
+        _log.Info(ModuloId, dryRun ? "Limpar (dry-run)" : "Limpar", null,
+            $"{removidosTotal} arquivos, {GameModeModule.Formatar(liberadoTotal)}");
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {removidosTotal} arquivos seriam removidos. Nada foi alterado."
+                : $"{removidosTotal} arquivos removidos.",
+            GanhoMedido = dryRun
+                ? $"Liberaria até {GameModeModule.Formatar(liberadoTotal)}."
+                : emUsoTotal > 0
+                    ? $"{GameModeModule.Formatar(liberadoTotal)} liberados. "
+                    + $"{emUsoTotal} arquivos não puderam ser removidos porque estão em uso."
+                    : $"{GameModeModule.Formatar(liberadoTotal)} liberados."
+        };
+    }
+
+    private (AppliedAction Acao, long Bytes, int Removidos, int EmUso) LimparAlvo(
+        AchadoDeLimpeza achado,
+        IReadOnlyList<string> whitelist,
+        bool dryRun,
+        CancellationToken ct)
+    {
+        var alvo = achado.Alvo;
+        var itemId = $"clean:{alvo.Id}";
+
+        if (dryRun)
+        {
+            return (new AppliedAction(itemId, true,
+                $"{alvo.Titulo}: removeria {achado.Arquivos.Count} arquivos "
+                + $"({GameModeModule.Formatar(achado.Bytes)}).", null), achado.Bytes, achado.Arquivos.Count, 0);
+        }
+
+        var servicoParado = false;
+        if (alvo.PararServico is not null)
+            servicoParado = PararServico(alvo.PararServico);
+
+        try
+        {
+            return alvo.Modo == RemocaoModo.Lixeira
+                ? RemoverParaLixeira(achado, whitelist, itemId)
+                : ApagarDireto(achado, whitelist, itemId, ct);
+        }
+        finally
+        {
+            // O servico volta aconteca o que acontecer: deixar o Windows Update
+            // parado seria pior que nao ter limpado nada.
+            if (servicoParado && alvo.PararServico is not null)
+                ReligarServico(alvo.PararServico);
+        }
+    }
+
+    private (AppliedAction, long, int, int) ApagarDireto(
+        AchadoDeLimpeza achado,
+        IReadOnlyList<string> whitelist,
+        string itemId,
+        CancellationToken ct)
+    {
+        long bytes = 0;
+        var removidos = 0;
+        var emUso = 0;
+
+        foreach (var arquivo in achado.Arquivos)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            // Terceira checagem, agora na hora de apagar.
+            if (_guard.CheckPath(arquivo, whitelist).Protegido)
+                continue;
+
+            try
+            {
+                var tamanho = _fs.GetFileSize(arquivo);
+                _fs.DeleteFile(arquivo);
+                bytes += tamanho;
+                removidos++;
+            }
+            catch (IOException)
+            {
+                // Arquivo em uso. Normal, e conta separado (seção 5.2).
+                emUso++;
+            }
+            catch (UnauthorizedAccessException)
+            {
+                emUso++;
+            }
+        }
+
+        var detalhe = $"{achado.Alvo.Titulo}: {removidos} arquivos, {GameModeModule.Formatar(bytes)}."
+                    + (emUso > 0 ? $" {emUso} em uso, mantidos." : string.Empty);
+
+        return (new AppliedAction(itemId, true, detalhe, null), bytes, removidos, emUso);
+    }
+
+    private (AppliedAction, long, int, int) RemoverParaLixeira(
+        AchadoDeLimpeza achado,
+        IReadOnlyList<string> whitelist,
+        string itemId)
+    {
+        var permitidos = achado.Arquivos
+            .Where(a => !_guard.CheckPath(a, whitelist).Protegido)
+            .ToList();
+
+        if (permitidos.Count == 0)
+            return (new AppliedAction(itemId, false, "Nada permitido pela blindagem.", null), 0, 0, 0);
+
+        long bytes = 0;
+        foreach (var arquivo in permitidos)
+        {
+            try
+            {
+                bytes += _fs.GetFileSize(arquivo);
+            }
+            catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+            {
+            }
+        }
+
+        var ok = RecycleBinBridge.ParaLixeira(permitidos);
+
+        return ok
+            ? (new AppliedAction(itemId, true,
+                $"{achado.Alvo.Titulo}: {permitidos.Count} arquivos para a Lixeira "
+                + $"({GameModeModule.Formatar(bytes)}).", null), bytes, permitidos.Count, 0)
+            : (new AppliedAction(itemId, false,
+                $"{achado.Alvo.Titulo}: o Windows recusou mover para a Lixeira.", null), 0, 0, 0);
+    }
+
+    private bool PararServico(string nome)
+    {
+        if (_guard.CheckService(nome, apenasPausar: true).Protegido)
+            return false;
+
+        var atual = _servicos.GetService(nome);
+        if (atual is null || !atual.IsRunning)
+            return false;
+
+        var ok = _servicos.Stop(nome, TimeSpan.FromSeconds(20));
+        _log.Info(ModuloId, "PararServico", nome, ok ? "parado para a limpeza" : "não parou");
+        return ok;
+    }
+
+    private void ReligarServico(string nome)
+    {
+        var ok = _servicos.Start(nome, TimeSpan.FromSeconds(30));
+        _log.Log(ok ? LogLevel.Info : LogLevel.Warn, ModuloId, "ReligarServico", nome,
+            ok ? "religado" : "NÃO religou: verifique o serviço");
+    }
+
+    // ------------------------------------------------------------------
+    // Reversão
+    // ------------------------------------------------------------------
+
+    /// <summary>
+    /// Limpeza não se desfaz: o que foi para a Lixeira o usuário restaura pelo
+    /// Explorer, e temporário apagado não volta. Dizer isso é mais honesto que
+    /// oferecer um botão que não funciona (regra 4).
+    /// </summary>
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.FromResult(new ApplyResult
+        {
+            ModuloId = ModuloId,
+            DryRun = dryRun,
+            Resumo = "A limpeza não tem reversão automática.",
+            GanhoMedido = "Arquivos enviados para a Lixeira podem ser restaurados por ela. "
+                        + "Temporários apagados são recriados pelos próprios programas."
+        });
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupCatalog.cs b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupCatalog.cs
new file mode 100644
index 0000000..cd7a820
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupCatalog.cs
@@ -0,0 +1,387 @@
+namespace GameBoost.Core.Modules.Cleaner;
+
+/// <summary>
+/// A whitelist de limpeza da seção 5.2, e só ela.
+///
+/// O Cleaner não monta caminho por conta própria em lugar nenhum: tudo que ele
+/// pode tocar está escrito aqui, e ainda assim cada arquivo passa pelo
+/// SafetyGuard antes de ser removido. Duas camadas, de propósito.
+/// </summary>
+public static class CleanupCatalog
+{
+    private static string? Env(string variavel)
+    {
+        var valor = Environment.GetEnvironmentVariable(variavel);
+        return string.IsNullOrWhiteSpace(valor) ? null : valor;
+    }
+
+    private static string? Pasta(Environment.SpecialFolder pasta)
+    {
+        var valor = Environment.GetFolderPath(pasta);
+        return string.IsNullOrWhiteSpace(valor) ? null : valor;
+    }
+
+    private static string? Combinar(string? raiz, params string[] partes)
+        => raiz is null ? null : Path.Combine(new[] { raiz }.Concat(partes).ToArray());
+
+    public static IReadOnlyList<CleanupTarget> Todos() => new[]
+    {
+        // ---------------- Sistema ----------------
+
+        new CleanupTarget
+        {
+            Id = "temp-usuario",
+            Categoria = "Sistema",
+            Titulo = "Arquivos temporários do usuário",
+            Descricao = "Sobras que programas deixam em %TEMP% e nunca apagam.",
+            Raiz = () => Path.GetTempPath(),
+            IdadeMinima = TimeSpan.FromHours(24),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Não há: são arquivos temporários, recriados sob demanda. "
+                         + "Por isso só entram os que estão parados há mais de 24 horas."
+        },
+
+        new CleanupTarget
+        {
+            Id = "temp-sistema",
+            Categoria = "Sistema",
+            Titulo = "Arquivos temporários do Windows",
+            Descricao = "O mesmo, na pasta temporária do sistema.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.Windows), "Temp"),
+            IdadeMinima = TimeSpan.FromHours(24),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Não há: são temporários, recriados sob demanda."
+        },
+
+        new CleanupTarget
+        {
+            Id = "windows-update-cache",
+            Categoria = "Sistema",
+            Titulo = "Cache do Windows Update",
+            Descricao = "Instaladores de atualizações já aplicadas.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.Windows), "SoftwareDistribution", "Download"),
+            PararServico = "wuauserv",
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "O Windows baixa de novo se precisar. O serviço de atualização é "
+                         + "parado durante a limpeza e religado logo depois."
+        },
+
+        new CleanupTarget
+        {
+            Id = "delivery-optimization",
+            Categoria = "Sistema",
+            Titulo = "Cache de Otimização de Entrega",
+            Descricao = "Pedaços de atualização que o Windows guarda para compartilhar na rede.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.Windows),
+                "ServiceProfiles", "NetworkService", "AppData", "Local", "Microsoft", "Windows",
+                "DeliveryOptimization", "Cache"),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Recriado sozinho na próxima atualização."
+        },
+
+        new CleanupTarget
+        {
+            Id = "relatorios-de-erro",
+            Categoria = "Sistema",
+            Titulo = "Relatórios de erro do Windows",
+            Descricao = "Relatórios de travamentos que ficaram na fila de envio.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.CommonApplicationData),
+                "Microsoft", "Windows", "WER", "ReportQueue"),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Não há. São relatórios de erros passados, sem uso para você."
+        },
+
+        new CleanupTarget
+        {
+            Id = "dumps-de-memoria",
+            Categoria = "Sistema",
+            Titulo = "Despejos de memória de telas azuis",
+            Descricao = "Arquivos grandes gravados quando o Windows trava.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.Windows), "Minidump"),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Não há.",
+            Advertencia = "Só apague depois de investigar a tela azul: é o que um técnico leria."
+        },
+
+        new CleanupTarget
+        {
+            Id = "prefetch",
+            Categoria = "Sistema",
+            Titulo = "Prefetch antigo",
+            Descricao = "Dados que o Windows usa para abrir programas mais rápido.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.Windows), "Prefetch"),
+            Padrao = "*.pf",
+            Recursivo = false,
+            IdadeMinima = TimeSpan.FromDays(30),
+            Risco = RiskLevel.Medio,
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "O Windows recria em alguns dias de uso.",
+            Advertencia = "Os programas abrem um pouco mais devagar até o Windows reaprender. "
+                        + "Ganha pouco espaço: raramente compensa."
+        },
+
+        new CleanupTarget
+        {
+            Id = "miniaturas",
+            Categoria = "Sistema",
+            Titulo = "Cache de miniaturas e ícones",
+            Descricao = "Miniaturas de fotos e vídeos que o Explorer guarda.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData),
+                "Microsoft", "Windows", "Explorer"),
+            Padrao = "*cache_*.db",
+            Recursivo = false,
+            Risco = RiskLevel.Medio,
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "Recriado ao abrir as pastas de novo.",
+            Advertencia = "As pastas com muitas fotos ficam lentas na primeira vez que abrirem."
+        },
+
+        // ---------------- Navegadores ----------------
+
+        new CleanupTarget
+        {
+            Id = "cache-chrome",
+            Categoria = "Navegadores",
+            Titulo = "Cache do Chrome",
+            Descricao = "Imagens e scripts de sites já visitados. Não inclui senhas, cookies nem histórico.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData),
+                "Google", "Chrome", "User Data", "Default", "Cache"),
+            ExigeFechado = new[] { "chrome" },
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Os sites recarregam os arquivos na próxima visita. "
+                         + "Você continua logado: senhas, cookies e histórico não são tocados."
+        },
+
+        new CleanupTarget
+        {
+            Id = "cache-edge",
+            Categoria = "Navegadores",
+            Titulo = "Cache do Edge",
+            Descricao = "Imagens e scripts de sites já visitados. Não inclui senhas, cookies nem histórico.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData),
+                "Microsoft", "Edge", "User Data", "Default", "Cache"),
+            ExigeFechado = new[] { "msedge" },
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Os sites recarregam os arquivos na próxima visita."
+        },
+
+        new CleanupTarget
+        {
+            Id = "cache-brave",
+            Categoria = "Navegadores",
+            Titulo = "Cache do Brave",
+            Descricao = "Imagens e scripts de sites já visitados.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData),
+                "BraveSoftware", "Brave-Browser", "User Data", "Default", "Cache"),
+            ExigeFechado = new[] { "brave" },
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Os sites recarregam os arquivos na próxima visita."
+        },
+
+        new CleanupTarget
+        {
+            Id = "cache-opera",
+            Categoria = "Navegadores",
+            Titulo = "Cache do Opera",
+            Descricao = "Imagens e scripts de sites já visitados.",
+            Raiz = () => Combinar(Env("APPDATA"), "Opera Software", "Opera Stable", "Cache"),
+            ExigeFechado = new[] { "opera" },
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Os sites recarregam os arquivos na próxima visita."
+        },
+
+        new CleanupTarget
+        {
+            Id = "cache-firefox",
+            Categoria = "Navegadores",
+            Titulo = "Cache do Firefox",
+            Descricao = "Imagens e scripts de sites já visitados.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData),
+                "Mozilla", "Firefox", "Profiles"),
+            Padrao = "*",
+            ExigeFechado = new[] { "firefox" },
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "Os sites recarregam os arquivos na próxima visita.",
+            Advertencia = "O Firefox guarda o cache junto do perfil; por isso este item entra desmarcado."
+        },
+
+        // ---------------- Aplicativos ----------------
+
+        new CleanupTarget
+        {
+            Id = "cache-discord",
+            Categoria = "Aplicativos",
+            Titulo = "Cache do Discord",
+            Descricao = "Imagens e anexos de conversas já vistos.",
+            Raiz = () => Combinar(Env("APPDATA"), "discord", "Cache"),
+            ExigeFechado = new[] { "discord" },
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "O Discord baixa de novo o que precisar. Não desloga nem apaga conversa."
+        },
+
+        new CleanupTarget
+        {
+            Id = "cache-spotify",
+            Categoria = "Aplicativos",
+            Titulo = "Cache do Spotify",
+            Descricao = "Músicas guardadas para tocar sem baixar de novo.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Spotify", "Storage"),
+            ExigeFechado = new[] { "spotify" },
+            Risco = RiskLevel.Medio,
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "O Spotify baixa de novo ao tocar.",
+            Advertencia = "Músicas salvas para ouvir offline precisam ser baixadas outra vez."
+        },
+
+        // ---------------- Jogos ----------------
+
+        new CleanupTarget
+        {
+            Id = "steam-logs",
+            Categoria = "Jogos",
+            Titulo = "Logs e despejos da Steam",
+            Descricao = "Registros de diagnóstico que a Steam acumula.",
+            Raiz = () => PastaDaSteam("logs"),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "Não há. São registros de diagnóstico, recriados sozinhos."
+        },
+
+        new CleanupTarget
+        {
+            Id = "steam-httpcache",
+            Categoria = "Jogos",
+            Titulo = "Cache da loja da Steam",
+            Descricao = "Imagens e páginas da loja.",
+            Raiz = () => PastaDaSteam("appcache", "httpcache"),
+            PreMarcadoPadrao = true,
+            ComoDesfazer = "A loja recarrega as imagens sozinha."
+        },
+
+        new CleanupTarget
+        {
+            Id = "shader-nvidia",
+            Categoria = "Jogos",
+            Titulo = "Cache de shaders da NVIDIA",
+            Descricao = "Efeitos gráficos que os jogos pré-compilaram para não recompilar depois.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "NVIDIA", "DXCache"),
+            Risco = RiskLevel.Medio,
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "Os jogos recriam ao rodar.",
+            Advertencia = "Os jogos vão engasgar nas primeiras horas, recompilando os efeitos. "
+                        + "Só vale a pena quando falta espaço de verdade."
+        },
+
+        new CleanupTarget
+        {
+            Id = "shader-directx",
+            Categoria = "Jogos",
+            Titulo = "Cache de shaders do DirectX",
+            Descricao = "O mesmo, do lado do Windows.",
+            Raiz = () => Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "D3DSCache"),
+            Risco = RiskLevel.Medio,
+            PreMarcadoPadrao = false,
+            ComoDesfazer = "Os jogos recriam ao rodar.",
+            Advertencia = "Os jogos vão engasgar nas primeiras horas, recompilando os efeitos."
+        },
+
+        // ---------------- Só sugestão, nunca acionável ----------------
+
+        new CleanupTarget
+        {
+            Id = "instaladores-esquecidos",
+            Categoria = "Sugestões",
+            Titulo = "Instaladores antigos em Downloads",
+            Descricao = "Arquivos de instalação parados há mais de 30 dias.",
+            Raiz = () => Combinar(Env("USERPROFILE"), "Downloads"),
+            Padrao = "*.exe",
+            Recursivo = false,
+            IdadeMinima = TimeSpan.FromDays(30),
+            Risco = RiskLevel.Alto,
+            Modo = RemocaoModo.Lixeira,
+            PreMarcadoPadrao = false,
+            ApenasSugestao = true,
+            ComoDesfazer = "O GameBoost não apaga nada aqui: só mostra o que encontrou, "
+                         + "para você decidir e apagar à mão.",
+            Advertencia = "Downloads é pasta sua. O GameBoost nunca remove arquivo daqui."
+        }
+    };
+
+    /// <summary>
+    /// Descobre a pasta da Steam pelo registro. Sem isso seria preciso chutar
+    /// o disco de instalação, e chutar caminho é exatamente o que a regra 2 proíbe.
+    /// </summary>
+    private static string? PastaDaSteam(params string[] subpastas)
+    {
+        try
+        {
+            using var chave = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(@"Software\Valve\Steam");
+            var caminho = chave?.GetValue("SteamPath") as string;
+
+            if (string.IsNullOrWhiteSpace(caminho))
+                return null;
+
+            return Path.Combine(new[] { caminho.Replace('/', '\\') }.Concat(subpastas).ToArray());
+        }
+        catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Raízes onde a remoção é permitida. É a whitelist que o SafetyGuard
+    /// recebe na hora de apagar: nada fora daqui sai do disco, mesmo que um
+    /// alvo do catálogo aponte para lá.
+    ///
+    /// Downloads NÃO está aqui de propósito. É pasta do usuário: o GameBoost
+    /// pode olhar (ver <see cref="RaizesParaMedir"/>) e listar o que achou, mas
+    /// nunca remover.
+    /// </summary>
+    public static IReadOnlyList<string> RaizesPermitidas()
+    {
+        var raizes = new List<string?>
+        {
+            Path.GetTempPath(),
+            Combinar(Pasta(Environment.SpecialFolder.Windows), "Temp"),
+            Combinar(Pasta(Environment.SpecialFolder.Windows), "SoftwareDistribution", "Download"),
+            Combinar(Pasta(Environment.SpecialFolder.Windows), "ServiceProfiles"),
+            Combinar(Pasta(Environment.SpecialFolder.Windows), "Minidump"),
+            Combinar(Pasta(Environment.SpecialFolder.Windows), "Prefetch"),
+            Combinar(Pasta(Environment.SpecialFolder.CommonApplicationData), "Microsoft", "Windows", "WER"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Microsoft", "Windows", "Explorer"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Google", "Chrome", "User Data"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Microsoft", "Edge", "User Data"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "BraveSoftware"),
+            Combinar(Env("APPDATA"), "Opera Software"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Mozilla", "Firefox", "Profiles"),
+            Combinar(Env("APPDATA"), "discord"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "Spotify"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "NVIDIA"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "AMD"),
+            Combinar(Pasta(Environment.SpecialFolder.LocalApplicationData), "D3DSCache"),
+            PastaDaSteam()
+        };
+
+        return raizes.Where(r => !string.IsNullOrWhiteSpace(r)).Select(r => r!).ToList();
+    }
+
+    /// <summary>
+    /// Raízes que podem ser LIDAS durante a varredura. Inclui as de remoção mais
+    /// as pastas que entram só como sugestão.
+    ///
+    /// Separar leitura de remoção é o que permite mostrar "você tem 3 GB de
+    /// instaladores velhos em Downloads" sem nunca ganhar permissão para apagar
+    /// nada de lá: os alvos marcados como sugestão jamais chegam ao caminho de
+    /// remoção, e mesmo que chegassem, a whitelist de lá não os cobre.
+    /// </summary>
+    public static IReadOnlyList<string> RaizesParaMedir()
+    {
+        var raizes = RaizesPermitidas().ToList();
+
+        var downloads = Combinar(Env("USERPROFILE"), "Downloads");
+        if (!string.IsNullOrWhiteSpace(downloads))
+            raizes.Add(downloads);
+
+        return raizes;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupHistory.cs b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupHistory.cs
new file mode 100644
index 0000000..61ebe09
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupHistory.cs
@@ -0,0 +1,81 @@
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Cleaner;
+
+public sealed class CleanupEntry
+{
+    public DateTimeOffset Data { get; set; }
+    public List<string> Categorias { get; set; } = new();
+    public long BytesLiberados { get; set; }
+    public int ArquivosRemovidos { get; set; }
+}
+
+/// <summary>
+/// Histórico de limpeza em cleanup-history.json (seção 5.2). Serve para o
+/// usuário conferir o que o app já fez e quanto rendeu de verdade — e para
+/// ele mesmo perceber quando uma limpeza rendeu quase nada.
+/// </summary>
+public sealed class CleanupHistory
+{
+    private const int MaximoDeEntradas = 200;
+
+    private static readonly JsonSerializerOptions Json = new()
+    {
+        WriteIndented = true,
+        PropertyNameCaseInsensitive = true
+    };
+
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+    private readonly object _gate = new();
+
+    public CleanupHistory(AppPaths paths, IFileSystem fs, IGameBoostLogger log)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+    }
+
+    public IReadOnlyList<CleanupEntry> Ler()
+    {
+        lock (_gate)
+        {
+            if (!_fs.FileExists(_paths.CleanupHistoryFile))
+                return Array.Empty<CleanupEntry>();
+
+            try
+            {
+                return JsonSerializer.Deserialize<List<CleanupEntry>>(
+                    _fs.ReadAllText(_paths.CleanupHistoryFile), Json) ?? new List<CleanupEntry>();
+            }
+            catch (JsonException ex)
+            {
+                _log.Error("Cleaner", "Historico", _paths.CleanupHistoryFile, "arquivo ilegivel", ex);
+                return Array.Empty<CleanupEntry>();
+            }
+        }
+    }
+
+    public void Registrar(CleanupEntry entrada)
+    {
+        lock (_gate)
+        {
+            var lista = Ler().ToList();
+            lista.Insert(0, entrada);
+
+            // Histórico não pode crescer para sempre.
+            if (lista.Count > MaximoDeEntradas)
+                lista = lista.Take(MaximoDeEntradas).ToList();
+
+            _fs.CreateDirectory(_paths.RootDirectory);
+            _fs.WriteAllText(_paths.CleanupHistoryFile, JsonSerializer.Serialize(lista, Json));
+        }
+    }
+
+    public long TotalLiberadoNoAno(int ano)
+        => Ler().Where(e => e.Data.Year == ano).Sum(e => e.BytesLiberados);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupTarget.cs b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupTarget.cs
new file mode 100644
index 0000000..2b002ac
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Cleaner/CleanupTarget.cs
@@ -0,0 +1,56 @@
+namespace GameBoost.Core.Modules.Cleaner;
+
+/// <summary>O que fazer com os arquivos de um alvo.</summary>
+public enum RemocaoModo
+{
+    /// <summary>Temporário de sistema: pode ser apagado direto (regra 2).</summary>
+    ApagarDireto,
+
+    /// <summary>Conteúdo do usuário: vai para a Lixeira, sempre (regra 2).</summary>
+    Lixeira
+}
+
+/// <summary>
+/// Um alvo de limpeza. A whitelist da seção 5.2 é isto e nada além: o Cleaner
+/// nunca deriva caminho por conta própria, e cada alvo passa pelo SafetyGuard
+/// antes de qualquer leitura.
+/// </summary>
+public sealed record CleanupTarget
+{
+    public required string Id { get; init; }
+    public required string Categoria { get; init; }
+    public required string Titulo { get; init; }
+    public required string Descricao { get; init; }
+
+    /// <summary>Pasta raiz. Resolvida na hora: variáveis de ambiente mudam por usuário.</summary>
+    public required Func<string?> Raiz { get; init; }
+
+    public string Padrao { get; init; } = "*";
+    public bool Recursivo { get; init; } = true;
+
+    /// <summary>Só remove arquivos mais antigos que isto. Zero desliga a checagem.</summary>
+    public TimeSpan IdadeMinima { get; init; } = TimeSpan.Zero;
+
+    public RiskLevel Risco { get; init; } = RiskLevel.Baixo;
+    public RemocaoModo Modo { get; init; } = RemocaoModo.ApagarDireto;
+
+    /// <summary>Regra 3: nada que possa causar perda vem marcado.</summary>
+    public bool PreMarcadoPadrao { get; init; }
+
+    /// <summary>Processos que precisam estar fechados. Senão o item aparece bloqueado.</summary>
+    public IReadOnlyList<string> ExigeFechado { get; init; } = Array.Empty<string>();
+
+    /// <summary>Serviço parado durante a limpeza e religado depois.</summary>
+    public string? PararServico { get; init; }
+
+    public required string ComoDesfazer { get; init; }
+
+    /// <summary>Explicação honesta do efeito colateral, quando existe.</summary>
+    public string? Advertencia { get; init; }
+
+    /// <summary>
+    /// Só aparece em "Sugestões", nunca como item acionável. Usado para o que é
+    /// arriscado demais para o app decidir, como instaladores em Downloads.
+    /// </summary>
+    public bool ApenasSugestao { get; init; }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskCategories.cs b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskCategories.cs
new file mode 100644
index 0000000..1fd5efa
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskCategories.cs
@@ -0,0 +1,127 @@
+namespace GameBoost.Core.Modules.DiskAnalyzer;
+
+/// <summary>
+/// Classifica arquivos em categorias que significam algo para o usuário
+/// (seção 5.4). "12 GB de vídeo" diz mais que "12 GB em .mkv".
+/// </summary>
+public static class DiskCategories
+{
+    private static readonly IReadOnlySet<string> Video = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v", ".mpg", ".mpeg", ".ts" };
+
+    private static readonly IReadOnlySet<string> Imagem = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tiff", ".raw", ".cr2", ".nef", ".psd", ".heic" };
+
+    private static readonly IReadOnlySet<string> Musica = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".mp3", ".flac", ".wav", ".aac", ".ogg", ".m4a", ".wma" };
+
+    private static readonly IReadOnlySet<string> Instalador = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".exe", ".msi", ".iso", ".msix", ".appx" };
+
+    private static readonly IReadOnlySet<string> Compactado = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".zip", ".rar", ".7z", ".tar", ".gz", ".xz" };
+
+    private static readonly IReadOnlySet<string> Documento = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".txt", ".odt", ".csv" };
+
+    private static readonly IReadOnlySet<string> Codigo = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    { ".cs", ".js", ".ts", ".py", ".java", ".cpp", ".c", ".h", ".go", ".rs", ".rb", ".php", ".sql" };
+
+    private static readonly string[] PastasDeJogo =
+    {
+        @"\steamapps\", @"\epic games\", @"\riot games\", @"\battle.net\",
+        @"\gog galaxy\games\", @"\gog games\", @"\xboxgames\", @"\ea games\",
+        @"\origin games\", @"\ubisoft\", @"\my games\"
+    };
+
+    private static readonly string[] PastasDeCache =
+    {
+        @"\cache\", @"\cache2\", @"\temp\", @"\tmp\", @"\appdata\local\temp\",
+        @"\code cache\", @"\gpucache\", @"\dxcache\", @"\glcache\", @"\d3dscache\",
+        @"\shadercache\", @"\nv_cache\", @"\softwaredistribution\", @"\node_modules\",
+        @"\.nuget\", @"\obj\", @"\bin\debug\", @"\bin\release\"
+    };
+
+    /// <summary>
+    /// A pasta manda mais que a extensão: um .dll dentro de steamapps é parte
+    /// do jogo, e um .exe dentro de um cache não é instalador guardado.
+    /// </summary>
+    public static DiskCategory Classificar(string caminho, long tamanho)
+    {
+        var minusculo = caminho.ToLowerInvariant().Replace('/', '\\');
+
+        if (PastasDeJogo.Any(p => minusculo.Contains(p, StringComparison.Ordinal)))
+            return DiskCategory.Jogos;
+
+        if (PastasDeCache.Any(p => minusculo.Contains(p, StringComparison.Ordinal)))
+            return DiskCategory.Caches;
+
+        if (EhDeSistema(minusculo))
+            return DiskCategory.Sistema;
+
+        var extensao = Path.GetExtension(minusculo);
+
+        if (Video.Contains(extensao))
+            return DiskCategory.Videos;
+
+        if (Imagem.Contains(extensao))
+            return DiskCategory.Imagens;
+
+        if (Musica.Contains(extensao))
+            return DiskCategory.Musica;
+
+        if (Documento.Contains(extensao))
+            return DiskCategory.Documentos;
+
+        if (Codigo.Contains(extensao))
+            return DiskCategory.Codigo;
+
+        // Instalador só conta como tal se for grande: um .exe de 200 KB é
+        // programa, não pacote de instalação esquecido.
+        if ((Instalador.Contains(extensao) || Compactado.Contains(extensao))
+            && tamanho > 5L * 1024 * 1024)
+        {
+            return DiskCategory.Instaladores;
+        }
+
+        return DiskCategory.Outros;
+    }
+
+    private static bool EhDeSistema(string caminhoMinusculo)
+    {
+        var windows = Environment.GetFolderPath(Environment.SpecialFolder.Windows).ToLowerInvariant();
+
+        return caminhoMinusculo.StartsWith(windows, StringComparison.Ordinal)
+            || caminhoMinusculo.Contains(@"\windows.old\", StringComparison.Ordinal)
+            || caminhoMinusculo.Contains(@"\$windows.~", StringComparison.Ordinal);
+    }
+
+    public static string Nome(DiskCategory categoria) => categoria switch
+    {
+        DiskCategory.Jogos => "Jogos",
+        DiskCategory.Videos => "Vídeos",
+        DiskCategory.Imagens => "Imagens",
+        DiskCategory.Instaladores => "Instaladores",
+        DiskCategory.Caches => "Caches",
+        DiskCategory.Sistema => "Sistema",
+        DiskCategory.Documentos => "Documentos",
+        DiskCategory.Codigo => "Código",
+        DiskCategory.Musica => "Música",
+        _ => "Outros"
+    };
+
+    /// <summary>Cor do treemap, em hexadecimal. Uma por categoria, estável.</summary>
+    public static string Cor(DiskCategory categoria) => categoria switch
+    {
+        DiskCategory.Jogos => "#FF00C2A8",
+        DiskCategory.Videos => "#FF9B6DFF",
+        DiskCategory.Imagens => "#FF3FB950",
+        DiskCategory.Instaladores => "#FFD29922",
+        DiskCategory.Caches => "#FF6E7681",
+        DiskCategory.Sistema => "#FF388BFD",
+        DiskCategory.Documentos => "#FFDB6D28",
+        DiskCategory.Codigo => "#FFF778BA",
+        DiskCategory.Musica => "#FF56D4DD",
+        _ => "#FF484F58"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskNode.cs b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskNode.cs
new file mode 100644
index 0000000..9f490b3
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskNode.cs
@@ -0,0 +1,188 @@
+namespace GameBoost.Core.Modules.DiskAnalyzer;
+
+/// <summary>Categoria do treemap: o que é aquele espaço, em linguagem humana.</summary>
+public enum DiskCategory
+{
+    Outros,
+    Jogos,
+    Videos,
+    Imagens,
+    Instaladores,
+    Caches,
+    Sistema,
+    Documentos,
+    Codigo,
+    Musica
+}
+
+/// <summary>
+/// Um nó da árvore do disco. Guarda o tamanho agregado da subárvore, calculado
+/// uma vez ao fim da varredura: recalcular a cada acesso tornaria o treemap
+/// inutilizável em disco com milhões de arquivos.
+/// </summary>
+public sealed class DiskNode
+{
+    /// <summary>Raiz da árvore: é a única que guarda um caminho completo.</summary>
+    public DiskNode(string caminhoDaRaiz)
+    {
+        Nome = caminhoDaRaiz;
+        EhPasta = true;
+        _caminhoDaRaiz = caminhoDaRaiz;
+    }
+
+    /// <summary>
+    /// Nó filho. Guarda só o nome: o caminho completo em cada nó custava cerca
+    /// de 240 MB numa árvore de 1,5 milhão de arquivos, para uma informação que
+    /// já está na estrutura.
+    /// </summary>
+    public DiskNode(string nome, bool ehPasta, DiskNode pai)
+    {
+        Nome = nome;
+        EhPasta = ehPasta;
+        Pai = pai;
+    }
+
+    private readonly string? _caminhoDaRaiz;
+
+    public string Nome { get; }
+    public bool EhPasta { get; }
+    public DiskNode? Pai { get; }
+
+    /// <summary>Montado sob demanda subindo até a raiz.</summary>
+    public string Caminho
+    {
+        get
+        {
+            if (_caminhoDaRaiz is not null)
+                return _caminhoDaRaiz;
+
+            var partes = new Stack<string>();
+
+            for (var no = this; no is not null; no = no.Pai)
+            {
+                if (no._caminhoDaRaiz is not null)
+                {
+                    partes.Push(no._caminhoDaRaiz);
+                    break;
+                }
+
+                partes.Push(no.Nome);
+            }
+
+            return Path.Combine(partes.ToArray());
+        }
+    }
+
+    public List<DiskNode> Filhos { get; } = new();
+
+    /// <summary>Tamanho próprio, quando arquivo. Pasta soma pelos filhos.</summary>
+    public long TamanhoProprio { get; set; }
+
+    /// <summary>Soma da subárvore inteira. Preenchido por <see cref="Consolidar"/>.</summary>
+    public long Tamanho { get; private set; }
+
+    public int TotalDeArquivos { get; private set; }
+
+    public DateTime Modificado { get; set; }
+
+    public DiskCategory Categoria { get; set; } = DiskCategory.Outros;
+
+    /// <summary>Pastas que não puderam ser lidas, por permissão ou por sumirem no meio.</summary>
+    public int PastasIgnoradas { get; set; }
+
+    /// <summary>
+    /// Soma a subárvore de baixo para cima e propaga a categoria dominante.
+    /// Iterativo, e não recursivo: uma árvore de disco cheio chega a dezenas de
+    /// milhares de níveis somados e estouraria a pilha.
+    /// </summary>
+    public void Consolidar()
+    {
+        var pilha = new Stack<(DiskNode No, bool Visitado)>();
+        pilha.Push((this, false));
+
+        while (pilha.Count > 0)
+        {
+            var (no, visitado) = pilha.Pop();
+
+            if (!visitado)
+            {
+                pilha.Push((no, true));
+
+                foreach (var filho in no.Filhos)
+                    pilha.Push((filho, false));
+
+                continue;
+            }
+
+            if (no.EhPasta)
+            {
+                long soma = 0;
+                var arquivos = 0;
+
+                foreach (var filho in no.Filhos)
+                {
+                    soma += filho.Tamanho;
+                    arquivos += filho.TotalDeArquivos;
+                }
+
+                no.Tamanho = soma;
+                no.TotalDeArquivos = arquivos;
+
+                if (no.Categoria == DiskCategory.Outros)
+                    no.Categoria = CategoriaDominante(no);
+            }
+            else
+            {
+                no.Tamanho = no.TamanhoProprio;
+                no.TotalDeArquivos = 1;
+            }
+        }
+    }
+
+    /// <summary>A categoria que ocupa mais espaço dentro da pasta é a que a define.</summary>
+    private static DiskCategory CategoriaDominante(DiskNode pasta)
+    {
+        if (pasta.Filhos.Count == 0)
+            return DiskCategory.Outros;
+
+        var porCategoria = new Dictionary<DiskCategory, long>();
+
+        foreach (var filho in pasta.Filhos)
+        {
+            porCategoria.TryGetValue(filho.Categoria, out var atual);
+            porCategoria[filho.Categoria] = atual + filho.Tamanho;
+        }
+
+        return porCategoria.OrderByDescending(p => p.Value).First().Key;
+    }
+
+    /// <summary>Percorre a árvore inteira sem recursão.</summary>
+    public IEnumerable<DiskNode> Percorrer()
+    {
+        var pilha = new Stack<DiskNode>();
+        pilha.Push(this);
+
+        while (pilha.Count > 0)
+        {
+            var no = pilha.Pop();
+            yield return no;
+
+            foreach (var filho in no.Filhos)
+                pilha.Push(filho);
+        }
+    }
+
+    public IEnumerable<DiskNode> MaioresArquivos(int quantidade)
+        => Percorrer()
+            .Where(n => !n.EhPasta)
+            .OrderByDescending(n => n.Tamanho)
+            .Take(quantidade);
+
+    public IEnumerable<DiskNode> MaioresPastas(int quantidade)
+        => Percorrer()
+            .Where(n => n.EhPasta && n != this)
+            .OrderByDescending(n => n.Tamanho)
+            .Take(quantidade);
+
+    public override string ToString() => $"{Caminho} ({Tamanho} bytes)";
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskScanner.cs b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskScanner.cs
new file mode 100644
index 0000000..4455029
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/DiskScanner.cs
@@ -0,0 +1,173 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.DiskAnalyzer;
+
+public sealed record ScanProgresso(string PastaAtual, int Arquivos, long Bytes);
+
+public sealed record DiskScanResult(
+    DiskNode Raiz,
+    TimeSpan Duracao,
+    int TotalDeArquivos,
+    int PastasIgnoradas,
+    long EspacoTotal,
+    long EspacoLivre);
+
+/// <summary>
+/// Varre um volume inteiro montando a árvore de tamanhos.
+///
+/// Usa FindFirstFileEx com busca grande, paralelizado por subárvore. Não lê a
+/// MFT crua: ver docs/DECISOES.md para o motivo e o que isso custa em
+/// velocidade.
+/// </summary>
+public sealed class DiskScanner
+{
+    private readonly IGameBoostLogger _log;
+
+    public DiskScanner(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    /// <summary>Pastas que a varredura nunca entra: são reparse points ou lixo de kernel.</summary>
+    private static readonly IReadOnlySet<string> Pular = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "System Volume Information",
+        "$Recycle.Bin",
+        "$WinREAgent",
+        "Config.Msi"
+    };
+
+    public DiskScanResult Varrer(
+        string raizDoVolume,
+        IProgress<ScanProgresso>? progresso,
+        CancellationToken ct)
+    {
+        var relogio = Stopwatch.StartNew();
+
+        var raiz = new DiskNode(raizDoVolume);
+        var arquivos = 0;
+        var ignoradas = 0;
+        long bytes = 0;
+        var ultimoAviso = 0L;
+
+        // Uma fila de trabalho em vez de recursão: a profundidade de um disco
+        // real é imprevisível e o paralelismo fica explícito.
+        var fila = new ConcurrentQueue<DiskNode>();
+        fila.Enqueue(raiz);
+
+        var paralelismo = Math.Min(Environment.ProcessorCount, 8);
+
+        while (!fila.IsEmpty)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var lote = new List<DiskNode>();
+            while (fila.TryDequeue(out var no) && lote.Count < 512)
+                lote.Add(no);
+
+            var descobertas = new ConcurrentBag<DiskNode>();
+
+            Parallel.ForEach(
+                lote,
+                new ParallelOptions { MaxDegreeOfParallelism = paralelismo, CancellationToken = ct },
+                pasta =>
+                {
+                    // Uma vez por pasta, nunca por arquivo: montar o caminho
+                    // sobe a arvore inteira, e fazer isso por arquivo tornaria
+                    // a varredura quadratica na profundidade.
+                    var caminhoDaPasta = pasta.Caminho;
+
+                    var entradas = FastFind.Listar(caminhoDaPasta, out var acessoNegado);
+
+                    // So conta como ignorada quando o Windows recusou de fato.
+                    // Pasta vazia nao e pasta inacessivel.
+                    if (acessoNegado)
+                        Interlocked.Increment(ref ignoradas);
+
+                    foreach (var entrada in entradas)
+                    {
+                        if (entrada.EhPasta && Pular.Contains(entrada.Nome))
+                            continue;
+
+                        var caminho = Path.Combine(caminhoDaPasta, entrada.Nome);
+                        var filho = new DiskNode(entrada.Nome, entrada.EhPasta, pasta)
+                        {
+                            TamanhoProprio = entrada.Tamanho,
+                            Modificado = entrada.Modificado,
+                            Categoria = entrada.EhPasta
+                                ? DiskCategory.Outros
+                                : DiskCategories.Classificar(caminho, entrada.Tamanho)
+                        };
+
+                        lock (pasta.Filhos)
+                            pasta.Filhos.Add(filho);
+
+                        if (entrada.EhPasta)
+                        {
+                            descobertas.Add(filho);
+                        }
+                        else
+                        {
+                            Interlocked.Increment(ref arquivos);
+                            Interlocked.Add(ref bytes, entrada.Tamanho);
+                        }
+                    }
+                });
+
+            foreach (var nova in descobertas)
+                fila.Enqueue(nova);
+
+            // Progresso a cada 25 mil arquivos: relatar a cada arquivo custaria
+            // mais que a própria leitura.
+            var lidos = Volatile.Read(ref arquivos);
+            if (lidos - ultimoAviso > 25_000)
+            {
+                ultimoAviso = lidos;
+                progresso?.Report(new ScanProgresso(
+                    lote.Count > 0 ? lote[0].Caminho : raizDoVolume, lidos, Volatile.Read(ref bytes)));
+            }
+        }
+
+        raiz.PastasIgnoradas = ignoradas;
+        raiz.Consolidar();
+
+        relogio.Stop();
+
+        var (total, livre) = EspacoDoVolume(raizDoVolume);
+
+        _log.Info("DiskAnalyzer", "Varrer", raizDoVolume,
+            $"{arquivos} arquivos, {GameMode.GameModeModule.Formatar(raiz.Tamanho)} em {relogio.Elapsed.TotalSeconds:0.0}s");
+
+        return new DiskScanResult(raiz, relogio.Elapsed, arquivos, ignoradas, total, livre);
+    }
+
+    private static (long Total, long Livre) EspacoDoVolume(string raiz)
+    {
+        try
+        {
+            var unidade = new DriveInfo(raiz);
+            return unidade.IsReady ? (unidade.TotalSize, unidade.TotalFreeSpace) : (0, 0);
+        }
+        catch (Exception ex) when (ex is ArgumentException or IOException or UnauthorizedAccessException)
+        {
+            return (0, 0);
+        }
+    }
+
+    public static IReadOnlyList<DriveInfo> VolumesDisponiveis()
+    {
+        try
+        {
+            return DriveInfo.GetDrives()
+                .Where(d => d.IsReady && d.DriveType is DriveType.Fixed or DriveType.Removable)
+                .ToList();
+        }
+        catch (IOException)
+        {
+            return Array.Empty<DriveInfo>();
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/GameLibrary.cs b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/GameLibrary.cs
new file mode 100644
index 0000000..deb4dab
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/GameLibrary.cs
@@ -0,0 +1,294 @@
+using System.Text.RegularExpressions;
+using GameBoost.Core.Logging;
+using Microsoft.Win32;
+
+namespace GameBoost.Core.Modules.DiskAnalyzer;
+
+public sealed record JogoInstalado(
+    string Nome,
+    string Launcher,
+    string Pasta,
+    long Bytes,
+    DateTimeOffset? UltimaVez)
+{
+    public string QuandoJogou => UltimaVez is null
+        ? "sem registro"
+        : (DateTimeOffset.Now - UltimaVez.Value).TotalDays switch
+        {
+            < 7 => "esta semana",
+            < 31 => "este mês",
+            < 90 => "nos últimos 3 meses",
+            < 365 => $"há {(int)((DateTimeOffset.Now - UltimaVez.Value).TotalDays / 30)} meses",
+            _ => "há mais de um ano"
+        };
+
+    /// <summary>Jogo grande e parado há muito é onde estão os GB de verdade (seção 5.11).</summary>
+    public bool CandidatoADesinstalar
+        => Bytes > 20L * 1024 * 1024 * 1024
+           && UltimaVez is not null
+           && (DateTimeOffset.Now - UltimaVez.Value).TotalDays > 180;
+}
+
+/// <summary>
+/// Lê a biblioteca instalada de cada launcher (seção 5.11).
+///
+/// Serve para o analisador de disco responder o que o usuário realmente quer
+/// saber: qual jogo de 90 GB está parado desde o ano passado. Só lê; nunca
+/// desinstala nada.
+/// </summary>
+public sealed class GameLibrary
+{
+    private readonly IGameBoostLogger _log;
+
+    public GameLibrary(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public IReadOnlyList<JogoInstalado> Listar()
+    {
+        var jogos = new List<JogoInstalado>();
+
+        Seguro(() => jogos.AddRange(DaSteam()), "Steam");
+        Seguro(() => jogos.AddRange(DaEpic()), "Epic");
+        Seguro(() => jogos.AddRange(DaGog()), "GOG");
+        Seguro(() => jogos.AddRange(DoXbox()), "Xbox");
+
+        return jogos
+            .GroupBy(j => j.Pasta, StringComparer.OrdinalIgnoreCase)
+            .Select(g => g.First())
+            .OrderByDescending(j => j.Bytes)
+            .ToList();
+    }
+
+    private void Seguro(Action acao, string origem)
+    {
+        try
+        {
+            acao();
+        }
+        catch (Exception ex) when (ex is IOException
+                                      or UnauthorizedAccessException
+                                      or System.Security.SecurityException
+                                      or FormatException)
+        {
+            _log.Warn("DiskAnalyzer", "Biblioteca", origem, ex.Message);
+        }
+    }
+
+    // ---------------- Steam ----------------
+
+    /// <summary>
+    /// A Steam guarda as bibliotecas em libraryfolders.vdf e cada jogo num
+    /// appmanifest_*.acf. O .acf traz tamanho e data do último jogo, que é
+    /// exatamente o que interessa aqui.
+    /// </summary>
+    private IEnumerable<JogoInstalado> DaSteam()
+    {
+        var raiz = CaminhoDaSteam();
+        if (raiz is null)
+            yield break;
+
+        foreach (var biblioteca in BibliotecasDaSteam(raiz))
+        {
+            var steamapps = Path.Combine(biblioteca, "steamapps");
+            if (!Directory.Exists(steamapps))
+                continue;
+
+            foreach (var manifesto in Directory.EnumerateFiles(steamapps, "appmanifest_*.acf"))
+            {
+                var texto = LerTexto(manifesto);
+                if (texto is null)
+                    continue;
+
+                var nome = Campo(texto, "name");
+                var pasta = Campo(texto, "installdir");
+                var tamanho = CampoLongo(texto, "SizeOnDisk");
+                var ultimo = CampoLongo(texto, "LastPlayed");
+
+                if (nome is null || pasta is null)
+                    continue;
+
+                yield return new JogoInstalado(
+                    nome,
+                    "Steam",
+                    Path.Combine(steamapps, "common", pasta),
+                    tamanho,
+                    ultimo > 0 ? DateTimeOffset.FromUnixTimeSeconds(ultimo) : null);
+            }
+        }
+    }
+
+    private static string? CaminhoDaSteam()
+    {
+        using var chave = Registry.CurrentUser.OpenSubKey(@"Software\Valve\Steam");
+        var caminho = chave?.GetValue("SteamPath") as string;
+
+        return string.IsNullOrWhiteSpace(caminho) ? null : caminho.Replace('/', '\\');
+    }
+
+    private static IEnumerable<string> BibliotecasDaSteam(string raiz)
+    {
+        yield return raiz;
+
+        var vdf = Path.Combine(raiz, "steamapps", "libraryfolders.vdf");
+        var texto = LerTexto(vdf);
+
+        if (texto is null)
+            yield break;
+
+        // O formato mudou de versão para versão; casar "path" cobre as duas.
+        foreach (Match m in Regex.Matches(texto, "\"path\"\\s+\"([^\"]+)\"", RegexOptions.IgnoreCase))
+        {
+            var caminho = m.Groups[1].Value.Replace(@"\\", @"\");
+
+            if (!caminho.Equals(raiz, StringComparison.OrdinalIgnoreCase) && Directory.Exists(caminho))
+                yield return caminho;
+        }
+    }
+
+    private static string? Campo(string vdf, string chave)
+    {
+        var m = Regex.Match(vdf, $"\"{chave}\"\\s+\"([^\"]*)\"", RegexOptions.IgnoreCase);
+        return m.Success ? m.Groups[1].Value : null;
+    }
+
+    private static long CampoLongo(string vdf, string chave)
+        => long.TryParse(Campo(vdf, chave), out var valor) ? valor : 0;
+
+    // ---------------- Epic ----------------
+
+    private IEnumerable<JogoInstalado> DaEpic()
+    {
+        var pasta = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
+            "Epic", "EpicGamesLauncher", "Data", "Manifests");
+
+        if (!Directory.Exists(pasta))
+            yield break;
+
+        foreach (var arquivo in Directory.EnumerateFiles(pasta, "*.item"))
+        {
+            var texto = LerTexto(arquivo);
+            if (texto is null)
+                continue;
+
+            var nome = Json(texto, "DisplayName");
+            var local = Json(texto, "InstallLocation");
+            var tamanho = long.TryParse(Json(texto, "InstallSize"), out var v) ? v : 0;
+
+            if (nome is null || local is null)
+                continue;
+
+            yield return new JogoInstalado(nome, "Epic", local, tamanho, UltimoUso(local));
+        }
+    }
+
+    private static string? Json(string texto, string chave)
+    {
+        var m = Regex.Match(texto, $"\"{chave}\"\\s*:\\s*\"?([^\",}}]*)\"?", RegexOptions.IgnoreCase);
+        return m.Success && !string.IsNullOrWhiteSpace(m.Groups[1].Value) ? m.Groups[1].Value : null;
+    }
+
+    // ---------------- GOG ----------------
+
+    private IEnumerable<JogoInstalado> DaGog()
+    {
+        foreach (var raiz in new[] { Registry.LocalMachine, Registry.CurrentUser })
+        {
+            foreach (var caminho in new[] { @"SOFTWARE\WOW6432Node\GOG.com\Games", @"SOFTWARE\GOG.com\Games" })
+            {
+                using var chave = raiz.OpenSubKey(caminho);
+                if (chave is null)
+                    continue;
+
+                foreach (var id in chave.GetSubKeyNames())
+                {
+                    using var jogo = chave.OpenSubKey(id);
+                    var nome = jogo?.GetValue("gameName") as string;
+                    var pasta = jogo?.GetValue("path") as string;
+
+                    if (nome is null || pasta is null || !Directory.Exists(pasta))
+                        continue;
+
+                    yield return new JogoInstalado(nome, "GOG", pasta, TamanhoDaPasta(pasta), UltimoUso(pasta));
+                }
+            }
+        }
+    }
+
+    // ---------------- Xbox ----------------
+
+    private IEnumerable<JogoInstalado> DoXbox()
+    {
+        foreach (var unidade in DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Fixed))
+        {
+            // .GamingRoot aponta a pasta de jogos do Xbox naquele volume.
+            var marcador = Path.Combine(unidade.RootDirectory.FullName, ".GamingRoot");
+            if (!File.Exists(marcador))
+                continue;
+
+            var pastaDeJogos = Path.Combine(unidade.RootDirectory.FullName, "XboxGames");
+            if (!Directory.Exists(pastaDeJogos))
+                continue;
+
+            foreach (var jogo in Directory.EnumerateDirectories(pastaDeJogos))
+            {
+                yield return new JogoInstalado(
+                    Path.GetFileName(jogo), "Xbox", jogo, TamanhoDaPasta(jogo), UltimoUso(jogo));
+            }
+        }
+    }
+
+    // ---------------- Apoio ----------------
+
+    private static string? LerTexto(string caminho)
+    {
+        try
+        {
+            return File.Exists(caminho) ? File.ReadAllText(caminho) : null;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Sem data de "último jogo" no launcher, a data de modificação da pasta é
+    /// a melhor aproximação: jogo salva progresso e configuração ali.
+    /// </summary>
+    private static DateTimeOffset? UltimoUso(string pasta)
+    {
+        try
+        {
+            return Directory.Exists(pasta) ? new DateTimeOffset(Directory.GetLastWriteTimeUtc(pasta)) : null;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    private static long TamanhoDaPasta(string pasta)
+    {
+        long total = 0;
+        var pilha = new Stack<string>();
+        pilha.Push(pasta);
+
+        while (pilha.Count > 0)
+        {
+            var atual = pilha.Pop();
+
+            foreach (var entrada in Native.FastFind.Listar(atual))
+            {
+                if (entrada.EhPasta)
+                    pilha.Push(Path.Combine(atual, entrada.Nome));
+                else
+                    total += entrada.Tamanho;
+            }
+        }
+
+        return total;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/SpecialFiles.cs b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/SpecialFiles.cs
new file mode 100644
index 0000000..46a38db
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/DiskAnalyzer/SpecialFiles.cs
@@ -0,0 +1,104 @@
+using GameBoost.Core.Modules.GameMode;
+
+namespace GameBoost.Core.Modules.DiskAnalyzer;
+
+/// <summary>
+/// Arquivo grande do Windows que o usuário vê no analisador e não entende.
+/// Explicar vale mais que listar: sem isso ele tenta apagar hiberfil.sys na
+/// mão e não consegue.
+/// </summary>
+public sealed record SpecialFile(
+    string Nome,
+    string Caminho,
+    long Bytes,
+    string OQueE,
+    string ComoRemover,
+    RiskLevel Risco);
+
+public static class SpecialFiles
+{
+    /// <summary>Encontra os arquivos grandes de sistema na raiz do volume.</summary>
+    public static IReadOnlyList<SpecialFile> Encontrar(string raizDoVolume)
+    {
+        var achados = new List<SpecialFile>();
+
+        Adicionar(achados, raizDoVolume, "hiberfil.sys",
+            "Guarda o conteúdo da memória quando o PC hiberna. Ocupa perto do tamanho da sua RAM.",
+            "Desativar a hibernação libera este espaço, com o comando powercfg /h off. "
+          + "Você perde a hibernação e a Inicialização Rápida, que deixa o boot um pouco mais lento.",
+            RiskLevel.Medio);
+
+        Adicionar(achados, raizDoVolume, "pagefile.sys",
+            "Memória virtual: o Windows usa quando a RAM acaba.",
+            "Não mexa sem necessidade. Reduzir ou desativar causa travamento quando a RAM enche, "
+          + "e o ganho de espaço não compensa.",
+            RiskLevel.Alto);
+
+        Adicionar(achados, raizDoVolume, "swapfile.sys",
+            "Arquivo de troca dos aplicativos da Store. Costuma ser pequeno.",
+            "Some junto com o pagefile. Não vale mexer separadamente.",
+            RiskLevel.Alto);
+
+        // Windows.old aparece depois de uma atualização grande e costuma passar
+        // de 20 GB. É o maior ganho fácil de espaço que existe.
+        var windowsOld = Path.Combine(raizDoVolume, "Windows.old");
+        if (Directory.Exists(windowsOld))
+        {
+            achados.Add(new SpecialFile(
+                "Windows.old",
+                windowsOld,
+                TamanhoDaPasta(windowsOld),
+                "Cópia do Windows anterior, guardada depois de uma atualização grande. "
+              + "Serve para voltar à versão antiga nos primeiros dias.",
+                "Use a Limpeza de Disco do Windows e marque Instalações anteriores do Windows. "
+              + "Depois disso não dá mais para voltar à versão antiga.",
+                RiskLevel.Medio));
+        }
+
+        return achados;
+    }
+
+    private static void Adicionar(
+        List<SpecialFile> lista, string raiz, string nome,
+        string oQueE, string comoRemover, RiskLevel risco)
+    {
+        var caminho = Path.Combine(raiz, nome);
+
+        try
+        {
+            var info = new FileInfo(caminho);
+            if (info.Exists && info.Length > 0)
+                lista.Add(new SpecialFile(nome, caminho, info.Length, oQueE, comoRemover, risco));
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            // Estes arquivos ficam abertos pelo kernel; nem sempre dá para ler
+            // o tamanho, e nesse caso é melhor não listar que listar errado.
+        }
+    }
+
+    private static long TamanhoDaPasta(string pasta)
+    {
+        long total = 0;
+        var pilha = new Stack<string>();
+        pilha.Push(pasta);
+
+        while (pilha.Count > 0)
+        {
+            foreach (var entrada in Native.FastFind.Listar(pilha.Pop()))
+            {
+                if (entrada.EhPasta)
+                    pilha.Push(Path.Combine(pasta, entrada.Nome));
+                else
+                    total += entrada.Tamanho;
+            }
+        }
+
+        return total;
+    }
+
+    public static string Descrever(SpecialFile arquivo)
+        => $"{arquivo.Nome} — {GameModeModule.Formatar(arquivo.Bytes)}\n\n"
+         + $"O que é: {arquivo.OQueE}\n\n"
+         + $"Como remover: {arquivo.ComoRemover}";
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Drivers/GpuDriverInfo.cs b/GameBoost/src/GameBoost.Core/Modules/Drivers/GpuDriverInfo.cs
new file mode 100644
index 0000000..1d4d9bd
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Drivers/GpuDriverInfo.cs
@@ -0,0 +1,192 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Modules.Drivers;
+
+public enum FabricanteGpu
+{
+    Desconhecido,
+    Nvidia,
+    Amd,
+    Intel
+}
+
+/// <summary>Uma placa de vídeo e o driver instalado nela.</summary>
+public sealed record PlacaDeVideo
+{
+    public required string Nome { get; init; }
+    public required FabricanteGpu Fabricante { get; init; }
+
+    /// <summary>Versão como o Windows registra: "32.0.15.7680".</summary>
+    public required string VersaoDoDriver { get; init; }
+
+    /// <summary>
+    /// Versão como o fabricante anuncia: "576.80". Null quando não dá para
+    /// traduzir — só a NVIDIA tem uma regra estável para isso.
+    /// </summary>
+    public string? VersaoDeMarketing { get; init; }
+
+    public DateTime? DataDoDriver { get; init; }
+
+    public int? MesesDeIdade => DataDoDriver is null
+        ? null
+        : (int)((DateTime.Now - DataDoDriver.Value).TotalDays / 30.44);
+
+    public string PaginaOficial => Fabricante switch
+    {
+        FabricanteGpu.Nvidia => "https://www.nvidia.com/pt-br/geforce/drivers/",
+        FabricanteGpu.Amd => "https://www.amd.com/pt/support",
+        FabricanteGpu.Intel => "https://www.intel.com.br/content/www/br/pt/download-center/home.html",
+        _ => "https://support.microsoft.com/pt-br/windows/atualizar-drivers-manualmente-no-windows-ec62f46c-ff14-c91d-eead-d7126dc1f7b6"
+    };
+}
+
+/// <summary>
+/// Detecção do driver de vídeo (seção 5.10).
+///
+/// **O GameBoost nunca instala driver.** Ele diz qual está instalado, há quanto
+/// tempo, e abre a página oficial do fabricante. Baixar e instalar driver por
+/// conta própria é como ferramenta de "otimização" vira vetor de malware, e o
+/// ganho para o usuário seria zero — ele clica no mesmo link de qualquer jeito.
+///
+/// A leitura vem do registro, não do WMI. `Win32_VideoController` traria a
+/// mesma informação, mas uma consulta WMI custa entre 200 ms e 2 s na primeira
+/// chamada, e a página de Diagnóstico já tem orçamento apertado de tempo.
+/// </summary>
+public sealed class GpuDriverInfo
+{
+    /// <summary>Classe de dispositivo "Adaptadores de vídeo" no registro.</summary>
+    private const string ClasseDeVideo =
+        @"SYSTEM\CurrentControlSet\Control\Class\{4d36e968-e325-11ce-bfc1-08002be10318}";
+
+    private readonly IRegistryService _registro;
+    private readonly IGameBoostLogger _log;
+
+    public GpuDriverInfo(IRegistryService registro, IGameBoostLogger log)
+    {
+        _registro = registro;
+        _log = log;
+    }
+
+    public IReadOnlyList<PlacaDeVideo> Listar()
+    {
+        var placas = new List<PlacaDeVideo>();
+
+        foreach (var sub in _registro.GetSubKeyNames(RegistryRoot.LocalMachine, ClasseDeVideo))
+        {
+            // As subchaves de interesse são "0000", "0001"... O resto
+            // (Configuration, Properties) não descreve adaptador.
+            if (sub.Length != 4 || !sub.All(char.IsDigit))
+                continue;
+
+            var caminho = $@"{ClasseDeVideo}\{sub}";
+
+            var nome = _registro.GetValue(RegistryRoot.LocalMachine, caminho, "DriverDesc") as string;
+            var versao = _registro.GetValue(RegistryRoot.LocalMachine, caminho, "DriverVersion") as string;
+
+            if (string.IsNullOrWhiteSpace(nome) || string.IsNullOrWhiteSpace(versao))
+                continue;
+
+            if (EhAdaptadorVirtual(nome))
+                continue;
+
+            var fornecedor = _registro.GetValue(RegistryRoot.LocalMachine, caminho, "ProviderName") as string;
+            var fabricante = Identificar(fornecedor, nome);
+
+            placas.Add(new PlacaDeVideo
+            {
+                Nome = nome,
+                Fabricante = fabricante,
+                VersaoDoDriver = versao,
+                VersaoDeMarketing = Traduzir(fabricante, versao),
+                DataDoDriver = LerData(caminho)
+            });
+        }
+
+        if (placas.Count == 0)
+            _log.Warn("drivers", "Listar", null, "nenhum adaptador de vídeo encontrado no registro");
+
+        // GPU dedicada primeiro: em notebook com iGPU + dGPU, a que importa
+        // para jogo é a dedicada, e ela costuma vir depois na ordem do registro.
+        return placas
+            .OrderBy(p => p.Fabricante == FabricanteGpu.Intel ? 1 : 0)
+            .ToList();
+    }
+
+    private DateTime? LerData(string caminho)
+    {
+        var bruto = _registro.GetValue(RegistryRoot.LocalMachine, caminho, "DriverDate") as string;
+
+        // O formato gravado é M-D-YYYY, sempre com este separador e sempre nesta
+        // ordem, independente do idioma do Windows.
+        if (bruto is not null
+            && DateTime.TryParseExact(bruto, "M-d-yyyy",
+                System.Globalization.CultureInfo.InvariantCulture,
+                System.Globalization.DateTimeStyles.None, out var data))
+        {
+            return data;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Descarta adaptador que não é placa de vídeo: display virtual do
+    /// Hyper-V, o adaptador básico que o Windows usa antes do driver real,
+    /// monitor de sessão remota, captura de tela de software.
+    ///
+    /// Isto não é preciosismo. Todos esses drivers vêm carimbados com
+    /// 21/06/2006, a data que a Microsoft usa para driver embutido no Windows.
+    /// Sem o filtro, a tela anunciaria "seu driver de vídeo tem 242 meses" numa
+    /// máquina cujo driver real foi instalado no mês passado.
+    /// </summary>
+    internal static bool EhAdaptadorVirtual(string nome)
+    {
+        string[] marcadores =
+        {
+            "hyper-v", "basic display", "basic render", "vídeo básico", "video basico",
+            "remote display", "rdp", "citrix", "vmware", "virtualbox", "parsec",
+            "meta virtual", "idd", "indirect display", "oray", "sunshine", "usb display"
+        };
+
+        return marcadores.Any(m => nome.Contains(m, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private static FabricanteGpu Identificar(string? fornecedor, string nome)
+    {
+        var texto = $"{fornecedor} {nome}".ToLowerInvariant();
+
+        if (texto.Contains("nvidia"))
+            return FabricanteGpu.Nvidia;
+
+        if (texto.Contains("advanced micro") || texto.Contains("amd") || texto.Contains("radeon"))
+            return FabricanteGpu.Amd;
+
+        if (texto.Contains("intel"))
+            return FabricanteGpu.Intel;
+
+        return FabricanteGpu.Desconhecido;
+    }
+
+    /// <summary>
+    /// Traduz a versão do Windows para a que o fabricante anuncia.
+    ///
+    /// Só a NVIDIA tem regra estável: os cinco últimos dígitos da versão, com
+    /// ponto antes dos dois finais. "32.0.15.7680" vira "576.80". AMD e Intel
+    /// não têm correspondência previsível entre a versão do driver e o nome
+    /// comercial (Adrenalin 25.x), então aqui devolve null em vez de chutar.
+    /// </summary>
+    internal static string? Traduzir(FabricanteGpu fabricante, string versao)
+    {
+        if (fabricante != FabricanteGpu.Nvidia)
+            return null;
+
+        var digitos = new string(versao.Where(char.IsDigit).ToArray());
+
+        if (digitos.Length < 5)
+            return null;
+
+        var ultimos = digitos[^5..];
+        return $"{ultimos[..3]}.{ultimos[3..]}";
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/GameMode/GameDetector.cs b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameDetector.cs
new file mode 100644
index 0000000..255131f
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameDetector.cs
@@ -0,0 +1,164 @@
+using GameBoost.Core.Abstractions;
+
+namespace GameBoost.Core.Modules.GameMode;
+
+public sealed record DetectedGame(ProcessInfo Process, string Motivo, int Confianca);
+
+/// <summary>
+/// Descobre qual processo e o jogo. Ordem de confianca: pasta de launcher,
+/// nome conhecido, consumo de memoria com janela visivel.
+/// </summary>
+public sealed class GameDetector
+{
+    private static readonly string[] PastasDeJogo =
+    {
+        @"\steamapps\common\", @"\epic games\", @"\riot games\",
+        @"\battle.net\", @"\gog galaxy\games\", @"\gog games\",
+        @"\xboxgames\", @"\ea games\", @"\origin games\",
+        @"\ubisoft\ubisoft game launcher\games\", @"\games\"
+    };
+
+    private static readonly IReadOnlySet<string> JogosConhecidos = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "valorant", "valorant-win64-shipping",
+        "cs2", "csgo", "dota2",
+        "leagueoflegends", "league of legends",
+        "cyberpunk2077", "witcher3",
+        "fortniteclient-win64-shipping",
+        "r5apex", "apex",
+        "gta5", "gtav", "rdr2",
+        "eldenring", "sekiro", "darksouls3",
+        "hd2", "helldivers2",
+        "overwatch", "hearthstone", "wow", "wowclassic", "diablo iv", "diabloiv",
+        "rocketleague", "minecraft", "javaw",
+        "pubg", "tslgame", "rust", "rustclient",
+        "destiny2", "warframe", "bf2042", "bf1", "codmw", "cod",
+        "starfield", "baldursgate3", "bg3", "bg3_dx11",
+        "palworld-win64-shipping", "marvelrivals", "deltaforceclient"
+    };
+
+    /// <summary>
+    /// Deteccao barata, so por nome conhecido. Existe para o monitor de
+    /// gargalos, que roda a cada segundo e nao pode pagar a varredura completa:
+    /// aquela consulta o WMI e enumera janelas, o que custaria mais que toda a
+    /// coleta de metricas junta.
+    /// </summary>
+    public string? DetectarPorNome(IEnumerable<string> nomesDeProcesso)
+    {
+        foreach (var nome in nomesDeProcesso)
+        {
+            var normalizado = Safety.ProtectedProcesses.Normalizar(nome);
+
+            if (!NaoSaoJogos.Contains(normalizado) && JogosConhecidos.Contains(normalizado))
+                return nome;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Instalado pela Steam, mas nao e jogo. Sem esta lista, o Wallpaper Engine
+    /// vira "o jogo" so por morar em steamapps\common, e o Modo Game acaba
+    /// subindo a prioridade do papel de parede em vez da do jogo de verdade.
+    /// Foi exatamente o que aconteceu no primeiro teste com privilegios.
+    /// </summary>
+    private static readonly IReadOnlySet<string> NaoSaoJogos = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "wallpaper64", "wallpaper32", "wallpaperservice64", "webwallpaper32",
+        "vrmonitor", "vrserver", "vrcompositor", "vrdashboard", "steamvr",
+        "aseprite", "blender", "krita", "obs64", "3dsmax", "unity", "unityhub",
+        "rpcs3", "pcsx2", "dolphin", "retroarch",
+        "steamwebhelper", "gameoverlayui", "steamerrorreporter",
+
+        // Atualizadores e serviços que moram DENTRO da pasta do launcher.
+        //
+        // O "Agent" do Battle.net vive em ProgramData\\Battle.net\\Agent e foi
+        // anunciado como jogo numa sessão real: ele engorda enquanto baixa
+        // atualização, passou do limite de memória, e a pasta bate com a lista
+        // de launchers. Nome genérico dentro de pasta de launcher é quase
+        // sempre infraestrutura, não jogo.
+        "agent", "battle.net helper", "blizzard error handler",
+        "epicgameslauncher", "epicwebhelper", "unrealcefsubprocess",
+        "eabackgroundservice", "eadesktop", "eacrashreporter",
+        "upc", "uplaywebcore", "ubisoftgamelauncher", "ubisoftconnect",
+        "riotclientservices", "riotclientux", "riotclientcrashhandler",
+        "galaxyclient", "galaxycommunication", "goggalaxynotifications",
+        "launcher", "updater", "update", "crashhandler", "crashreporter",
+        "bootstrapper", "installer", "setup", "helper", "service"
+    };
+
+    public DetectedGame? Detectar(IEnumerable<ProcessInfo> processos)
+    {
+        DetectedGame? melhor = null;
+
+        foreach (var p in processos)
+        {
+            var candidato = Avaliar(p);
+            if (candidato is null)
+                continue;
+
+            if (melhor is null || candidato.Confianca > melhor.Confianca)
+                melhor = candidato;
+        }
+
+        return melhor;
+    }
+
+    /// <summary>
+    /// Nome que descreve função, não produto.
+    ///
+    /// Jogo tem nome próprio. "Agent", "Launcher" e "Updater" são o que o
+    /// programa faz, e dentro de uma pasta de launcher é sempre a
+    /// infraestrutura dele.
+    /// </summary>
+    private static bool NomeGenerico(string nome)
+    {
+        string[] genericos =
+        {
+            "agent", "launcher", "updater", "update", "helper", "service",
+            "host", "daemon", "bootstrap", "bootstrapper", "crashhandler",
+            "crashreporter", "installer", "setup", "client", "overlay"
+        };
+
+        return genericos.Contains(nome, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private static DetectedGame? Avaliar(ProcessInfo p)
+    {
+        var nome = Safety.ProtectedProcesses.Normalizar(p.Name);
+
+        if (NaoSaoJogos.Contains(nome))
+            return null;
+
+        if (JogosConhecidos.Contains(nome))
+            return new DetectedGame(p, "nome de jogo conhecido", 100);
+
+        if (!string.IsNullOrEmpty(p.ExecutablePath))
+        {
+            var caminho = p.ExecutablePath.Replace('/', '\\');
+            if (PastasDeJogo.Any(pasta => caminho.Contains(pasta, StringComparison.OrdinalIgnoreCase)))
+            {
+                // Pasta de launcher tem jogo e tem a maquinaria do launcher.
+                // Um nome que so descreve funcao ("agent", "launcher",
+                // "updater") descreve a maquinaria.
+                if (NomeGenerico(nome))
+                    return null;
+
+                // Estar na pasta do launcher nao basta: utilitarios instalados
+                // pela Steam moram no mesmo lugar. Jogo em execucao ocupa
+                // memoria de jogo.
+                if (p.WorkingSetBytes < 300L * 1024 * 1024)
+                    return null;
+
+                return new DetectedGame(p, "executavel dentro de uma pasta de launcher", 80);
+            }
+        }
+
+        // Heuristica fraca: processo pesado com janela propria. So vale se nada
+        // melhor aparecer, e por isso a confianca baixa.
+        if (p.WorkingSetBytes > 1_500L * 1024 * 1024 && !string.IsNullOrWhiteSpace(p.WindowTitle))
+            return new DetectedGame(p, "processo pesado com janela em primeiro plano", 30);
+
+        return null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/GameMode/GameModeModule.cs b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameModeModule.cs
new file mode 100644
index 0000000..6c387f0
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameModeModule.cs
@@ -0,0 +1,600 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Services;
+using GameBoost.Core.Settings;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.GameMode;
+
+/// <summary>
+/// O Modo Game da v1 portado para IModule/ActionItem.
+///
+/// ScanAsync  -> lista o que sera encerrado, ja com a blindagem aplicada.
+/// ApplyAsync -> liga o Modo Game com os itens confirmados pelo usuario.
+/// RevertAsync-> desliga, devolve o sistema e reabre os apps essenciais.
+/// </summary>
+public sealed class GameModeModule : IModule
+{
+    public const string ModuloId = "gamemode";
+
+    private static readonly TimeSpan EsperaDeFechamento = TimeSpan.FromSeconds(3);
+
+    private readonly IProcessService _processes;
+    private readonly IMemoryService _memory;
+    private readonly IPowerService _power;
+    private readonly ISafetyGuard _guard;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly ISessionStore _sessions;
+    private readonly SystemSilencer _silencer;
+    private readonly GameDetector _detector;
+    private readonly AppSettings _settings;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _clock;
+
+    public GameModeModule(
+        IProcessService processes,
+        IMemoryService memory,
+        IPowerService power,
+        ISafetyGuard guard,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        ISessionStore sessions,
+        SystemSilencer silencer,
+        GameDetector detector,
+        AppSettings settings,
+        IGameBoostLogger log,
+        IClock clock)
+    {
+        _processes = processes;
+        _memory = memory;
+        _power = power;
+        _guard = guard;
+        _backup = backup;
+        _rollback = rollback;
+        _sessions = sessions;
+        _silencer = silencer;
+        _detector = detector;
+        _settings = settings;
+        _log = log;
+        _clock = clock;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Modo Game";
+    public string Descricao => "Encerra o que voce confirmar, libera RAM e prepara o sistema para o jogo.";
+
+    public bool Ativo => _sessions.Load().Ativo;
+
+    // ------------------------------------------------------------------
+    // Varredura
+    // ------------------------------------------------------------------
+
+    public Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+        => Task.Run(() => Varrer(progress, ct), ct);
+
+    private ScanResult Varrer(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        progress?.Report(new ModuleProgress("Lendo processos", 10));
+        var processos = _processes.GetProcesses();
+        ct.ThrowIfCancellationRequested();
+
+        progress?.Report(new ModuleProgress("Procurando o jogo", 35));
+        var jogo = _detector.Detectar(processos);
+
+        progress?.Report(new ModuleProgress("Aplicando a blindagem", 60));
+        var itens = new List<ActionItem>();
+        var avisos = new List<string>();
+
+        // Agrupa por nome: o Chrome com 40 processos vira um unico item.
+        var grupos = processos
+            .Where(p => p.Pid > 4)
+            .GroupBy(p => ProtectedProcesses.Normalizar(p.Name), StringComparer.OrdinalIgnoreCase);
+
+        foreach (var grupo in grupos)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var representante = grupo.OrderByDescending(p => p.WorkingSetBytes).First();
+            var veredito = _guard.CheckProcess(representante);
+
+            // Protegidos por seguranca nem aparecem: poluiriam a lista com
+            // dezenas de svchost que o usuario nunca deve tocar.
+            if (veredito.Protegido && veredito.Motivo is
+                ProtectionReason.ProcessoCritico or
+                ProtectionReason.DentroDoWindows or
+                ProtectionReason.OutraSessao or
+                ProtectionReason.ProprioApp)
+            {
+                continue;
+            }
+
+            var ehOJogo = jogo is not null && grupo.Any(p => p.Pid == jogo.Process.Pid);
+            var ramGrupo = grupo.Sum(p => p.WorkingSetBytes);
+
+            if (_settings.SoOEssencial && !ehOJogo && !veredito.Protegido)
+            {
+                var limite = _settings.LimiteRamMegabytes * 1024L * 1024L;
+                if (ramGrupo < limite)
+                    continue;
+            }
+
+            itens.Add(MontarItem(grupo.Key, grupo.ToList(), representante, veredito, ehOJogo, ramGrupo));
+        }
+
+        progress?.Report(new ModuleProgress("Medindo a memoria", 85));
+        var memoria = _memory.GetSnapshot();
+
+        if (jogo is null)
+            avisos.Add("Nenhum jogo detectado. A prioridade de CPU nao sera alterada.");
+
+        var plano = _power.GetActivePlan();
+        if (plano is not null && plano.Id == WindowsPowerService.Balanceado)
+            avisos.Add("Plano de energia Balanceado ativo: o Modo Game vai trocar para Alto desempenho.");
+
+        var marcados = itens.Count(i => i.PreMarcado);
+        var ramMarcada = itens.Where(i => i.PreMarcado).Sum(i => i.GanhoBytes);
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens.OrderByDescending(i => i.GanhoBytes).ToList(),
+            Momento = _clock.Now,
+            Avisos = avisos,
+            Resumo = jogo is not null
+                ? $"{marcados} apps marcados, ate {Formatar(ramMarcada)} de RAM. Jogo detectado: {jogo.Process.Name}. RAM livre agora: {Formatar(memoria.AvailableBytes)}."
+                : $"{marcados} apps marcados, ate {Formatar(ramMarcada)} de RAM. RAM livre agora: {Formatar(memoria.AvailableBytes)}."
+        };
+    }
+
+    private ActionItem MontarItem(
+        string nome,
+        IReadOnlyList<ProcessInfo> grupo,
+        ProcessInfo representante,
+        ProtectionVerdict veredito,
+        bool ehOJogo,
+        long ramGrupo)
+    {
+        var eEssencial = _settings.Essenciais.Any(e =>
+            ProtectedProcesses.Normalizar(e.Nome).Equals(nome, StringComparison.OrdinalIgnoreCase));
+
+        var preMarcado = !ehOJogo && !veredito.Protegido && _guard.PodePreMarcar(representante);
+
+        var descricao = grupo.Count > 1
+            ? $"{grupo.Count} processos, {Formatar(ramGrupo)} de RAM."
+            : $"{Formatar(ramGrupo)} de RAM.";
+
+        if (!string.IsNullOrWhiteSpace(representante.WindowTitle))
+            descricao += $" Janela aberta: {representante.WindowTitle}";
+
+        if (ehOJogo)
+            descricao = "Este parece ser o jogo. " + descricao;
+
+        var risco = ehOJogo || veredito.Protegido
+            ? RiskLevel.Alto
+            : ProtectedProcesses.NuncaPreMarcados.Contains(nome)
+                ? RiskLevel.Medio
+                : RiskLevel.Baixo;
+
+        return new ActionItem
+        {
+            Id = $"proc:{nome}",
+            Categoria = ehOJogo ? "Jogo" : veredito.Protegido ? "Protegido" : "Aplicativos",
+            Titulo = representante.Name,
+            Descricao = descricao,
+            Risco = risco,
+            GanhoBytes = ramGrupo,
+            GanhoEstimado = $"ate {Formatar(ramGrupo)} de RAM",
+            PreMarcado = preMarcado,
+            Bloqueado = veredito.Protegido || ehOJogo,
+            MotivoBloqueio = ehOJogo
+                ? "O GameBoost nunca encerra o jogo que voce vai jogar."
+                : veredito.Protegido ? veredito.Explicacao : null,
+            ComoDesfazer = eEssencial
+                ? "Marcado como essencial: reabre sozinho ao desligar o Modo Game."
+                : "Aparece na lista de restauracao ao desligar o Modo Game, com botao Restaurar.",
+            Payload = grupo
+        };
+    }
+
+    // ------------------------------------------------------------------
+    // Ativacao
+    // ------------------------------------------------------------------
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Ativar(itemIds, dryRun, ct), ct);
+
+    private ApplyResult Ativar(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+    {
+        var acoes = new List<AppliedAction>();
+        var antes = _memory.GetSnapshot();
+
+        var sessao = new GameSession
+        {
+            Ativo = !dryRun,
+            AtivadoEm = _clock.Now,
+            RamLivreAntes = antes.AvailableBytes,
+            RamTotal = antes.TotalBytes
+        };
+
+        var processos = _processes.GetProcesses();
+        var jogo = _detector.Detectar(processos);
+
+        if (jogo is not null)
+        {
+            sessao.JogoDetectado = jogo.Process.Name;
+            sessao.PidDoJogo = jogo.Process.Pid;
+        }
+
+        // 1. Encerrar os apps confirmados.
+        var nomesSelecionados = itemIds
+            .Where(id => id.StartsWith("proc:", StringComparison.Ordinal))
+            .Select(id => id[5..])
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var grupo in processos.GroupBy(p => ProtectedProcesses.Normalizar(p.Name), StringComparer.OrdinalIgnoreCase))
+        {
+            ct.ThrowIfCancellationRequested();
+
+            if (!nomesSelecionados.Contains(grupo.Key))
+                continue;
+
+            // Segunda checagem antes de matar: a lista pode ter vindo de um scan
+            // antigo, ou o usuario pode ter editado o JSON na mao.
+            var representante = grupo.OrderByDescending(p => p.WorkingSetBytes).First();
+            var veredito = _guard.CheckProcess(representante);
+            if (veredito.Protegido)
+            {
+                acoes.Add(new AppliedAction($"proc:{grupo.Key}", false, $"Bloqueado: {veredito.Explicacao}", null));
+                continue;
+            }
+
+            if (jogo is not null && grupo.Any(p => p.Pid == jogo.Process.Pid))
+            {
+                acoes.Add(new AppliedAction($"proc:{grupo.Key}", false, "Bloqueado: e o jogo detectado.", null));
+                continue;
+            }
+
+            acoes.Add(EncerrarGrupo(grupo.Key, grupo.ToList(), sessao, dryRun));
+        }
+
+        // 2. Plano de energia.
+        if (_settings.AplicarPlanoEnergia)
+            acoes.Add(AplicarPlanoDeEnergia(dryRun));
+
+        // 3. Silenciar o sistema.
+        if (_settings.SilenciarNotificacoes || _settings.DesativarGameDvr)
+        {
+            foreach (var tweak in SystemSilencer.Tweaks)
+            {
+                ct.ThrowIfCancellationRequested();
+                var changeId = _silencer.Aplicar(tweak, dryRun);
+                acoes.Add(new AppliedAction($"tweak:{tweak.ValueName}", true,
+                    changeId is null ? $"{tweak.Nome}: ja estava aplicado." : $"{tweak.Nome}: aplicado.", changeId));
+            }
+        }
+
+        if (_settings.PausarWindowsUpdate)
+        {
+            var changeId = _silencer.PausarWindowsUpdate(dryRun);
+            acoes.Add(new AppliedAction("service:wuauserv", true,
+                changeId is null
+                    ? "Windows Update ja estava parado."
+                    : "Windows Update pausado ate desligar o Modo Game.", changeId));
+        }
+
+        // 4. Prioridade do jogo.
+        if (_settings.SubirPrioridadeDoJogo && jogo is not null)
+            acoes.Add(SubirPrioridade(jogo, dryRun));
+
+        // 5. Limpeza de RAM: por ultimo, para medir depois dos apps ja fechados.
+        if (_settings.LimparRam)
+            acoes.Add(LimparRam(dryRun, ct));
+
+        if (_settings.PurgarStandbyList && !dryRun)
+        {
+            var ok = _memory.PurgeStandbyList();
+            acoes.Add(new AppliedAction("mem:standby", ok,
+                ok ? "Standby List purgada." : "Standby List nao pode ser purgada (precisa de administrador).", null));
+        }
+
+        var depois = _memory.GetSnapshot();
+        sessao.RamLivreDepois = depois.AvailableBytes;
+
+        if (!dryRun)
+            _sessions.Save(sessao);
+
+        var ganho = depois.AvailableBytes - antes.AvailableBytes;
+        var encerrados = sessao.AppsEncerrados.Count;
+
+        _log.Info(ModuloId, dryRun ? "Ativar (dry-run)" : "Ativar", null,
+            $"{encerrados} apps encerrados, RAM livre {Formatar(antes.AvailableBytes)} -> {Formatar(depois.AvailableBytes)}");
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? "Simulacao concluida. Nada foi alterado."
+                : $"Modo Game ativo. {encerrados} apps encerrados.",
+            GanhoMedido = dryRun
+                ? "Dry-run nao mede ganho."
+                : ganho > 0
+                    ? $"RAM livre: {Formatar(antes.AvailableBytes)} -> {Formatar(depois.AvailableBytes)} ({Formatar(ganho)} a mais)"
+                    : $"RAM livre: {Formatar(depois.AvailableBytes)}. Sem ganho mensuravel de memoria."
+        };
+    }
+
+    private AppliedAction EncerrarGrupo(string nome, IReadOnlyList<ProcessInfo> grupo, GameSession sessao, bool dryRun)
+    {
+        var itemId = $"proc:{nome}";
+
+        if (dryRun)
+            return new AppliedAction(itemId, true, $"Encerraria {grupo.Count} processo(s) de {nome}.", null);
+
+        var essencial = _settings.Essenciais.FirstOrDefault(e =>
+            ProtectedProcesses.Normalizar(e.Nome).Equals(nome, StringComparison.OrdinalIgnoreCase));
+
+        var principal = grupo
+            .OrderByDescending(p => !string.IsNullOrWhiteSpace(p.WindowTitle))
+            .ThenByDescending(p => p.WorkingSetBytes)
+            .First();
+
+        var fechados = 0;
+        var forcados = 0;
+
+        foreach (var p in grupo)
+        {
+            // Fechamento gracioso primeiro: o app pede para salvar o que estiver aberto.
+            if (_processes.TryCloseGracefully(p.Pid, EsperaDeFechamento))
+            {
+                fechados++;
+                continue;
+            }
+
+            if (_processes.Kill(p.Pid))
+            {
+                fechados++;
+                forcados++;
+            }
+        }
+
+        if (fechados == 0)
+            return new AppliedAction(itemId, false, $"Nao foi possivel encerrar {nome}.", null);
+
+        sessao.AppsEncerrados.Add(new ClosedApp
+        {
+            Nome = principal.Name,
+            ExecutablePath = principal.ExecutablePath ?? essencial?.ExecutablePath,
+            Argumentos = ExtrairArgumentos(principal) ?? essencial?.Argumentos,
+            WorkingDirectory = principal.ExecutablePath is null ? null : Path.GetDirectoryName(principal.ExecutablePath),
+            Essencial = essencial is not null
+        });
+
+        var detalhe = forcados > 0
+            ? $"{fechados} processo(s) encerrados ({forcados} a forca apos {EsperaDeFechamento.TotalSeconds:0} s)."
+            : $"{fechados} processo(s) encerrados normalmente.";
+
+        return new AppliedAction(itemId, true, detalhe, null);
+    }
+
+    /// <summary>A linha de comando do WMI vem com o exe na frente: remove para sobrar so os argumentos.</summary>
+    private static string? ExtrairArgumentos(ProcessInfo p)
+    {
+        if (string.IsNullOrWhiteSpace(p.CommandLine))
+            return null;
+
+        var linha = p.CommandLine.Trim();
+
+        if (linha.StartsWith('"'))
+        {
+            var fim = linha.IndexOf('"', 1);
+            if (fim > 0 && fim + 1 < linha.Length)
+                return linha[(fim + 1)..].Trim();
+            return null;
+        }
+
+        var espaco = linha.IndexOf(' ');
+        return espaco > 0 ? linha[(espaco + 1)..].Trim() : null;
+    }
+
+    private AppliedAction AplicarPlanoDeEnergia(bool dryRun)
+    {
+        var atual = _power.GetActivePlan();
+        if (atual is null)
+            return new AppliedAction("power:plan", false, "Nao foi possivel ler o plano de energia atual.", null);
+
+        var planos = _power.GetPlans();
+        var alvo = planos.FirstOrDefault(p => p.Id == WindowsPowerService.DesempenhoMaximo)
+                   ?? planos.FirstOrDefault(p => p.Id == WindowsPowerService.AltoDesempenho);
+
+        if (alvo is null)
+            return new AppliedAction("power:plan", false,
+                "Nenhum plano de Alto desempenho disponivel nesta maquina.", null);
+
+        if (atual.Id == alvo.Id)
+            return new AppliedAction("power:plan", true, $"Plano {alvo.Name} ja estava ativo.", null);
+
+        if (dryRun)
+            return new AppliedAction("power:plan", true, $"Trocaria {atual.Name} por {alvo.Name}.", null);
+
+        var record = _backup.Registrar(new ChangeRecord
+        {
+            Modulo = ModuloId,
+            Tipo = ChangeType.Power,
+            Alvo = "plano-de-energia",
+            ValorAnterior = atual.Id.ToString(),
+            ValorNovo = alvo.Id.ToString(),
+            Extras = { ["nome"] = $"Plano de energia ({atual.Name})" }
+        });
+
+        var ok = _power.SetActivePlan(alvo.Id);
+        return new AppliedAction("power:plan", ok,
+            ok ? $"Plano de energia: {atual.Name} -> {alvo.Name}." : "Nao foi possivel trocar o plano de energia.",
+            ok ? record.Id : null);
+    }
+
+    private AppliedAction SubirPrioridade(DetectedGame jogo, bool dryRun)
+    {
+        var anterior = _processes.GetPriority(jogo.Process.Pid);
+        if (anterior is null)
+            return new AppliedAction("priority:game", false, "Nao foi possivel ler a prioridade do jogo.", null);
+
+        if (anterior == ProcessPriority.High)
+            return new AppliedAction("priority:game", true, $"{jogo.Process.Name} ja estava em prioridade Alta.", null);
+
+        if (dryRun)
+            return new AppliedAction("priority:game", true,
+                $"Subiria {jogo.Process.Name} de {anterior} para Alta.", null);
+
+        // Prioridade morre com o processo: nao precisa de ChangeRecord, mas fica no log.
+        var ok = _processes.SetPriority(jogo.Process.Pid, ProcessPriority.High);
+        _log.Info(ModuloId, "Prioridade", jogo.Process.Name,
+            ok ? $"{anterior} -> High ({jogo.Motivo})" : "falhou");
+
+        return new AppliedAction("priority:game", ok,
+            ok ? $"{jogo.Process.Name}: prioridade Alta (nunca Tempo real)." : "Nao foi possivel subir a prioridade.",
+            null);
+    }
+
+    private AppliedAction LimparRam(bool dryRun, CancellationToken ct)
+    {
+        if (dryRun)
+            return new AppliedAction("mem:workingset", true, "Faria EmptyWorkingSet em todos os processos.", null);
+
+        long total = 0;
+        var tocados = 0;
+
+        foreach (var p in _processes.GetProcesses())
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var liberado = _processes.TrimWorkingSet(p.Pid);
+            if (liberado > 0)
+            {
+                total += liberado;
+                tocados++;
+            }
+        }
+
+        return new AppliedAction("mem:workingset", true,
+            $"{Formatar(total)} retirados do working set de {tocados} processos.", null);
+    }
+
+    // ------------------------------------------------------------------
+    // Desligamento
+    // ------------------------------------------------------------------
+
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Desligar(changeIds, dryRun), ct);
+
+    private ApplyResult Desligar(IReadOnlyList<string> changeIds, bool dryRun)
+    {
+        var acoes = new List<AppliedAction>();
+
+        // 1. Desfazer as alteracoes de sistema, da mais recente para a mais antiga.
+        var doModulo = _backup.Pendentes
+            .Where(r => r.Modulo == ModuloId)
+            .Where(r => changeIds.Count == 0 || changeIds.Contains(r.Id))
+            .Select(r => r.Id)
+            .ToList();
+
+        foreach (var resultado in _rollback.Reverter(doModulo, dryRun))
+            acoes.Add(new AppliedAction(resultado.ChangeId, resultado.Sucesso, resultado.Detalhe, resultado.ChangeId));
+
+        // 2. Reabrir os apps marcados com estrela.
+        var sessao = _sessions.Load();
+        var reabertos = 0;
+
+        foreach (var app in sessao.AppsEncerrados.Where(a => a.Essencial && !a.Reaberto))
+        {
+            if (string.IsNullOrWhiteSpace(app.ExecutablePath))
+            {
+                acoes.Add(new AppliedAction($"reopen:{app.Nome}", false,
+                    $"{app.Nome}: caminho do executavel desconhecido, reabra manualmente.", null));
+                continue;
+            }
+
+            if (dryRun)
+            {
+                acoes.Add(new AppliedAction($"reopen:{app.Nome}", true, $"Reabriria {app.Nome}.", null));
+                continue;
+            }
+
+            var ok = _processes.Start(app.ExecutablePath, app.Argumentos, app.WorkingDirectory);
+            app.Reaberto = ok;
+            if (ok)
+                reabertos++;
+
+            acoes.Add(new AppliedAction($"reopen:{app.Nome}", ok,
+                ok ? $"{app.Nome} reaberto." : $"Nao foi possivel reabrir {app.Nome}.", null));
+        }
+
+        var naoEssenciais = sessao.AppsEncerrados.Count(a => !a.Essencial);
+
+        if (!dryRun)
+        {
+            sessao.Ativo = false;
+            _sessions.Save(sessao);
+        }
+
+        _log.Info(ModuloId, dryRun ? "Desligar (dry-run)" : "Desligar", null,
+            $"{doModulo.Count} alteracoes revertidas, {reabertos} apps reabertos");
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? "Simulacao de desligamento. Nada foi alterado."
+                : $"Modo Game desligado. {reabertos} apps reabertos, {naoEssenciais} aguardando na lista de restauracao.",
+            GanhoMedido = sessao.RamLivreAntes > 0
+                ? $"Durante a sessao a RAM livre foi de {Formatar(sessao.RamLivreAntes)} para {Formatar(sessao.RamLivreDepois)}."
+                : string.Empty
+        };
+    }
+
+    /// <summary>Reabre um app da lista de restauracao, um por vez, pelo botao da UI.</summary>
+    public bool RestaurarApp(string nome)
+    {
+        var sessao = _sessions.Load();
+        var app = sessao.AppsEncerrados.FirstOrDefault(a =>
+            a.Nome.Equals(nome, StringComparison.OrdinalIgnoreCase) && !a.Reaberto);
+
+        if (app?.ExecutablePath is null)
+            return false;
+
+        var ok = _processes.Start(app.ExecutablePath, app.Argumentos, app.WorkingDirectory);
+        if (ok)
+        {
+            app.Reaberto = true;
+            _sessions.Save(sessao);
+        }
+
+        _log.Info(ModuloId, "RestaurarApp", nome, ok ? "reaberto" : "falhou");
+        return ok;
+    }
+
+    public static string Formatar(long bytes)
+    {
+        var negativo = bytes < 0;
+        var valor = Math.Abs((double)bytes);
+
+        string texto;
+        if (valor >= 1024L * 1024 * 1024)
+            texto = $"{valor / (1024.0 * 1024 * 1024):0.0} GB";
+        else if (valor >= 1024 * 1024)
+            texto = $"{valor / (1024.0 * 1024):0} MB";
+        else if (valor >= 1024)
+            texto = $"{valor / 1024.0:0} KB";
+        else
+            texto = $"{valor:0} B";
+
+        return negativo ? "-" + texto : texto;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/GameMode/GameSession.cs b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameSession.cs
new file mode 100644
index 0000000..89eac78
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/GameMode/GameSession.cs
@@ -0,0 +1,89 @@
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.GameMode;
+
+/// <summary>App encerrado pelo Modo Game, com o necessario para reabrir depois.</summary>
+public sealed class ClosedApp
+{
+    public string Nome { get; set; } = string.Empty;
+    public string? ExecutablePath { get; set; }
+    public string? Argumentos { get; set; }
+    public string? WorkingDirectory { get; set; }
+
+    /// <summary>Marcado com estrela: reabre sozinho ao desligar o Modo Game.</summary>
+    public bool Essencial { get; set; }
+
+    public bool Reaberto { get; set; }
+}
+
+/// <summary>
+/// Conteudo de session.json. Sobrevive a um travamento: se o app morrer com o
+/// Modo Game ativo, a proxima abertura le este arquivo e oferece a restauracao.
+/// </summary>
+public sealed class GameSession
+{
+    public bool Ativo { get; set; }
+    public DateTimeOffset? AtivadoEm { get; set; }
+    public string? JogoDetectado { get; set; }
+    public int? PidDoJogo { get; set; }
+    public List<ClosedApp> AppsEncerrados { get; set; } = new();
+
+    public long RamLivreAntes { get; set; }
+    public long RamLivreDepois { get; set; }
+    public long RamTotal { get; set; }
+}
+
+public interface ISessionStore
+{
+    GameSession Load();
+    void Save(GameSession session);
+    void Clear();
+}
+
+public sealed class SessionStore : ISessionStore
+{
+    private static readonly JsonSerializerOptions Json = new()
+    {
+        WriteIndented = true,
+        PropertyNameCaseInsensitive = true
+    };
+
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+
+    public SessionStore(AppPaths paths, IFileSystem fs, IGameBoostLogger log)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+    }
+
+    public GameSession Load()
+    {
+        if (!_fs.FileExists(_paths.SessionFile))
+            return new GameSession();
+
+        try
+        {
+            return JsonSerializer.Deserialize<GameSession>(_fs.ReadAllText(_paths.SessionFile), Json)
+                ?? new GameSession();
+        }
+        catch (JsonException ex)
+        {
+            _log.Error("GameMode", "LoadSession", _paths.SessionFile, "session.json ilegivel", ex);
+            return new GameSession();
+        }
+    }
+
+    public void Save(GameSession session)
+    {
+        _fs.CreateDirectory(_paths.RootDirectory);
+        _fs.WriteAllText(_paths.SessionFile, JsonSerializer.Serialize(session, Json));
+    }
+
+    public void Clear() => Save(new GameSession());
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs b/GameBoost/src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs
new file mode 100644
index 0000000..4fb846e
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/GameMode/SystemSilencer.cs
@@ -0,0 +1,172 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Services;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.GameMode;
+
+/// <summary>Um ajuste de registro com valor alvo. O anterior vira ChangeRecord antes de aplicar.</summary>
+public sealed record RegistryTweak(
+    string Nome,
+    RegistryRoot Root,
+    string SubKey,
+    string ValueName,
+    int ValorDesejado,
+    string Explicacao);
+
+/// <summary>
+/// Silencia o que atrapalha durante o jogo: notificacoes, gravacao em segundo
+/// plano, overlay da Game Bar e Windows Update. Tudo reversivel (regra 1).
+/// </summary>
+public sealed class SystemSilencer
+{
+    public const string ModuloId = "gamemode";
+
+    public static readonly IReadOnlyList<RegistryTweak> Tweaks = new[]
+    {
+        new RegistryTweak(
+            "Notificacoes do Windows",
+            RegistryRoot.CurrentUser,
+            @"Software\Microsoft\Windows\CurrentVersion\PushNotifications",
+            "ToastEnabled", 0,
+            "Impede que notificacoes apareçam sobre o jogo em tela cheia."),
+
+        new RegistryTweak(
+            "Gravacao em segundo plano (Game DVR)",
+            RegistryRoot.CurrentUser,
+            @"System\GameConfigStore",
+            "GameDVR_Enabled", 0,
+            "Desliga a gravacao continua da Game Bar, que consome CPU e GPU o tempo todo."),
+
+        new RegistryTweak(
+            "Overlay da Xbox Game Bar",
+            RegistryRoot.CurrentUser,
+            @"Software\Microsoft\GameBar",
+            "UseNexusForGameBarEnabled", 0,
+            "Desliga o overlay da Game Bar, que injeta codigo em todo jogo aberto."),
+
+        new RegistryTweak(
+            "Dica de abertura da Game Bar",
+            RegistryRoot.CurrentUser,
+            @"Software\Microsoft\GameBar",
+            "ShowStartupPanel", 0,
+            "Evita o painel da Game Bar aparecer ao abrir o jogo.")
+    };
+
+    private readonly IRegistryService _registry;
+    private readonly IServiceControllerService _services;
+    private readonly IStateBackup _backup;
+    private readonly ISafetyGuard _guard;
+    private readonly IGameBoostLogger _log;
+
+    public SystemSilencer(
+        IRegistryService registry,
+        IServiceControllerService services,
+        IStateBackup backup,
+        ISafetyGuard guard,
+        IGameBoostLogger log)
+    {
+        _registry = registry;
+        _services = services;
+        _backup = backup;
+        _guard = guard;
+        _log = log;
+    }
+
+    /// <summary>Aplica um tweak gravando antes o valor anterior. Retorna o id do ChangeRecord.</summary>
+    public string? Aplicar(RegistryTweak tweak, bool dryRun)
+    {
+        var anterior = _registry.GetValue(tweak.Root, tweak.SubKey, tweak.ValueName);
+        var existia = anterior is not null;
+
+        if (existia && anterior is int atual && atual == tweak.ValorDesejado)
+        {
+            _log.Info(ModuloId, "Tweak", tweak.Nome, "ja estava no valor desejado, nada a fazer");
+            return null;
+        }
+
+        if (dryRun)
+        {
+            _log.Info(ModuloId, "Tweak (dry-run)", tweak.Nome,
+                $"mudaria de {anterior?.ToString() ?? "(inexistente)"} para {tweak.ValorDesejado}");
+            return null;
+        }
+
+        var record = _backup.Registrar(new ChangeRecord
+        {
+            Modulo = ModuloId,
+            Tipo = ChangeType.Registry,
+            Alvo = tweak.SubKey,
+            SubAlvo = tweak.ValueName,
+            ValorAnterior = WindowsRegistryService.Serializar(anterior),
+            ValorNovo = tweak.ValorDesejado.ToString(),
+            ValorAnteriorExistia = existia,
+            Extras =
+            {
+                ["root"] = tweak.Root.ToString(),
+                ["kind"] = RegistryValueKindLite.DWord.ToString(),
+                ["nome"] = tweak.Nome
+            }
+        });
+
+        _registry.SetValue(tweak.Root, tweak.SubKey, tweak.ValueName, tweak.ValorDesejado, RegistryValueKindLite.DWord);
+        _log.Info(ModuloId, "Tweak", tweak.Nome, $"aplicado: {tweak.ValueName}={tweak.ValorDesejado}");
+        return record.Id;
+    }
+
+    /// <summary>
+    /// Pausa o Windows Update parando wuauserv, sem mexer no StartType. Se o app
+    /// morrer aqui, o ChangeRecord garante que o servico volta.
+    /// </summary>
+    public string? PausarWindowsUpdate(bool dryRun)
+    {
+        const string servico = "wuauserv";
+
+        var veredito = _guard.CheckService(servico, apenasPausar: true);
+        if (veredito.Protegido)
+        {
+            _log.Warn(ModuloId, "PausarUpdate", servico, veredito.Explicacao);
+            return null;
+        }
+
+        var atual = _services.GetService(servico);
+        if (atual is null)
+        {
+            _log.Warn(ModuloId, "PausarUpdate", servico, "servico nao encontrado");
+            return null;
+        }
+
+        if (!atual.IsRunning)
+        {
+            _log.Info(ModuloId, "PausarUpdate", servico, "ja estava parado");
+            return null;
+        }
+
+        if (dryRun)
+        {
+            _log.Info(ModuloId, "PausarUpdate (dry-run)", servico, "pararia o servico");
+            return null;
+        }
+
+        var record = _backup.Registrar(new ChangeRecord
+        {
+            Modulo = ModuloId,
+            Tipo = ChangeType.Service,
+            Alvo = servico,
+            ValorAnterior = atual.StartMode.ToString(),
+            ValorNovo = atual.StartMode.ToString(),
+            Extras =
+            {
+                ["estavaRodando"] = "true",
+                ["nome"] = "Windows Update pausado durante o jogo"
+            }
+        });
+
+        var ok = _services.Stop(servico, TimeSpan.FromSeconds(20));
+        _log.Log(ok ? LogLevel.Info : LogLevel.Warn, ModuloId, "PausarUpdate", servico,
+            ok ? "servico parado" : "nao foi possivel parar");
+
+        return ok ? record.Id : null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthReportModule.cs b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthReportModule.cs
new file mode 100644
index 0000000..201a3ef
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthReportModule.cs
@@ -0,0 +1,120 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.GameMode;
+
+namespace GameBoost.Core.Modules.HealthReport;
+
+public sealed record HealthSnapshot(
+    HealthScore Pontuacao,
+    MetricsSnapshot Metricas,
+    SystemFacts Fatos,
+    string? JogoEmExecucao,
+    DateTimeOffset Momento);
+
+/// <summary>
+/// Relatorio de saude (secao 5.12): roda todas as varreduras em modo leitura e
+/// gera nota por area com os principais findings.
+///
+/// Nao implementa IModule de proposito: nao ha nada para aplicar nem reverter,
+/// e um ApplyAsync que nao faz nada seria pior que nao existir.
+/// </summary>
+public sealed class HealthReportModule
+{
+    public const string ModuloId = "healthreport";
+
+    /// <summary>
+    /// Amostras coletadas antes de avaliar. A primeira e so linha de base dos
+    /// deltas, e as regras de duracao precisam de historico para decidir.
+    /// </summary>
+    public const int AmostrasParaRelatorio = 8;
+
+    private readonly IMetricsCollector _coletor;
+    private readonly SystemFactsReader _fatos;
+    private readonly GameDetector _detector;
+    private readonly IProcessService _processos;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    public HealthReportModule(
+        IMetricsCollector coletor,
+        SystemFactsReader fatos,
+        GameDetector detector,
+        IProcessService processos,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _coletor = coletor;
+        _fatos = fatos;
+        _detector = detector;
+        _processos = processos;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public async Task<HealthSnapshot> GerarAsync(IProgress<ModuleProgress>? progresso, CancellationToken ct)
+    {
+        progresso?.Report(new ModuleProgress("Lendo a configuracao do sistema", 5));
+        var fatos = _fatos.Ler(forcar: true);
+
+        progresso?.Report(new ModuleProgress("Medindo o uso da maquina", 15));
+
+        var buffer = new MetricsBuffer(AmostrasParaRelatorio + 2);
+
+        // A primeira coleta so estabelece a linha de base dos deltas.
+        _coletor.Coletar();
+
+        for (var i = 0; i < AmostrasParaRelatorio; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+            await Task.Delay(TimeSpan.FromSeconds(1), ct);
+
+            buffer.Adicionar(_coletor.Coletar());
+
+            var percentual = 15 + (int)(60.0 * (i + 1) / AmostrasParaRelatorio);
+            progresso?.Report(new ModuleProgress($"Medindo a maquina ({i + 1}/{AmostrasParaRelatorio})", percentual));
+        }
+
+        progresso?.Report(new ModuleProgress("Procurando gargalos", 85));
+
+        var jogo = DetectarJogo();
+        var ultimo = buffer.Ultimo
+            ?? throw new InvalidOperationException("Nenhuma metrica foi coletada.");
+
+        // Motor proprio, sem debounce herdado de uma sessao de monitoramento:
+        // o relatorio precisa refletir so o que foi medido agora.
+        var motor = new FindingEngine(_log, _relogio);
+
+        IReadOnlyList<Finding> findings = Array.Empty<Finding>();
+        foreach (var snapshot in buffer.Todos())
+        {
+            findings = motor.Avaliar(new FindingContext
+            {
+                Atual = snapshot,
+                Historico = buffer.Todos(),
+                Fatos = fatos,
+                JogoEmExecucao = jogo
+            });
+        }
+
+        progresso?.Report(new ModuleProgress("Pronto", 100));
+
+        var pontuacao = HealthScore.Calcular(findings);
+        _log.Info(ModuloId, "Gerar", null,
+            $"nota {pontuacao.NotaGeral} ({pontuacao.Conceito}), {findings.Count} findings");
+
+        return new HealthSnapshot(pontuacao, ultimo, fatos, jogo, _relogio.Now);
+    }
+
+    private string? DetectarJogo()
+    {
+        try
+        {
+            return _detector.Detectar(_processos.GetProcesses())?.Process.Name;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthScore.cs b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthScore.cs
new file mode 100644
index 0000000..cd0223f
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HealthScore.cs
@@ -0,0 +1,79 @@
+using GameBoost.Core.Modules.Bottleneck;
+
+namespace GameBoost.Core.Modules.HealthReport;
+
+public sealed record AreaScore(HealthArea Area, int Nota, IReadOnlyList<Finding> Findings)
+{
+    public string Nome => Area switch
+    {
+        HealthArea.Desempenho => "Desempenho",
+        HealthArea.Espaco => "Espaco",
+        HealthArea.Inicializacao => "Inicializacao",
+        HealthArea.ConfiguracaoParaJogos => "Configuracao para jogos",
+        _ => Area.ToString()
+    };
+
+    public string Conceito => Nota switch
+    {
+        >= 90 => "Otimo",
+        >= 75 => "Bom",
+        >= 50 => "Da para melhorar",
+        >= 25 => "Precisa de atencao",
+        _ => "Critico"
+    };
+}
+
+/// <summary>
+/// Nota 0 a 100 por area (secao 5.12).
+///
+/// A nota parte de 100 e desconta a penalidade de cada finding. Findings
+/// puramente informativos tem penalidade zero de proposito: VBS ativo e GPU no
+/// limite sao fatos, nao defeitos, e baixar a nota por eles seria pressionar o
+/// usuario a mexer no que nao deve (regra 4).
+/// </summary>
+public sealed class HealthScore
+{
+    public static HealthScore Calcular(IReadOnlyList<Finding> findings)
+    {
+        var areas = new List<AreaScore>();
+
+        foreach (var area in Enum.GetValues<HealthArea>())
+        {
+            var doGrupo = findings.Where(f => f.Area == area).ToList();
+            var desconto = doGrupo.Sum(f => f.Penalidade);
+            var nota = Math.Clamp(100 - desconto, 0, 100);
+
+            areas.Add(new AreaScore(area, nota, doGrupo
+                .OrderByDescending(f => f.Severidade)
+                .ThenByDescending(f => f.Impacto)
+                .ToList()));
+        }
+
+        return new HealthScore
+        {
+            Areas = areas,
+            Principais = findings
+                .OrderByDescending(f => f.Severidade)
+                .ThenByDescending(f => f.Impacto)
+                .Take(5)
+                .ToList()
+        };
+    }
+
+    public required IReadOnlyList<AreaScore> Areas { get; init; }
+
+    /// <summary>Os 5 principais findings, como pede a secao 5.12.</summary>
+    public required IReadOnlyList<Finding> Principais { get; init; }
+
+    /// <summary>Media das areas, arredondada.</summary>
+    public int NotaGeral => Areas.Count == 0 ? 100 : (int)Math.Round(Areas.Average(a => a.Nota));
+
+    public string Conceito => NotaGeral switch
+    {
+        >= 90 => "Otimo",
+        >= 75 => "Bom",
+        >= 50 => "Da para melhorar",
+        >= 25 => "Precisa de atencao",
+        _ => "Critico"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/HealthReport/HtmlReportWriter.cs b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HtmlReportWriter.cs
new file mode 100644
index 0000000..fe2e114
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/HealthReport/HtmlReportWriter.cs
@@ -0,0 +1,255 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.GameMode;
+
+namespace GameBoost.Core.Modules.HealthReport;
+
+/// <summary>
+/// Exporta o relatorio de saude (secao 5.12).
+///
+/// O HTML e um arquivo unico, sem link externo nenhum: o usuario manda para
+/// quem da suporte e abre em qualquer lugar. Todo texto vindo da maquina passa
+/// por escape, porque nome de processo e titulo de janela sao conteudo
+/// arbitrario e acabariam quebrando a pagina.
+/// </summary>
+public static class HtmlReportWriter
+{
+    public static string GerarHtml(HealthSnapshot relatorio)
+    {
+        var sb = new StringBuilder();
+        var p = relatorio.Pontuacao;
+
+        sb.AppendLine("<!doctype html>");
+        sb.AppendLine("<html lang=\"pt-BR\"><head><meta charset=\"utf-8\">");
+        sb.AppendLine("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");
+        sb.AppendLine("<title>GameBoost - Relatorio de saude</title>");
+        sb.AppendLine("<style>");
+        sb.AppendLine(Css);
+        sb.AppendLine("</style></head><body>");
+
+        sb.AppendLine("<header>");
+        sb.AppendLine("<h1>GameBoost</h1>");
+        sb.AppendLine($"<p class=\"sub\">Relatorio de saude gerado em {E(relatorio.Momento.ToString("dd/MM/yyyy HH:mm"))}</p>");
+        sb.AppendLine("</header>");
+
+        // Nota geral
+        sb.AppendLine("<section class=\"nota\">");
+        sb.AppendLine($"<div class=\"circulo {Classe(p.NotaGeral)}\"><span>{p.NotaGeral}</span></div>");
+        sb.AppendLine($"<div><h2>{E(p.Conceito)}</h2><p class=\"sub\">Media das quatro areas avaliadas.</p></div>");
+        sb.AppendLine("</section>");
+
+        // Areas
+        sb.AppendLine("<section><h2>Areas</h2><div class=\"areas\">");
+        foreach (var area in p.Areas)
+        {
+            sb.AppendLine("<div class=\"area\">");
+            sb.AppendLine($"<div class=\"area-nome\">{E(area.Nome)}</div>");
+            sb.AppendLine($"<div class=\"barra\"><div class=\"preenche {Classe(area.Nota)}\" style=\"width:{area.Nota}%\"></div></div>");
+            sb.AppendLine($"<div class=\"area-nota\">{area.Nota} <span class=\"sub\">{E(area.Conceito)}</span></div>");
+            sb.AppendLine("</div>");
+        }
+
+        sb.AppendLine("</div></section>");
+
+        // Findings
+        sb.AppendLine("<section><h2>O que encontramos</h2>");
+        var todos = p.Areas.SelectMany(a => a.Findings)
+            .OrderByDescending(f => f.Severidade)
+            .ThenByDescending(f => f.Impacto)
+            .ToList();
+
+        if (todos.Count == 0)
+        {
+            sb.AppendLine("<p class=\"vazio\">Nada fora do lugar. A maquina esta bem cuidada.</p>");
+        }
+        else
+        {
+            foreach (var f in todos)
+            {
+                sb.AppendLine($"<article class=\"finding {Severidade(f.Severidade)}\">");
+                sb.AppendLine($"<h3>{E(f.Titulo)}</h3>");
+                sb.AppendLine($"<p>{E(f.Detalhe)}</p>");
+                if (f.TextoDaAcao is not null)
+                    sb.AppendLine($"<p class=\"acao\">Sugestao: {E(f.TextoDaAcao)}</p>");
+                sb.AppendLine("</article>");
+            }
+        }
+
+        sb.AppendLine("</section>");
+
+        // Medicoes
+        sb.AppendLine("<section><h2>Medicoes no momento do relatorio</h2><table>");
+        var m = relatorio.Metricas;
+        Linha(sb, "CPU", $"{m.CpuPercent:0}%");
+        Linha(sb, "Memoria", $"{GameModeModule.Formatar(m.RamTotalBytes - m.RamDisponivelBytes)} de {GameModeModule.Formatar(m.RamTotalBytes)} ({m.RamUsadaPercent:0}%)");
+        Linha(sb, "Memoria livre", GameModeModule.Formatar(m.RamDisponivelBytes));
+        Linha(sb, "Standby List", m.StandbyBytes > 0 ? GameModeModule.Formatar(m.StandbyBytes) : "indisponivel");
+        Linha(sb, "GPU", m.GpuPercent.Disponivel ? $"{m.GpuPercent.Valor:0}%" : "indisponivel");
+        Linha(sb, "Disco do sistema", $"{m.DiscoSistemaUsadoPercent:0}% ocupado");
+        Linha(sb, "Rede", m.RedeBytesPorSegundo.Disponivel ? $"{GameModeModule.Formatar((long)m.RedeBytesPorSegundo.Valor)}/s" : "indisponivel");
+        Linha(sb, "Temperatura da CPU", m.TemperaturaCpu.Disponivel ? $"{m.TemperaturaCpu.Valor:0} C" : "indisponivel");
+        sb.AppendLine("</table></section>");
+
+        // Sistema
+        sb.AppendLine("<section><h2>Sistema</h2><table>");
+        var f2 = relatorio.Fatos;
+        Linha(sb, "Windows", f2.BuildDoWindows ?? "desconhecido");
+        Linha(sb, "Nucleos logicos", m.NucleosLogicos.ToString());
+        Linha(sb, "Plano de energia", f2.NomeDoPlanoDeEnergia ?? "desconhecido");
+        Linha(sb, "Placa de video", f2.FabricanteDaGpu ?? "desconhecida");
+        Linha(sb, "Driver", f2.VersaoDoDriver ?? "desconhecido");
+        Linha(sb, "Data do driver", f2.DataDoDriver?.ToString("MM/yyyy") ?? "desconhecida");
+        Linha(sb, "Monitor", f2.TaxaDeAtualizacaoAtual > 0 ? $"{f2.TaxaDeAtualizacaoAtual} Hz (maximo {f2.TaxaDeAtualizacaoMaxima} Hz)" : "desconhecido");
+        Linha(sb, "Isolamento do nucleo (VBS)", f2.VbsAtivo ? "ativo" : "desligado");
+        Linha(sb, "Programas na inicializacao", f2.ItensNaInicializacao.ToString());
+        Linha(sb, "Pentes de memoria", f2.PentesDeMemoria > 0 ? f2.PentesDeMemoria.ToString() : "desconhecido");
+        Linha(sb, "Jogo em execucao", relatorio.JogoEmExecucao ?? "nenhum detectado");
+        sb.AppendLine("</table></section>");
+
+        // Processos
+        sb.AppendLine("<section><h2>Processos que mais consomem</h2><table>");
+        sb.AppendLine("<tr><th>Processo</th><th>CPU</th><th>Memoria</th></tr>");
+        foreach (var proc in m.Processos.Take(10))
+        {
+            sb.AppendLine("<tr>");
+            sb.AppendLine($"<td>{E(proc.NomeExibido)}</td>");
+            sb.AppendLine($"<td>{proc.CpuPercent:0.0}%</td>");
+            sb.AppendLine($"<td>{E(GameModeModule.Formatar(proc.WorkingSetBytes))}</td>");
+            sb.AppendLine("</tr>");
+        }
+
+        sb.AppendLine("</table></section>");
+
+        sb.AppendLine("<footer><p>Gerado pelo GameBoost. Nenhum dado saiu desta maquina: "
+                    + "este arquivo foi escrito localmente e so vai para onde voce mandar.</p></footer>");
+        sb.AppendLine("</body></html>");
+
+        return sb.ToString();
+    }
+
+    public static string GerarJson(HealthSnapshot relatorio)
+    {
+        var m = relatorio.Metricas;
+
+        return JsonSerializer.Serialize(new
+        {
+            gerado = relatorio.Momento,
+            notaGeral = relatorio.Pontuacao.NotaGeral,
+            conceito = relatorio.Pontuacao.Conceito,
+            areas = relatorio.Pontuacao.Areas.Select(a => new { area = a.Nome, nota = a.Nota, conceito = a.Conceito }),
+            findings = relatorio.Pontuacao.Areas.SelectMany(a => a.Findings).Select(f => new
+            {
+                f.RegraId,
+                f.Titulo,
+                f.Detalhe,
+                severidade = f.Severidade.ToString(),
+                area = f.Area.ToString(),
+                f.Impacto,
+                f.Penalidade,
+                acao = f.TextoDaAcao
+            }),
+            metricas = new
+            {
+                cpuPercent = Math.Round(m.CpuPercent, 1),
+                ramTotalBytes = m.RamTotalBytes,
+                ramDisponivelBytes = m.RamDisponivelBytes,
+                standbyBytes = m.StandbyBytes,
+                gpuPercent = m.GpuPercent.Disponivel ? Math.Round(m.GpuPercent.Valor, 1) : (double?)null,
+                discoSistemaUsadoPercent = Math.Round(m.DiscoSistemaUsadoPercent, 1),
+                redeBytesPorSegundo = m.RedeBytesPorSegundo.Disponivel ? Math.Round(m.RedeBytesPorSegundo.Valor) : (double?)null,
+                temperaturaCpu = m.TemperaturaCpu.Disponivel ? Math.Round(m.TemperaturaCpu.Valor, 1) : (double?)null,
+                nucleosLogicos = m.NucleosLogicos
+            },
+            sistema = new
+            {
+                relatorio.Fatos.BuildDoWindows,
+                relatorio.Fatos.NomeDoPlanoDeEnergia,
+                relatorio.Fatos.FabricanteDaGpu,
+                relatorio.Fatos.VersaoDoDriver,
+                relatorio.Fatos.DataDoDriver,
+                relatorio.Fatos.TaxaDeAtualizacaoAtual,
+                relatorio.Fatos.TaxaDeAtualizacaoMaxima,
+                relatorio.Fatos.VbsAtivo,
+                relatorio.Fatos.ItensNaInicializacao,
+                relatorio.Fatos.PentesDeMemoria
+            },
+            jogoEmExecucao = relatorio.JogoEmExecucao,
+            processos = m.Processos.Take(10).Select(p => new
+            {
+                p.Nome,
+                cpuPercent = Math.Round(p.CpuPercent, 1),
+                p.WorkingSetBytes,
+                p.Instancias
+            })
+        }, new JsonSerializerOptions { WriteIndented = true });
+    }
+
+    private static void Linha(StringBuilder sb, string rotulo, string valor)
+        => sb.AppendLine($"<tr><td>{E(rotulo)}</td><td>{E(valor)}</td></tr>");
+
+    /// <summary>Nome de processo e titulo de janela sao conteudo arbitrario.</summary>
+    private static string E(string? texto) => WebUtility.HtmlEncode(texto ?? string.Empty);
+
+    private static string Classe(int nota) => nota switch
+    {
+        >= 75 => "bom",
+        >= 50 => "medio",
+        _ => "ruim"
+    };
+
+    private static string Severidade(FindingSeverity s) => s switch
+    {
+        FindingSeverity.Critico => "critico",
+        FindingSeverity.Atencao => "atencao",
+        _ => "info"
+    };
+
+    private const string Css = """
+        :root { color-scheme: dark; }
+        * { box-sizing: border-box; }
+        body { margin: 0; padding: 32px 20px; background: #14161a; color: #edeff2;
+               font: 15px/1.55 "Segoe UI", system-ui, sans-serif; }
+        header, section, footer { max-width: 860px; margin: 0 auto 28px; }
+        h1 { font-size: 26px; margin: 0; }
+        h2 { font-size: 18px; margin: 0 0 14px; }
+        h3 { font-size: 15px; margin: 0 0 6px; }
+        p { margin: 0 0 8px; }
+        .sub { color: #9aa3b0; font-size: 13px; }
+        .nota { display: flex; align-items: center; gap: 20px; background: #1c1f26;
+                border: 1px solid #2e333d; border-radius: 10px; padding: 20px; }
+        .circulo { width: 78px; height: 78px; border-radius: 50%; display: grid; place-items: center;
+                   font-size: 26px; font-weight: 700; flex: none; border: 3px solid; }
+        .circulo.bom { border-color: #3fb950; color: #3fb950; }
+        .circulo.medio { border-color: #d29922; color: #d29922; }
+        .circulo.ruim { border-color: #f85149; color: #f85149; }
+        .areas { display: grid; gap: 12px; }
+        .area { display: grid; grid-template-columns: 190px 1fr 130px; gap: 14px; align-items: center; }
+        .barra { background: #1c1f26; border-radius: 5px; height: 10px; overflow: hidden; }
+        .preenche { height: 100%; }
+        .preenche.bom { background: #3fb950; }
+        .preenche.medio { background: #d29922; }
+        .preenche.ruim { background: #f85149; }
+        .area-nota { font-weight: 600; }
+        .finding { background: #1c1f26; border: 1px solid #2e333d; border-left-width: 3px;
+                   border-radius: 8px; padding: 14px 16px; margin-bottom: 10px; }
+        .finding.critico { border-left-color: #f85149; }
+        .finding.atencao { border-left-color: #d29922; }
+        .finding.info { border-left-color: #00c2a8; }
+        .finding p { color: #9aa3b0; font-size: 14px; }
+        .acao { color: #00c2a8 !important; }
+        .vazio { color: #3fb950; }
+        table { width: 100%; border-collapse: collapse; background: #1c1f26;
+                border: 1px solid #2e333d; border-radius: 8px; overflow: hidden; }
+        td, th { padding: 9px 14px; border-bottom: 1px solid #2e333d; text-align: left; font-size: 14px; }
+        th { color: #9aa3b0; font-weight: 600; }
+        tr:last-child td { border-bottom: 0; }
+        td:first-child { color: #9aa3b0; }
+        footer p { color: #5e6672; font-size: 12px; }
+        @media (max-width: 640px) {
+          .area { grid-template-columns: 1fr; gap: 4px; }
+          .nota { flex-direction: column; text-align: center; }
+        }
+        """;
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/IModule.cs b/GameBoost/src/GameBoost.Core/Modules/IModule.cs
new file mode 100644
index 0000000..e26e6c6
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/IModule.cs
@@ -0,0 +1,43 @@
+namespace GameBoost.Core.Modules;
+
+/// <summary>Etapa de progresso de uma varredura longa (regra 10: nunca travar a UI).</summary>
+public sealed record ModuleProgress(string Etapa, int Percentual);
+
+public sealed class ScanResult
+{
+    public required string ModuloId { get; init; }
+    public IReadOnlyList<ActionItem> Itens { get; init; } = Array.Empty<ActionItem>();
+    public string Resumo { get; init; } = string.Empty;
+    public DateTimeOffset Momento { get; init; }
+    public IReadOnlyList<string> Avisos { get; init; } = Array.Empty<string>();
+}
+
+public sealed record AppliedAction(string ItemId, bool Sucesso, string Detalhe, string? ChangeRecordId);
+
+public sealed class ApplyResult
+{
+    public required string ModuloId { get; init; }
+    public IReadOnlyList<AppliedAction> Acoes { get; init; } = Array.Empty<AppliedAction>();
+    public string Resumo { get; init; } = string.Empty;
+
+    /// <summary>Ganho realmente medido depois da acao. Nunca estimado (regra 4).</summary>
+    public string GanhoMedido { get; init; } = string.Empty;
+
+    public bool DryRun { get; init; }
+    public int Sucessos => Acoes.Count(a => a.Sucesso);
+    public int Falhas => Acoes.Count(a => !a.Sucesso);
+}
+
+/// <summary>Contrato unico de todo modulo do GameBoost (secao 4.2 do spec).</summary>
+public interface IModule
+{
+    string Id { get; }
+    string Nome { get; }
+    string Descricao { get; }
+
+    Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct);
+
+    Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct);
+
+    Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Network/NatDiagnostics.cs b/GameBoost/src/GameBoost.Core/Modules/Network/NatDiagnostics.cs
new file mode 100644
index 0000000..2875450
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Network/NatDiagnostics.cs
@@ -0,0 +1,435 @@
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Modules.Network;
+
+/// <summary>
+/// Tipo de NAT no vocabulário que o jogador já conhece.
+///
+/// Xbox, Call of Duty e Discord dizem Aberto, Moderado e Estrito, e é isso que o
+/// usuário vê na tela do jogo quando vem procurar ajuda. Inventar nomes próprios
+/// ("cone restrito", "simétrico") forçaria ele a traduzir sozinho a informação
+/// que veio buscar aqui.
+///
+/// CGNAT e NAT duplo não são tipos de NAT: são **causas** que produzem um NAT
+/// estrito. Estão no mesmo enum porque a tela precisa de uma resposta só, e
+/// porque a correção de cada um é completamente diferente — dizer "estrito"
+/// para quem está atrás de CGNAT o faria passar a tarde mexendo no roteador à
+/// toa.
+/// </summary>
+public enum TipoDeNat
+{
+    NaoDetectado,
+
+    /// <summary>Endereço público direto na máquina. O melhor caso possível.</summary>
+    SemNat,
+
+    /// <summary>Mapeamento estável e recebe de qualquer origem. "Open" nos jogos.</summary>
+    Aberto,
+
+    /// <summary>Mapeamento estável, mas só recebe de quem já falou. "Moderate".</summary>
+    Moderado,
+
+    /// <summary>O mapeamento muda por destino. "Strict": é o que trava lobby e voz.</summary>
+    Estrito,
+
+    /// <summary>O provedor compartilha um IP público entre vários assinantes.</summary>
+    Cgnat,
+
+    /// <summary>Dois roteadores em série fazendo NAT.</summary>
+    Duplo
+}
+
+public enum EstadoTeredo
+{
+    Desconhecido,
+    Desativado,
+    Qualificado,
+    NaoQualificado
+}
+
+/// <summary>Resultado completo do diagnóstico de conectividade.</summary>
+public sealed record DiagnosticoDeNat
+{
+    public required TipoDeNat Tipo { get; init; }
+    public IPAddress? EnderecoPublico { get; init; }
+    public IPAddress? EnderecoLocal { get; init; }
+
+    /// <summary>Quantos saltos privados existem antes do primeiro público.</summary>
+    public int SaltosPrivados { get; init; }
+
+    public bool PortaEstavel { get; init; }
+    public EstadoTeredo Teredo { get; init; }
+    public bool UpnpDisponivel { get; init; }
+    public string? ModeloDoRoteador { get; init; }
+    public IReadOnlyList<string> PerfisDeFirewallAtivos { get; init; } = Array.Empty<string>();
+
+    /// <summary>O que isso significa para quem joga, em português.</summary>
+    public string Explicacao => Tipo switch
+    {
+        TipoDeNat.SemNat =>
+            "Sua máquina tem endereço público direto. É o melhor caso: qualquer jogo consegue "
+          + "hospedar partida e receber conexão.",
+
+        TipoDeNat.Aberto =>
+            "NAT aberto. A porta que o jogo abre sai com o mesmo número para todos os destinos, "
+          + "que é o que os jogos chamam de NAT tipo 1 ou 2. Chat de voz e partida hospedada "
+          + "funcionam.",
+
+        TipoDeNat.Moderado =>
+            "NAT moderado. Seu roteador mantém a mesma porta para todo mundo, mas só aceita "
+          + "resposta de quem você contatou primeiro. Dá para jogar e entrar em partida; o que "
+          + "costuma falhar é hospedar e entrar em festa de quem também está em NAT moderado ou "
+          + "estrito. Ligar UPnP no roteador resolve a maior parte dos casos.",
+
+        TipoDeNat.Estrito =>
+            "NAT estrito. Seu roteador dá uma porta diferente para cada destino, e por isso "
+          + "outro jogador não consegue te alcançar de volta. É o tipo 3 dos jogos: lobby demora, "
+          + "chat de voz falha e partida hospedada não abre. Duas pessoas em NAT estrito não "
+          + "conseguem se conectar de jeito nenhum. Costuma ser resolvido ligando UPnP no "
+          + "roteador ou abrindo as portas do jogo à mão.",
+
+        TipoDeNat.Cgnat =>
+            "CGNAT: sua operadora divide um mesmo endereço público entre vários assinantes. "
+          + "Nenhum ajuste no seu roteador resolve isso, porque o NAT que atrapalha está na "
+          + "operadora, não na sua casa. As saídas são pedir IP público à operadora (às vezes "
+          + "gratuito, às vezes pago) ou usar IPv6, quando o jogo suporta.",
+
+        TipoDeNat.Duplo =>
+            "NAT duplo: há dois roteadores em série fazendo tradução, normalmente o modem da "
+          + "operadora mais um roteador seu. Abrir porta só no roteador de dentro não resolve, "
+          + "porque o de fora continua barrando. A correção é pôr o modem da operadora em modo "
+          + "bridge, ou apontar a DMZ dele para o seu roteador.",
+
+        _ => "Não foi possível determinar o tipo de NAT. Pode ser firewall bloqueando UDP de saída."
+    };
+
+    /// <summary>
+    /// Cor do semáforo grande da tela: verde joga, amarelo joga com atrito,
+    /// vermelho não entra em partida.
+    /// </summary>
+    public string Semaforo => Tipo switch
+    {
+        TipoDeNat.SemNat or TipoDeNat.Aberto => "verde",
+        TipoDeNat.Moderado => "amarelo",
+        TipoDeNat.Estrito or TipoDeNat.Cgnat or TipoDeNat.Duplo => "vermelho",
+        _ => "cinza"
+    };
+
+    /// <summary>Nome curto, do jeito que console e jogo usam.</summary>
+    public string NomeCurto => Tipo switch
+    {
+        TipoDeNat.SemNat => "aberto (IP público direto)",
+        TipoDeNat.Aberto => "aberto",
+        TipoDeNat.Moderado => "moderado",
+        TipoDeNat.Estrito => "estrito",
+        TipoDeNat.Cgnat => "CGNAT da operadora",
+        TipoDeNat.Duplo => "NAT duplo",
+        _ => "não detectado"
+    };
+}
+
+/// <summary>
+/// Detecção de NAT e conectividade (seção 5.9).
+///
+/// Esta é a parte da tela de Rede que resolve uma reclamação concreta: "meu
+/// jogo diz NAT estrito e eu não sei o que fazer". O valor não está em mudar
+/// nada — está em dizer, em dez segundos, **onde** está o problema, porque a
+/// correção é diferente para cada causa e o usuário normalmente mexe no lugar
+/// errado.
+///
+/// Nada aqui altera configuração. As correções que existem estão no
+/// <see cref="NetworkModule"/> e passam por ChangeRecord.
+/// </summary>
+public sealed class NatDiagnostics
+{
+    /// <summary>Faixa 100.64.0.0/10, reservada justamente para CGNAT (RFC 6598).</summary>
+    private static bool EhCgnat(IPAddress endereco)
+    {
+        var b = endereco.GetAddressBytes();
+        return b.Length == 4 && b[0] == 100 && b[1] >= 64 && b[1] <= 127;
+    }
+
+    private static bool EhPrivado(IPAddress endereco)
+    {
+        var b = endereco.GetAddressBytes();
+
+        if (b.Length != 4)
+            return false;
+
+        return b[0] == 10
+            || (b[0] == 172 && b[1] >= 16 && b[1] <= 31)
+            || (b[0] == 192 && b[1] == 168)
+            || (b[0] == 169 && b[1] == 254)
+            || EhCgnat(endereco);
+    }
+
+    private readonly IRegistryService _registro;
+    private readonly IGameBoostLogger _log;
+
+    public NatDiagnostics(IRegistryService registro, IGameBoostLogger log)
+    {
+        _registro = registro;
+        _log = log;
+    }
+
+    public async Task<DiagnosticoDeNat> DiagnosticarAsync(CancellationToken ct)
+    {
+        // Quatro consultas: dois servidores por duas portas locais.
+        //
+        // As duas primeiras, da MESMA porta local para servidores diferentes,
+        // respondem se o mapeamento é estável — se a porta pública muda com o
+        // destino, o NAT é estrito e acabou a conversa.
+        //
+        // A terceira e a quarta, de OUTRA porta local, respondem se o roteador
+        // preserva o número da porta. Um NAT que devolve a mesma porta de origem
+        // costuma ser o de cone cheio; um que renumera, mas mantém o mapeamento
+        // por destino, é o moderado.
+        var portaA = PortaLivre();
+        var portaB = PortaLivre();
+
+        var a1 = await StunClient.ConsultarAsync(
+            StunClient.Servidores[0].Host, StunClient.Servidores[0].Porta, portaA, ct);
+
+        RespostaStun? a2 = null;
+        RespostaStun? b1 = null;
+
+        if (a1 is not null)
+        {
+            a2 = await StunClient.ConsultarAsync(
+                StunClient.Servidores[1].Host, StunClient.Servidores[1].Porta, portaA, ct);
+
+            b1 = await StunClient.ConsultarAsync(
+                StunClient.Servidores[0].Host, StunClient.Servidores[0].Porta, portaB, ct);
+        }
+
+        var saltos = await ContarSaltosPrivadosAsync(ct);
+        var local = EnderecoLocal();
+
+        var estavel = a1 is not null && a2 is not null && a1.PortaPublica == a2.PortaPublica;
+        var preservaPorta = a1 is not null && b1 is not null
+                            && a1.PortaPublica == portaA && b1.PortaPublica == portaB;
+
+        var tipo = Classificar(a1, estavel, preservaPorta, saltos, local);
+        var primeira = a1;
+
+        return new DiagnosticoDeNat
+        {
+            Tipo = tipo,
+            EnderecoPublico = primeira?.EnderecoPublico,
+            EnderecoLocal = local,
+            SaltosPrivados = saltos,
+            PortaEstavel = estavel,
+            Teredo = LerTeredo(),
+            UpnpDisponivel = await UpnpDisponivelAsync(ct),
+            PerfisDeFirewallAtivos = LerFirewall()
+        };
+    }
+
+    /// <summary>
+    /// A classificação completa da RFC 5780 exigiria o atributo CHANGE-REQUEST,
+    /// que faz o servidor responder de outro IP e de outra porta. Quase nenhum
+    /// servidor STUN público ainda atende a isso — os da Google e da Cloudflare
+    /// não atendem. Sem ele não dá para separar cone cheio de cone restrito com
+    /// certeza.
+    ///
+    /// O que dá para afirmar com duas portas locais e dois servidores é o que
+    /// importa na prática, e é o que está aqui: se o mapeamento muda por
+    /// destino (estrito) e se o roteador preserva o número da porta de origem
+    /// (sinal forte de cone cheio, o "aberto" dos jogos). O caso do meio vira
+    /// moderado, que é a resposta correta na dúvida — errar para moderado faz o
+    /// usuário ligar UPnP à toa; errar para aberto o faria parar de procurar o
+    /// problema que ele tem.
+    /// </summary>
+    private static TipoDeNat Classificar(
+        RespostaStun? primeira, bool mapeamentoEstavel, bool preservaPorta,
+        int saltosPrivados, IPAddress? local)
+    {
+        if (primeira is null)
+            return TipoDeNat.NaoDetectado;
+
+        // CGNAT ganha de tudo: se o endereço "público" está na faixa reservada
+        // para operadora, nada que o usuário faça em casa muda o resultado, e
+        // dizer "abra a porta no roteador" seria mandá-lo perder a tarde.
+        if (EhCgnat(primeira.EnderecoPublico))
+            return TipoDeNat.Cgnat;
+
+        if (local is not null && primeira.EnderecoPublico.Equals(local))
+            return TipoDeNat.SemNat;
+
+        // Dois ou mais saltos privados antes do primeiro público: há um
+        // roteador atrás do outro.
+        if (saltosPrivados >= 2)
+            return TipoDeNat.Duplo;
+
+        if (!mapeamentoEstavel)
+            return TipoDeNat.Estrito;
+
+        return preservaPorta ? TipoDeNat.Aberto : TipoDeNat.Moderado;
+    }
+
+    private static int PortaLivre()
+    {
+        using var socket = new UdpClient(0);
+        return ((IPEndPoint)socket.Client.LocalEndPoint!).Port;
+    }
+
+    private static IPAddress? EnderecoLocal()
+        => NetworkInterface.GetAllNetworkInterfaces()
+            .Where(n => n.OperationalStatus == OperationalStatus.Up
+                     && n.GetIPProperties().GatewayAddresses.Count > 0)
+            .SelectMany(n => n.GetIPProperties().UnicastAddresses)
+            .Select(u => u.Address)
+            .FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork);
+
+    /// <summary>
+    /// Conta quantos saltos com endereço privado existem antes do primeiro
+    /// público, usando ping com TTL crescente.
+    ///
+    /// Para no quinto salto: NAT duplo, quando existe, aparece nos dois
+    /// primeiros. Ir mais longe só gastaria segundos que o usuário está
+    /// esperando na tela.
+    /// </summary>
+    private async Task<int> ContarSaltosPrivadosAsync(CancellationToken ct)
+    {
+        var privados = 0;
+
+        try
+        {
+            using var ping = new Ping();
+
+            for (var ttl = 1; ttl <= 5; ttl++)
+            {
+                ct.ThrowIfCancellationRequested();
+
+                var opcoes = new PingOptions(ttl, true);
+                var resposta = await ping.SendPingAsync("1.1.1.1", 1200, new byte[32], opcoes);
+
+                if (resposta.Address is null || resposta.Address.Equals(IPAddress.Any))
+                    continue;
+
+                if (EhPrivado(resposta.Address))
+                {
+                    privados++;
+                    continue;
+                }
+
+                // Primeiro salto público: daqui para frente é a internet.
+                break;
+            }
+        }
+        catch (Exception ex) when (ex is PingException or SocketException or NotSupportedException)
+        {
+            _log.Warn("network", "Saltos", null, ex.Message);
+        }
+
+        return privados;
+    }
+
+    /// <summary>
+    /// Estado do Teredo, lido do registro.
+    ///
+    /// Teredo é o túnel de IPv6 sobre IPv4 que o multiplayer de Xbox e Game
+    /// Pass no PC usa para achar outros jogadores. Metade dos guias de
+    /// "otimização de rede" da internet manda desativar, e é justamente isso
+    /// que quebra o multiplayer de quem joga Game Pass.
+    /// </summary>
+    internal EstadoTeredo LerTeredo()
+    {
+        const string chave = @"SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters";
+
+        // DisabledComponents com o bit 0x01 ligado desativa todos os túneis,
+        // inclusive o Teredo.
+        if (_registro.GetValue(RegistryRoot.LocalMachine, chave, "DisabledComponents") is int componentes
+            && (componentes & 0x01) != 0)
+        {
+            return EstadoTeredo.Desativado;
+        }
+
+        var tipo = _registro.GetValue(RegistryRoot.LocalMachine,
+            @"SYSTEM\CurrentControlSet\Services\iphlpsvc\Teredo", "Type");
+
+        // 0 e 1 são "disabled"; ausente significa o padrão do Windows, que é
+        // cliente quando há necessidade.
+        return tipo switch
+        {
+            int t and (0 or 1) => EstadoTeredo.Desativado,
+            null => EstadoTeredo.Qualificado,
+            _ => EstadoTeredo.Qualificado
+        };
+    }
+
+    /// <summary>
+    /// Procura um roteador que fale UPnP, por SSDP multicast.
+    ///
+    /// Só descoberta: o GameBoost não cria mapeamento de porta. Abrir porta no
+    /// roteador por conta própria seria mexer em equipamento que não é dele,
+    /// sem ter como desfazer se a máquina sumir da rede.
+    /// </summary>
+    internal async Task<bool> UpnpDisponivelAsync(CancellationToken ct)
+    {
+        const string busca =
+            "M-SEARCH * HTTP/1.1\r\n" +
+            "HOST: 239.255.255.250:1900\r\n" +
+            "MAN: \"ssdp:discover\"\r\n" +
+            "MX: 2\r\n" +
+            "ST: urn:schemas-upnp-org:device:InternetGatewayDevice:1\r\n\r\n";
+
+        try
+        {
+            using var socket = new UdpClient(0);
+            var dados = System.Text.Encoding.ASCII.GetBytes(busca);
+            var destino = new IPEndPoint(IPAddress.Parse("239.255.255.250"), 1900);
+
+            await socket.SendAsync(dados, dados.Length, destino);
+
+            using var limite = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            limite.CancelAfter(TimeSpan.FromSeconds(3));
+
+            var resposta = await socket.ReceiveAsync(limite.Token);
+            var texto = System.Text.Encoding.ASCII.GetString(resposta.Buffer);
+
+            return texto.Contains("InternetGatewayDevice", StringComparison.OrdinalIgnoreCase);
+        }
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Perfis de firewall ligados, lidos do registro.
+    ///
+    /// Isto é informativo: o firewall ligado é o certo, e um bloqueio de jogo
+    /// específico é regra, não perfil. O GameBoost não desliga firewall — essa
+    /// é a "otimização" que mais aparece em tutorial de YouTube e a que mais
+    /// custa caro.
+    /// </summary>
+    internal IReadOnlyList<string> LerFirewall()
+    {
+        const string raiz = @"SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy";
+
+        var perfis = new (string Chave, string Nome)[]
+        {
+            ("DomainProfile", "Domínio"),
+            ("StandardProfile", "Rede privada"),
+            ("PublicProfile", "Rede pública")
+        };
+
+        var ativos = new List<string>();
+
+        foreach (var (chave, nome) in perfis)
+        {
+            var valor = _registro.GetValue(RegistryRoot.LocalMachine, $@"{raiz}\{chave}", "EnableFirewall");
+
+            // Ausente significa ligado: é o padrão do Windows.
+            if (valor is null or int and not 0)
+                ativos.Add(nome);
+        }
+
+        return ativos;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Network/NetworkDiagnostics.cs b/GameBoost/src/GameBoost.Core/Modules/Network/NetworkDiagnostics.cs
new file mode 100644
index 0000000..ce4d3d8
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Network/NetworkDiagnostics.cs
@@ -0,0 +1,354 @@
+using System.Diagnostics;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Modules.Network;
+
+/// <summary>
+/// Resultado de uma medição de latência. <see cref="Respondeu"/> falso não
+/// significa rede ruim: muito host ignora ICMP de propósito.
+/// </summary>
+public sealed record MedicaoPing(
+    string Rotulo,
+    string Alvo,
+    bool Respondeu,
+    double MediaMs,
+    double JitterMs,
+    double PiorMs,
+    int PerdaPercentual,
+    string? Erro)
+{
+    /// <summary>
+    /// Semáforo da seção 5.9.3: abaixo de 30 ms verde, até 80 amarelo, acima
+    /// vermelho.
+    /// </summary>
+    public string Semaforo => !Respondeu
+        ? "cinza"
+        : MediaMs switch
+        {
+            < 30 => "verde",
+            <= 80 => "amarelo",
+            _ => "vermelho"
+        };
+
+    /// <summary>Texto do que o número significa para quem joga.</summary>
+    public string Leitura => !Respondeu
+        ? "sem resposta"
+        : MediaMs switch
+        {
+            < 30 => "ótimo",
+            <= 80 => "aceitável",
+            _ => "alto para jogo competitivo"
+        };
+
+    /// <summary>Jitter acima de 15 ms ou perda acima de 1% viram Finding (5.9.1).</summary>
+    public bool EhProblema => Respondeu && (JitterMs > 15 || PerdaPercentual > 1);
+}
+
+/// <summary>Tempo de resposta de um resolvedor de DNS.</summary>
+public sealed record MedicaoDns(string Nome, string Endereco, bool Respondeu, double MediaMs, bool EmUso);
+
+/// <summary>Estado do Wi-Fi, quando a conexão é sem fio.</summary>
+public sealed record EstadoWifi(string Ssid, int SinalPercentual, string Banda, int Canal, string Padrao);
+
+/// <summary>
+/// Diagnóstico de rede da seção 5.9.
+///
+/// Tudo aqui é leitura: nada nesta classe altera configuração. As ações ficam
+/// no <see cref="NetworkModule"/>, onde passam pelo ChangeRecord.
+/// </summary>
+public sealed class NetworkDiagnostics
+{
+    /// <summary>
+    /// Quantos pacotes por alvo. Cinco é o suficiente para ter jitter com
+    /// algum significado e ainda terminar rápido; um único ping não diz nada
+    /// sobre estabilidade, que é o que importa em jogo.
+    /// </summary>
+    private const int Pacotes = 5;
+
+    private const int TimeoutMs = 1500;
+
+    /// <summary>Resolvedores públicos comparados com o que está em uso.</summary>
+    public static readonly (string Nome, string Endereco)[] ResolvedoresPublicos =
+    {
+        ("Cloudflare", "1.1.1.1"),
+        ("Google", "8.8.8.8"),
+        ("Quad9", "9.9.9.9")
+    };
+
+    private readonly IGameBoostLogger _log;
+
+    public NetworkDiagnostics(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    // ==================================================================
+    // Latência
+    // ==================================================================
+
+    public async Task<IReadOnlyList<MedicaoPing>> MedirLatenciaAsync(CancellationToken ct)
+    {
+        var alvos = new List<(string Rotulo, string Alvo)>();
+
+        var gateway = Gateway();
+        if (gateway is not null)
+            alvos.Add(("Seu roteador", gateway));
+
+        alvos.Add(("Internet (Cloudflare)", "1.1.1.1"));
+        alvos.Add(("Internet (Google)", "8.8.8.8"));
+
+        var resultados = new List<MedicaoPing>(alvos.Count);
+
+        foreach (var (rotulo, alvo) in alvos)
+        {
+            ct.ThrowIfCancellationRequested();
+            resultados.Add(await MedirUmAsync(rotulo, alvo, ct));
+        }
+
+        return resultados;
+    }
+
+    private async Task<MedicaoPing> MedirUmAsync(string rotulo, string alvo, CancellationToken ct)
+    {
+        var tempos = new List<double>(Pacotes);
+        var perdidos = 0;
+        string? erro = null;
+
+        using var ping = new Ping();
+
+        for (var i = 0; i < Pacotes; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            try
+            {
+                var resposta = await ping.SendPingAsync(alvo, TimeoutMs);
+
+                if (resposta.Status == IPStatus.Success)
+                    tempos.Add(resposta.RoundtripTime);
+                else
+                    perdidos++;
+            }
+            catch (Exception ex) when (ex is PingException or SocketException)
+            {
+                perdidos++;
+                erro = ex.Message;
+            }
+        }
+
+        if (tempos.Count == 0)
+            return new MedicaoPing(rotulo, alvo, false, 0, 0, 0, 100, erro);
+
+        var media = tempos.Average();
+
+        // Jitter é a variação entre pacotes consecutivos, não o desvio padrão:
+        // é a medida que corresponde ao que o jogador sente como "travadinha".
+        var jitter = tempos.Count > 1
+            ? Enumerable.Range(1, tempos.Count - 1)
+                        .Select(i => Math.Abs(tempos[i] - tempos[i - 1]))
+                        .Average()
+            : 0;
+
+        return new MedicaoPing(
+            rotulo, alvo, true,
+            Math.Round(media, 1),
+            Math.Round(jitter, 1),
+            tempos.Max(),
+            perdidos * 100 / Pacotes,
+            erro);
+    }
+
+    public static string? Gateway()
+        => NetworkInterface.GetAllNetworkInterfaces()
+            .Where(n => n.OperationalStatus == OperationalStatus.Up)
+            .SelectMany(n => n.GetIPProperties().GatewayAddresses)
+            .Select(g => g.Address)
+            .FirstOrDefault(a => a is not null
+                              && a.AddressFamily == AddressFamily.InterNetwork
+                              && !a.Equals(IPAddress.Any))
+            ?.ToString();
+
+    // ==================================================================
+    // DNS
+    // ==================================================================
+
+    /// <summary>
+    /// Compara o tempo de resolução do DNS em uso com os três públicos.
+    ///
+    /// A comparação usa consulta UDP direta a cada servidor, montada à mão.
+    /// `Dns.GetHostEntry` não serviria: ele pergunta ao resolvedor do sistema,
+    /// então mediria sempre o mesmo servidor com três nomes diferentes.
+    /// </summary>
+    public async Task<IReadOnlyList<MedicaoDns>> CompararDnsAsync(CancellationToken ct)
+    {
+        var emUso = DnsEmUso();
+        var resultados = new List<MedicaoDns>();
+
+        foreach (var endereco in emUso.Take(1))
+        {
+            ct.ThrowIfCancellationRequested();
+            var ms = await MedirDnsAsync(endereco, ct);
+            resultados.Add(new MedicaoDns("Em uso agora", endereco, ms >= 0, ms, true));
+        }
+
+        foreach (var (nome, endereco) in ResolvedoresPublicos)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            // Não repetir na tabela o que já está em uso.
+            if (emUso.Contains(endereco, StringComparer.Ordinal))
+                continue;
+
+            var ms = await MedirDnsAsync(endereco, ct);
+            resultados.Add(new MedicaoDns(nome, endereco, ms >= 0, ms, false));
+        }
+
+        return resultados;
+    }
+
+    public static IReadOnlyList<string> DnsEmUso()
+        => NetworkInterface.GetAllNetworkInterfaces()
+            .Where(n => n.OperationalStatus == OperationalStatus.Up
+                     && n.NetworkInterfaceType != NetworkInterfaceType.Loopback)
+            .SelectMany(n => n.GetIPProperties().DnsAddresses)
+            .Where(a => a.AddressFamily == AddressFamily.InterNetwork)
+            .Select(a => a.ToString())
+            .Distinct(StringComparer.Ordinal)
+            .ToList();
+
+    /// <summary>Média de três consultas. Devolve -1 quando o servidor não responde.</summary>
+    private async Task<double> MedirDnsAsync(string servidor, CancellationToken ct)
+    {
+        // Nomes diferentes a cada rodada evitam medir o cache do servidor em
+        // vez do servidor.
+        string[] nomes = { "example.com", "wikipedia.org", "github.com" };
+        var tempos = new List<double>(nomes.Length);
+
+        foreach (var nome in nomes)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var ms = await ConsultarAsync(servidor, nome, ct);
+            if (ms >= 0)
+                tempos.Add(ms);
+        }
+
+        return tempos.Count == 0 ? -1 : Math.Round(tempos.Average(), 1);
+    }
+
+    /// <summary>
+    /// Uma consulta A por UDP, montada na mão. O pacote de pergunta do DNS é
+    /// pequeno o bastante para não valer uma dependência.
+    /// </summary>
+    private async Task<double> ConsultarAsync(string servidor, string nome, CancellationToken ct)
+    {
+        try
+        {
+            using var cliente = new UdpClient();
+            cliente.Client.ReceiveTimeout = TimeoutMs;
+
+            var pergunta = MontarConsulta(nome);
+            var destino = new IPEndPoint(IPAddress.Parse(servidor), 53);
+
+            var relogio = Stopwatch.StartNew();
+
+            await cliente.SendAsync(pergunta, pergunta.Length, destino);
+
+            using var limite = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            limite.CancelAfter(TimeoutMs);
+
+            var resposta = await cliente.ReceiveAsync(limite.Token);
+            relogio.Stop();
+
+            // Confere se a resposta é da pergunta que fizemos: os dois primeiros
+            // bytes são o id da transação.
+            if (resposta.Buffer.Length < 2
+                || resposta.Buffer[0] != pergunta[0]
+                || resposta.Buffer[1] != pergunta[1])
+            {
+                return -1;
+            }
+
+            return relogio.Elapsed.TotalMilliseconds;
+        }
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException or FormatException)
+        {
+            return -1;
+        }
+    }
+
+    private static byte[] MontarConsulta(string nome)
+    {
+        var partes = nome.Split('.');
+        var tamanho = 12 + partes.Sum(p => p.Length + 1) + 1 + 4;
+        var pacote = new byte[tamanho];
+
+        // Id aleatório, para casar pergunta e resposta.
+        var id = Random.Shared.Next(1, ushort.MaxValue);
+        pacote[0] = (byte)(id >> 8);
+        pacote[1] = (byte)(id & 0xFF);
+
+        // Flags: consulta padrão, recursão desejada.
+        pacote[2] = 0x01;
+
+        // Uma pergunta.
+        pacote[5] = 0x01;
+
+        var i = 12;
+
+        foreach (var parte in partes)
+        {
+            pacote[i++] = (byte)parte.Length;
+
+            foreach (var c in parte)
+                pacote[i++] = (byte)c;
+        }
+
+        pacote[i++] = 0;      // fim do nome
+        pacote[i++] = 0;
+        pacote[i++] = 1;      // tipo A
+        pacote[i++] = 0;
+        pacote[i] = 1;        // classe IN
+
+        return pacote;
+    }
+
+    // ==================================================================
+    // Wi-Fi
+    // ==================================================================
+
+    /// <summary>
+    /// Dados do Wi-Fi, ou null em conexão por cabo.
+    ///
+    /// O que interessa aqui é dizer ao jogador se ele está em 2,4 GHz, que
+    /// divide espaço com micro-ondas e com o Wi-Fi do vizinho, ou em 5/6 GHz.
+    /// </summary>
+    public EstadoWifi? LerWifi()
+    {
+        var adaptador = NetworkInterface.GetAllNetworkInterfaces()
+            .FirstOrDefault(n => n.NetworkInterfaceType == NetworkInterfaceType.Wireless80211
+                              && n.OperationalStatus == OperationalStatus.Up);
+
+        if (adaptador is null)
+            return null;
+
+        try
+        {
+            return Native.WlanInfo.Ler(adaptador.Id);
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException or InvalidOperationException)
+        {
+            _log.Warn("network", "Wifi", adaptador.Name, $"não foi possível ler: {ex.Message}");
+            return null;
+        }
+    }
+
+    public static bool ConectadoPorCabo()
+        => NetworkInterface.GetAllNetworkInterfaces()
+            .Any(n => n.NetworkInterfaceType == NetworkInterfaceType.Ethernet
+                   && n.OperationalStatus == OperationalStatus.Up
+                   && n.GetIPProperties().GatewayAddresses.Count > 0);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Network/NetworkModule.cs b/GameBoost/src/GameBoost.Core/Modules/Network/NetworkModule.cs
new file mode 100644
index 0000000..c29cebe
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Network/NetworkModule.cs
@@ -0,0 +1,711 @@
+using System.Diagnostics;
+using System.Net.NetworkInformation;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.Network;
+
+/// <summary>Quem está falando com a internet agora, agrupado por processo.</summary>
+public sealed record ConsumidorDeRede(int ProcessId, string Nome, int Conexoes, string PrincipalDestino);
+
+/// <summary>
+/// Rede (seção 5.9).
+///
+/// As ações daqui são de três naturezas bem diferentes, e a tela precisa deixar
+/// isso claro:
+///
+/// - **Limpar o cache de DNS** é inofensivo e instantâneo.
+/// - **Trocar o DNS do adaptador** é reversível de verdade: o valor anterior vai
+///   para o ChangeRecord e volta com um clique.
+/// - **Resetar o Winsock** derruba a rede até reiniciar e não tem desfazer. Vem
+///   com risco Alto e o aviso por extenso.
+/// </summary>
+public sealed class NetworkModule : IModule
+{
+    public const string ModuloId = "network";
+
+    private const string PrefixoDns = "dns:";
+    private const string ItemFlush = "rede:flush-dns";
+    private const string ItemWinsock = "rede:winsock";
+    private const string ItemTeredo = "rede:teredo";
+
+    private const string ChaveTcpip6 = @"SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters";
+    private const string ChaveTeredo = @"SYSTEM\CurrentControlSet\Services\iphlpsvc\Teredo";
+
+    private readonly NetworkDiagnostics _diagnostico;
+    private readonly NatDiagnostics _nat;
+    private readonly SpeedTest _velocidade;
+    private readonly IRegistryService _registro;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly IProcessService _processos;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    public NetworkModule(
+        NetworkDiagnostics diagnostico,
+        NatDiagnostics nat,
+        SpeedTest velocidade,
+        IRegistryService registro,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        IProcessService processos,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _diagnostico = diagnostico;
+        _nat = nat;
+        _velocidade = velocidade;
+        _registro = registro;
+        _backup = backup;
+        _rollback = rollback;
+        _processos = processos;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Rede";
+    public string Descricao => "Latência, jitter, perda e DNS — com o que dá para mudar e o que não vale mexer.";
+
+    /// <summary>Última medição, para a tela desenhar as tabelas.</summary>
+    public IReadOnlyList<MedicaoPing> UltimoPing { get; private set; } = Array.Empty<MedicaoPing>();
+    public IReadOnlyList<MedicaoDns> UltimoDns { get; private set; } = Array.Empty<MedicaoDns>();
+    public IReadOnlyList<ConsumidorDeRede> UltimosConsumidores { get; private set; } = Array.Empty<ConsumidorDeRede>();
+    public EstadoWifi? UltimoWifi { get; private set; }
+    public DiagnosticoDeNat? UltimoNat { get; private set; }
+    public ResultadoDeVelocidade? UltimaVelocidade { get; private set; }
+
+    /// <summary>O teste de velocidade gasta banda, então é opt-in.</summary>
+    public bool VelocidadePermitida => _velocidade.Permitido;
+
+    // ==================================================================
+    // Varredura
+    // ==================================================================
+
+    public async Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        progress?.Report(new ModuleProgress("Medindo latência", 10));
+        UltimoPing = await _diagnostico.MedirLatenciaAsync(ct);
+
+        progress?.Report(new ModuleProgress("Comparando servidores de DNS", 45));
+        UltimoDns = await _diagnostico.CompararDnsAsync(ct);
+
+        progress?.Report(new ModuleProgress("Descobrindo o tipo de NAT", 60));
+        UltimoNat = await _nat.DiagnosticarAsync(ct);
+
+        progress?.Report(new ModuleProgress("Vendo quem está usando a rede", 80));
+        UltimosConsumidores = LerConsumidores();
+        UltimoWifi = _diagnostico.LerWifi();
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        var itens = MontarItens();
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens,
+            Momento = _relogio.Now,
+            Resumo = MontarResumo(),
+            Avisos = MontarAvisos()
+        };
+    }
+
+    private string MontarResumo()
+    {
+        var internet = UltimoPing.FirstOrDefault(p => p.Rotulo.StartsWith("Internet", StringComparison.Ordinal) && p.Respondeu);
+
+        if (internet is null)
+            return "Nenhum dos alvos respondeu ao ping. Pode ser a rede, ou pode ser firewall bloqueando ICMP.";
+
+        var texto = $"Latência até a internet: {internet.MediaMs} ms ({internet.Leitura}), "
+                  + $"jitter {internet.JitterMs} ms, {internet.PerdaPercentual}% de perda.";
+
+        if (UltimoNat is not null && UltimoNat.Tipo != TipoDeNat.NaoDetectado)
+            texto += $" NAT {UltimoNat.NomeCurto}.";
+
+        if (UltimaVelocidade is { Funcionou: true })
+            texto += $" Download {UltimaVelocidade.DownloadMbps} Mbps, upload {UltimaVelocidade.UploadMbps} Mbps.";
+
+        var melhor = UltimoDns.Where(d => d.Respondeu && !d.EmUso).OrderBy(d => d.MediaMs).FirstOrDefault();
+        var atual = UltimoDns.FirstOrDefault(d => d.EmUso && d.Respondeu);
+
+        if (melhor is not null && atual is not null && melhor.MediaMs < atual.MediaMs - 5)
+            texto += $" O DNS da {melhor.Nome} responde {Math.Round(atual.MediaMs - melhor.MediaMs, 1)} ms mais rápido que o seu.";
+
+        return texto;
+    }
+
+    private IReadOnlyList<string> MontarAvisos()
+    {
+        var avisos = new List<string>();
+
+        var gateway = UltimoPing.FirstOrDefault(p => p.Rotulo == "Seu roteador");
+
+        // Jitter alto até o próprio roteador é o diagnóstico mais útil desta
+        // tela: o problema está dentro de casa, e trocar de DNS ou de provedor
+        // não vai resolver.
+        if (gateway is { Respondeu: true, JitterMs: > 5 })
+        {
+            avisos.Add($"O jitter até o seu próprio roteador é de {gateway.JitterMs} ms. "
+                     + "Quando isso acontece o problema está na sua casa, não no provedor: "
+                     + "costuma ser Wi-Fi congestionado ou cabo ruim.");
+        }
+
+        if (UltimoWifi is not null)
+        {
+            var texto = $"Você está no Wi-Fi ({UltimoWifi.Ssid}, {UltimoWifi.Padrao}, {UltimoWifi.Banda}, "
+                      + $"sinal {UltimoWifi.SinalPercentual}%).";
+
+            if (UltimoWifi.Banda.StartsWith("2,4", StringComparison.Ordinal))
+                texto += " A faixa de 2,4 GHz divide espaço com micro-ondas e com o Wi-Fi dos vizinhos. Se houver rede de 5 GHz, ela é melhor para jogo.";
+
+            texto += " Para jogo competitivo, cabo continua sendo melhor que qualquer Wi-Fi.";
+            avisos.Add(texto);
+        }
+
+        if (UltimoNat is not null)
+        {
+            avisos.Add(UltimoNat.Explicacao);
+
+            if (UltimoNat.Tipo is TipoDeNat.Estrito or TipoDeNat.Moderado && !UltimoNat.UpnpDisponivel)
+            {
+                avisos.Add("Seu roteador não respondeu à busca por UPnP. Com NAT estrito e sem "
+                         + "UPnP, a única saída é abrir as portas do jogo à mão no roteador. "
+                         + "As portas de cada jogo estão em docs/PORTAS.md.");
+            }
+        }
+
+        var emUso = UltimoDns.FirstOrDefault(d => d.EmUso);
+
+        if (emUso is not null && emUso.Endereco.StartsWith("192.168.", StringComparison.Ordinal))
+        {
+            avisos.Add($"O DNS em uso ({emUso.Endereco}) é o seu próprio roteador, que guarda "
+                     + "respostas em cache. A comparação abaixo favorece ele de propósito ou não: "
+                     + "um nome que ele já tem em cache responde em quase zero, um que não tem "
+                     + "custa a ida até o provedor. Os números são reais, mas não são uma "
+                     + "comparação limpa entre servidores.");
+        }
+
+        if (UltimosConsumidores.Count > 0)
+        {
+            avisos.Add("A lista de quem está usando a rede mostra número de conexões abertas, "
+                     + "não velocidade. Medir banda por processo exigiria um coletor de eventos "
+                     + "rodando o tempo todo, e isso custaria mais CPU do que o problema vale.");
+        }
+
+        return avisos;
+    }
+
+    private IReadOnlyList<ConsumidorDeRede> LerConsumidores()
+    {
+        try
+        {
+            var conexoes = TcpTable.Listar().Where(c => c.Estado == "conectada").ToList();
+
+            if (conexoes.Count == 0)
+                return Array.Empty<ConsumidorDeRede>();
+
+            var nomes = _processos.GetProcesses()
+                .GroupBy(p => p.Pid)
+                .ToDictionary(g => g.Key, g => g.First().Name);
+
+            // Agrupar por nome, nao por PID. Um editor de codigo sobe um
+            // processo de servidor de linguagem por projeto aberto, e por PID
+            // a lista virava a mesma linha repetida tres vezes, parecendo bug.
+            return conexoes
+                .Select(c => new
+                {
+                    Nome = nomes.TryGetValue(c.ProcessId, out var nome) ? nome : $"PID {c.ProcessId}",
+                    c.ProcessId,
+                    Destino = c.Remoto.ToString()
+                })
+                .GroupBy(c => c.Nome, StringComparer.OrdinalIgnoreCase)
+                .Select(g => new ConsumidorDeRede(
+                    g.First().ProcessId,
+                    g.Select(x => x.ProcessId).Distinct().Count() is var quantos && quantos > 1
+                        ? $"{g.Key} ({quantos} processos)"
+                        : g.Key,
+                    g.Count(),
+                    g.GroupBy(x => x.Destino)
+                     .OrderByDescending(x => x.Count())
+                     .First().Key))
+                .OrderByDescending(c => c.Conexoes)
+                .Take(10)
+                .ToList();
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or OutOfMemoryException)
+        {
+            _log.Warn(ModuloId, "Conexoes", null, ex.Message);
+            return Array.Empty<ConsumidorDeRede>();
+        }
+    }
+
+    private IReadOnlyList<ActionItem> MontarItens()
+    {
+        var itens = new List<ActionItem>
+        {
+            new()
+            {
+                Id = ItemFlush,
+                Categoria = "Manutenção",
+                Titulo = "Limpar o cache de DNS",
+                Descricao = "Apaga os nomes que o Windows memorizou. Resolve o caso específico de "
+                          + "um site ou servidor que mudou de endereço e continua abrindo no endereço "
+                          + "velho. Não acelera a internet.",
+                Risco = RiskLevel.Baixo,
+                GanhoEstimado = "efeito imediato, sem risco",
+                PreMarcado = false,
+                ComoDesfazer = "Não precisa desfazer: o cache se refaz sozinho na próxima consulta."
+            }
+        };
+
+        foreach (var dns in UltimoDns.Where(d => !d.EmUso && d.Respondeu))
+        {
+            var atual = UltimoDns.FirstOrDefault(d => d.EmUso && d.Respondeu);
+
+            var comparacao = atual is null
+                ? "não deu para medir o seu DNS atual para comparar"
+                : dns.MediaMs < atual.MediaMs
+                    ? $"responde {Math.Round(atual.MediaMs - dns.MediaMs, 1)} ms mais rápido que o seu ({atual.MediaMs} ms)"
+                    : $"responde {Math.Round(dns.MediaMs - atual.MediaMs, 1)} ms mais devagar que o seu ({atual.MediaMs} ms)";
+
+            itens.Add(new ActionItem
+            {
+                Id = PrefixoDns + dns.Endereco,
+                Categoria = "Servidor de DNS",
+                Titulo = $"Usar o DNS da {dns.Nome} ({dns.Endereco})",
+                Descricao = $"Medido agora: {dns.MediaMs} ms, {comparacao}. "
+                          + "DNS mais rápido faz página abrir mais rápido. Não muda o ping do jogo, "
+                          + "porque o jogo resolve o nome uma vez e depois fala direto com o servidor.",
+                Risco = RiskLevel.Baixo,
+                GanhoEstimado = $"{dns.MediaMs} ms",
+                PreMarcado = false,
+                ComoDesfazer = "Voltar ao DNS anterior por aqui. O valor antigo, inclusive o "
+                             + "automático do provedor, fica guardado no histórico.",
+                Payload = dns
+            });
+        }
+
+        if (UltimoNat?.Teredo == EstadoTeredo.Desativado)
+        {
+            itens.Add(new ActionItem
+            {
+                Id = ItemTeredo,
+                Categoria = "Conectividade",
+                Titulo = "Reativar o Teredo",
+                Descricao = "O Teredo está desligado nesta máquina. Ele é o túnel que o "
+                          + "multiplayer de Xbox e de Game Pass no PC usa para achar outros "
+                          + "jogadores; sem ele, esses jogos dão erro de rede e não entram em "
+                          + "partida. Muito guia de otimização manda desativar, e é justamente "
+                          + "isso que quebra o multiplayer de quem joga Game Pass. Se você não "
+                          + "joga nada da Microsoft, deixar desligado não faz falta.",
+                Risco = RiskLevel.Baixo,
+                GanhoEstimado = "desligado agora",
+                PreMarcado = false,
+                ComoDesfazer = "Desligar de novo por aqui. O valor anterior das duas chaves "
+                             + "fica no histórico."
+            });
+        }
+
+        itens.Add(new ActionItem
+        {
+            Id = ItemWinsock,
+            Categoria = "Manutenção",
+            Titulo = "Resetar o Winsock",
+            Descricao = "Devolve a pilha de rede do Windows ao estado de fábrica. Serve para "
+                      + "máquina que ficou sem internet depois de desinstalar VPN ou antivírus. "
+                      + "Derruba a rede até você reiniciar, apaga configurações de adaptador "
+                      + "e não tem desfazer automático. Não use como manutenção de rotina.",
+            Risco = RiskLevel.Alto,
+            GanhoEstimado = "só para consertar rede quebrada",
+            PreMarcado = false,
+            ComoDesfazer = "Não há desfazer. Depois de reiniciar, reconfigure VPN e "
+                         + "proxy que você usava."
+        });
+
+        return itens;
+    }
+
+    // ==================================================================
+    // Aplicação
+    // ==================================================================
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Aplicar(itemIds, dryRun, ct), ct);
+
+    private ApplyResult Aplicar(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+    {
+        var acoes = new List<AppliedAction>();
+
+        foreach (var id in itemIds)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            if (id == ItemFlush)
+                acoes.Add(LimparDns(dryRun));
+            else if (id == ItemWinsock)
+                acoes.Add(ResetarWinsock(dryRun));
+            else if (id == ItemTeredo)
+                acoes.Add(ReativarTeredo(dryRun));
+            else if (id.StartsWith(PrefixoDns, StringComparison.Ordinal))
+                acoes.Add(TrocarDns(id[PrefixoDns.Length..], id, dryRun));
+            else
+                acoes.Add(new AppliedAction(id, false, "Item desconhecido.", null));
+        }
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {ok} de {acoes.Count} ações seriam executadas."
+                : $"{ok} de {acoes.Count} ações executadas.",
+            GanhoMedido = "Varra de novo para medir o efeito: a tela mede latência e DNS na hora."
+        };
+    }
+
+    private AppliedAction LimparDns(bool dryRun)
+    {
+        if (dryRun)
+            return new AppliedAction(ItemFlush, true, "Limparia o cache de DNS.", null);
+
+        var ok = ToolsNative.LimparCacheDeDns();
+
+        _log.Info(ModuloId, "FlushDns", null, ok ? "cache limpo" : "falhou");
+
+        return new AppliedAction(ItemFlush, ok,
+            ok ? "Cache de DNS limpo." : "Não foi possível limpar o cache de DNS.", null);
+    }
+
+    private AppliedAction ResetarWinsock(bool dryRun)
+    {
+        if (dryRun)
+            return new AppliedAction(ItemWinsock, true,
+                "Rodaria netsh winsock reset. A rede cairia até reiniciar.", null);
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(ItemWinsock, false, "Resetar o Winsock precisa de administrador.", null);
+
+        try
+        {
+            using var processo = Process.Start(new ProcessStartInfo
+            {
+                FileName = "netsh.exe",
+                Arguments = "winsock reset",
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            });
+
+            if (processo is null)
+                return new AppliedAction(ItemWinsock, false, "Não foi possível iniciar o netsh.", null);
+
+            processo.WaitForExit(60_000);
+
+            // Nenhum ChangeRecord aqui, e de propósito: não existe estado
+            // anterior para guardar. O texto do item avisa disso antes.
+            _log.Warn(ModuloId, "Winsock", null, $"reset executado, código {processo.ExitCode}");
+
+            return processo.ExitCode == 0
+                ? new AppliedAction(ItemWinsock, true,
+                    "Winsock resetado. Reinicie o computador para a rede voltar ao normal.", null)
+                : new AppliedAction(ItemWinsock, false, $"netsh saiu com código {processo.ExitCode}.", null);
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            _log.Error(ModuloId, "Winsock", null, ex.Message, ex);
+            return new AppliedAction(ItemWinsock, false, ex.Message, null);
+        }
+    }
+
+    /// <summary>
+    /// Reativa o Teredo apagando as duas chaves que o desligam. Apagar, e nao
+    /// gravar zero: o padrao do Windows e o valor **ausente**, e deixar um zero
+    /// escrito congelaria a configuracao num estado que o Windows nao
+    /// escolheria sozinho.
+    /// </summary>
+    private AppliedAction ReativarTeredo(bool dryRun)
+    {
+        var componentes = _registro.GetValue(RegistryRoot.LocalMachine, ChaveTcpip6, "DisabledComponents");
+        var tipo = _registro.GetValue(RegistryRoot.LocalMachine, ChaveTeredo, "Type");
+
+        if (dryRun)
+        {
+            return new AppliedAction(ItemTeredo, true,
+                $"Apagaria DisabledComponents (agora {componentes?.ToString() ?? "ausente"}) e "
+              + $"Type do Teredo (agora {tipo?.ToString() ?? "ausente"}).", null);
+        }
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(ItemTeredo, false, "Reativar o Teredo precisa de administrador.", null);
+
+        try
+        {
+            if (componentes is not null)
+            {
+                _backup.Registrar(new ChangeRecord
+                {
+                    Modulo = ModuloId,
+                    Tipo = ChangeType.Registry,
+                    Alvo = ChaveTcpip6,
+                    SubAlvo = "DisabledComponents",
+                    ValorAnterior = componentes.ToString(),
+                    ValorNovo = null,
+                    ValorAnteriorExistia = true,
+                    Extras =
+                    {
+                        ["root"] = RegistryRoot.LocalMachine.ToString(),
+                        ["kind"] = RegistryValueKindLite.DWord.ToString(),
+                        ["nome"] = "Tuneis IPv6 (Teredo)"
+                    }
+                });
+
+                _registro.DeleteValue(RegistryRoot.LocalMachine, ChaveTcpip6, "DisabledComponents");
+            }
+
+            if (tipo is not null)
+            {
+                _backup.Registrar(new ChangeRecord
+                {
+                    Modulo = ModuloId,
+                    Tipo = ChangeType.Registry,
+                    Alvo = ChaveTeredo,
+                    SubAlvo = "Type",
+                    ValorAnterior = tipo.ToString(),
+                    ValorNovo = null,
+                    ValorAnteriorExistia = true,
+                    Extras =
+                    {
+                        ["root"] = RegistryRoot.LocalMachine.ToString(),
+                        ["kind"] = RegistryValueKindLite.DWord.ToString(),
+                        ["nome"] = "Estado do Teredo"
+                    }
+                });
+
+                _registro.DeleteValue(RegistryRoot.LocalMachine, ChaveTeredo, "Type");
+            }
+
+            _log.Info(ModuloId, "Teredo", null, "reativado");
+
+            return new AppliedAction(ItemTeredo, true,
+                "Teredo reativado. Reinicie o computador para o tunel subir.", null);
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or System.Security.SecurityException or IOException)
+        {
+            _log.Error(ModuloId, "Teredo", null, ex.Message, ex);
+            return new AppliedAction(ItemTeredo, false, ex.Message, null);
+        }
+    }
+
+    /// <summary>
+    /// Teste de velocidade, separado da varredura porque gasta 33 MB de banda.
+    /// Os outros testes desta tela (ping, DNS, STUN) mandam pacotes de dezenas
+    /// de bytes; este transfere um arquivo, e num plano com franquia isso e
+    /// dinheiro do usuario. Por isso ele e um botao a parte e depende da
+    /// permissao explicita em Configuracoes.
+    /// </summary>
+    public async Task<ResultadoDeVelocidade> MedirVelocidadeAsync(IProgress<string>? progresso, CancellationToken ct)
+    {
+        UltimaVelocidade = await _velocidade.MedirAsync(progresso, ct);
+        return UltimaVelocidade;
+    }
+
+    private AppliedAction TrocarDns(string servidor, string itemId, bool dryRun)
+    {
+        var adaptador = AdaptadorPrincipal();
+
+        if (adaptador is null)
+            return new AppliedAction(itemId, false, "Nenhum adaptador de rede ativo com gateway.", null);
+
+        var anteriores = adaptador.GetIPProperties().DnsAddresses
+            .Where(a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
+            .Select(a => a.ToString())
+            .ToList();
+
+        var texto = anteriores.Count == 0 ? "automático (DHCP)" : string.Join(", ", anteriores);
+
+        if (dryRun)
+            return new AppliedAction(itemId, true,
+                $"{adaptador.Name}: DNS passaria de {texto} para {servidor}.", null);
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(itemId, false, "Trocar o DNS precisa de administrador.", null);
+
+        // Regra 1: o estado anterior vai para o histórico antes de qualquer
+        // escrita — inclusive o caso "estava no automático", que é o mais fácil
+        // de perder e o mais chato de reconstruir depois.
+        var registro = _backup.Registrar(new ChangeRecord
+        {
+            Modulo = ModuloId,
+            Tipo = ChangeType.Registry,
+            Alvo = adaptador.Id,
+            SubAlvo = "dns",
+            ValorAnterior = anteriores.Count == 0 ? null : string.Join(",", anteriores),
+            ValorNovo = servidor,
+            ValorAnteriorExistia = anteriores.Count > 0,
+            Extras =
+            {
+                ["adaptador"] = adaptador.Name,
+                ["nome"] = $"DNS de {adaptador.Name}",
+                ["netsh"] = "dns"
+            }
+        });
+
+        var ok = DefinirDns(adaptador.Name, servidor);
+
+        if (!ok)
+            return new AppliedAction(itemId, false, $"Não foi possível trocar o DNS de {adaptador.Name}.", registro.Id);
+
+        // Sem limpar o cache, o usuário troca de DNS e continua vendo as
+        // respostas do antigo por horas.
+        ToolsNative.LimparCacheDeDns();
+
+        _log.Info(ModuloId, "TrocarDns", adaptador.Name, $"{texto} -> {servidor}");
+
+        return new AppliedAction(itemId, true,
+            $"DNS de {adaptador.Name} agora é {servidor}. O anterior era {texto} e está no histórico.",
+            registro.Id);
+    }
+
+    private static NetworkInterface? AdaptadorPrincipal()
+        => NetworkInterface.GetAllNetworkInterfaces()
+            .Where(n => n.OperationalStatus == OperationalStatus.Up
+                     && n.NetworkInterfaceType != NetworkInterfaceType.Loopback
+                     && n.GetIPProperties().GatewayAddresses.Count > 0)
+            .OrderBy(n => n.NetworkInterfaceType == NetworkInterfaceType.Ethernet ? 0 : 1)
+            .FirstOrDefault();
+
+    /// <summary>
+    /// Troca o DNS pelo netsh. O spec sugeria o WMI
+    /// (`SetDNSServerSearchOrder`), mas aquele método é da classe
+    /// `Win32_NetworkAdapterConfiguration`, que está congelada desde o Windows 8
+    /// e falha em adaptador configurado por DHCP em algumas máquinas. O netsh é
+    /// a via que o próprio Windows usa.
+    /// </summary>
+    internal static bool DefinirDns(string nomeDoAdaptador, string? servidor)
+    {
+        var argumentos = servidor is null
+            ? $"interface ipv4 set dnsservers name=\"{nomeDoAdaptador}\" source=dhcp"
+            : $"interface ipv4 set dnsservers name=\"{nomeDoAdaptador}\" static {servidor} primary";
+
+        try
+        {
+            using var processo = Process.Start(new ProcessStartInfo
+            {
+                FileName = "netsh.exe",
+                Arguments = argumentos,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            });
+
+            if (processo is null)
+                return false;
+
+            processo.WaitForExit(30_000);
+            return processo.ExitCode == 0;
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            return false;
+        }
+    }
+
+    // ==================================================================
+    // Reversão
+    // ==================================================================
+
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Reverter(changeIds, dryRun), ct);
+
+    private ApplyResult Reverter(IReadOnlyList<string> changeIds, bool dryRun)
+    {
+        var pendentes = _backup.Pendentes.Where(r => r.Modulo == ModuloId).ToList();
+
+        var alvos = changeIds.Count > 0
+            ? pendentes.Where(r => changeIds.Contains(r.Id)).ToList()
+            : pendentes;
+
+        if (alvos.Count == 0)
+        {
+            return new ApplyResult
+            {
+                ModuloId = ModuloId,
+                DryRun = dryRun,
+                Resumo = "Não há alteração de rede para desfazer."
+            };
+        }
+
+        var acoes = new List<AppliedAction>();
+
+        foreach (var registro in Enumerable.Reverse(alvos))
+        {
+            // A troca de DNS não volta pelo RollbackEngine: ele restaura valor
+            // de registro, e aqui o que precisa voltar é a configuração do
+            // adaptador, inclusive o caso "voltar para automático".
+            if (registro.Extras.TryGetValue("netsh", out var tipo) && tipo == "dns")
+            {
+                acoes.Add(ReverterDns(registro, dryRun));
+                continue;
+            }
+
+            var resultado = _rollback.Reverter(new[] { registro.Id }, dryRun).FirstOrDefault();
+
+            if (resultado is not null)
+                acoes.Add(new AppliedAction(resultado.ChangeId, resultado.Sucesso, resultado.Detalhe, resultado.ChangeId));
+        }
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {ok} de {acoes.Count} alterações voltariam."
+                : $"{ok} de {acoes.Count} alterações revertidas."
+        };
+    }
+
+    private AppliedAction ReverterDns(ChangeRecord registro, bool dryRun)
+    {
+        var adaptador = registro.Extras.TryGetValue("adaptador", out var nome) ? nome : null;
+
+        if (adaptador is null)
+            return new AppliedAction(registro.Id, false, "Histórico sem o nome do adaptador.", registro.Id);
+
+        var voltarPara = registro.ValorAnteriorExistia
+            ? registro.ValorAnterior?.Split(',').FirstOrDefault()
+            : null;
+
+        var texto = voltarPara ?? "automático (DHCP)";
+
+        if (dryRun)
+            return new AppliedAction(registro.Id, true, $"DNS de {adaptador} voltaria para {texto}.", registro.Id);
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(registro.Id, false, "Reverter o DNS precisa de administrador.", registro.Id);
+
+        var ok = DefinirDns(adaptador, voltarPara);
+
+        if (ok)
+        {
+            ToolsNative.LimparCacheDeDns();
+            _backup.MarcarRevertido(registro.Id, _relogio.Now);
+        }
+
+        return new AppliedAction(registro.Id, ok,
+            ok ? $"DNS de {adaptador} voltou para {texto}." : $"Não foi possível reverter o DNS de {adaptador}.",
+            registro.Id);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Network/SpeedTest.cs b/GameBoost/src/GameBoost.Core/Modules/Network/SpeedTest.cs
new file mode 100644
index 0000000..217d9e8
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Network/SpeedTest.cs
@@ -0,0 +1,308 @@
+using System.Diagnostics;
+using System.Net;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Network;
+
+public sealed record ResultadoDeVelocidade(
+    double DownloadMbps,
+    double UploadMbps,
+    long BytesBaixados,
+    long BytesEnviados,
+    TimeSpan Duracao,
+    string? Erro)
+{
+    public bool Funcionou => Erro is null && DownloadMbps > 0;
+}
+
+/// <summary>
+/// Teste de velocidade (seção 5.9.1).
+///
+/// Três coisas que ele **não** é, e que a tela precisa dizer:
+///
+/// - Não substitui um teste de banda dedicado. Ele usa um servidor só e uma
+///   conexão só, enquanto o Speedtest escolhe o servidor mais próximo e abre
+///   várias em paralelo. O número sai por volta de 10% a 15% abaixo.
+///
+///   Vale lembrar que o teste dedicado também erra quando o servidor escolhido
+///   está congestionado: na mesma máquina e no mesmo minuto, um servidor deu
+///   73 Mbps de upload e outro deu 264.
+/// - Não mede a sua internet quando alguém está baixando algo em outra máquina.
+/// - Não tem relação com ping. Banda e latência são coisas diferentes, e é a
+///   latência que decide se o jogo está bom.
+///
+/// O que ele responde é uma pergunta específica: "a minha conexão está
+/// entregando algo próximo do que eu contratei, ou está muito abaixo?".
+///
+/// **Só roda quando o usuário permite acesso à rede** (regra 8).
+/// </summary>
+public sealed class SpeedTest
+{
+    private const string UrlDownload = "https://speed.cloudflare.com/__down?bytes=";
+    private const string UrlUpload = "https://speed.cloudflare.com/__up";
+
+    /// <summary>Três amostras, mediana no fim (seção 5.9.1).</summary>
+    private const int Amostras = 3;
+
+    /// <summary>
+    /// Duração de cada amostra.
+    ///
+    /// **Medir por tempo, não por tamanho.** A primeira versão transferia 25 MB
+    /// e cronometrava, o que parecia equivalente e era mais previsível para a
+    /// franquia de quem tem limite. Não é equivalente: numa fibra doméstica a
+    /// operadora deixa passar bem acima do contratado por um ou dois segundos,
+    /// e uma transferência que termina em 0,6 s mede **só essa rajada**.
+    ///
+    /// Na máquina de teste isso deu 380 Mbps de upload numa linha que entrega
+    /// 73. Não era ruído: com 8, 25 e 50 MB o resultado saiu 131, 354 e 275
+    /// Mbps — todos errados, e nenhum parecido com o outro.
+    /// </summary>
+    private static readonly TimeSpan DuracaoDaAmostra = TimeSpan.FromSeconds(8);
+
+    /// <summary>
+    /// O começo da transferência é descartado.
+    ///
+    /// É onde moram a rajada da operadora e o slow start do TCP, que ainda está
+    /// descobrindo quanto a linha aguenta. O que interessa é a taxa sustentada,
+    /// e ela só aparece depois.
+    /// </summary>
+    private static readonly TimeSpan Aquecimento = TimeSpan.FromSeconds(2);
+
+    /// <summary>
+    /// Teto por amostra, para não comer a franquia de quem tem limite. Numa
+    /// conexão de 500 Mbps, 8 segundos passariam de 500 MB.
+    /// </summary>
+    private const long TetoDeBytes = 120L * 1024 * 1024;
+
+    /// <summary>Pedaço pedido ao servidor a cada rodada do laço de download.</summary>
+    private const int BlocoDeDownload = 25 * 1024 * 1024;
+
+    private readonly ISettingsStore _configuracoes;
+    private readonly IGameBoostLogger _log;
+
+    public SpeedTest(ISettingsStore configuracoes, IGameBoostLogger log)
+    {
+        _configuracoes = configuracoes;
+        _log = log;
+    }
+
+    public bool Permitido => _configuracoes.Load().PermitirAcessoARede;
+
+    public async Task<ResultadoDeVelocidade> MedirAsync(IProgress<string>? progresso, CancellationToken ct)
+    {
+        if (!Permitido)
+        {
+            return new ResultadoDeVelocidade(0, 0, 0, 0, TimeSpan.Zero,
+                "O teste de velocidade precisa de acesso à internet, e essa permissão está "
+              + "desligada. Ligue em Configurações, se quiser.");
+        }
+
+        var relogio = Stopwatch.StartNew();
+
+        try
+        {
+            using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(90) };
+            http.DefaultRequestHeaders.UserAgent.ParseAdd("GameBoost/2.0");
+
+            var downloads = new List<double>(Amostras);
+            var uploads = new List<double>(Amostras);
+            long bytesBaixados = 0;
+            long bytesEnviados = 0;
+
+            for (var i = 1; i <= Amostras; i++)
+            {
+                progresso?.Report($"Medindo download ({i} de {Amostras})");
+                var (mbps, bytes) = await MedirDownloadAsync(http, ct);
+
+                if (mbps > 0)
+                {
+                    downloads.Add(mbps);
+                    bytesBaixados += bytes;
+                }
+            }
+
+            for (var i = 1; i <= Amostras; i++)
+            {
+                progresso?.Report($"Medindo upload ({i} de {Amostras})");
+                var (mbps, bytes) = await MedirUploadAsync(http, ct);
+
+                if (mbps > 0)
+                {
+                    uploads.Add(mbps);
+                    bytesEnviados += bytes;
+                }
+            }
+
+            relogio.Stop();
+
+            var download = Mediana(downloads);
+            var upload = Mediana(uploads);
+
+            _log.Info("network", "Velocidade", null,
+                $"download {download:0.0} Mbps, upload {upload:0.0} Mbps, "
+              + $"{bytesBaixados / 1024 / 1024} MB baixados, {bytesEnviados / 1024 / 1024} MB enviados");
+
+            return new ResultadoDeVelocidade(
+                Math.Round(download, 1), Math.Round(upload, 1),
+                bytesBaixados, bytesEnviados, relogio.Elapsed, null);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or IOException or TaskCanceledException)
+        {
+            relogio.Stop();
+            _log.Warn("network", "Velocidade", null, ex.Message);
+
+            return new ResultadoDeVelocidade(0, 0, 0, 0, relogio.Elapsed,
+                $"Não foi possível completar o teste: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Baixa por <see cref="DuracaoDaAmostra"/> e conta só o que passou depois
+    /// do aquecimento.
+    /// </summary>
+    private static async Task<(double Mbps, long Bytes)> MedirDownloadAsync(HttpClient http, CancellationToken ct)
+    {
+        var buffer = new byte[81920];
+        long totalTransferido = 0;
+        long contados = 0;
+
+        var relogio = Stopwatch.StartNew();
+        TimeSpan? inicioDaContagem = null;
+
+        while (relogio.Elapsed < DuracaoDaAmostra && totalTransferido < TetoDeBytes)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            using var resposta = await http.GetAsync(
+                UrlDownload + BlocoDeDownload, HttpCompletionOption.ResponseHeadersRead, ct);
+
+            resposta.EnsureSuccessStatusCode();
+
+            await using var fluxo = await resposta.Content.ReadAsStreamAsync(ct);
+
+            int lidos;
+            while ((lidos = await fluxo.ReadAsync(buffer, ct)) > 0)
+            {
+                totalTransferido += lidos;
+
+                if (relogio.Elapsed >= Aquecimento)
+                {
+                    inicioDaContagem ??= relogio.Elapsed;
+                    contados += lidos;
+                }
+
+                if (relogio.Elapsed >= DuracaoDaAmostra || totalTransferido >= TetoDeBytes)
+                    break;
+            }
+        }
+
+        relogio.Stop();
+
+        if (inicioDaContagem is null || contados == 0)
+            return (0, totalTransferido);
+
+        var janela = relogio.Elapsed - inicioDaContagem.Value;
+
+        return janela.TotalSeconds <= 0
+            ? (0, totalTransferido)
+            : (contados * 8.0 / janela.TotalSeconds / 1_000_000, totalTransferido);
+    }
+
+    /// <summary>
+    /// Envia por <see cref="DuracaoDaAmostra"/>, contando só depois do
+    /// aquecimento.
+    ///
+    /// O corpo é escrito por um fluxo, não por um array pronto: assim dá para
+    /// cronometrar **enquanto** os bytes saem. Com `ByteArrayContent` só dava
+    /// para medir o POST inteiro, e era isso que fazia o resultado depender do
+    /// tamanho escolhido.
+    /// </summary>
+    private static async Task<(double Mbps, long Bytes)> MedirUploadAsync(HttpClient http, CancellationToken ct)
+    {
+        var bloco = new byte[81920];
+        Random.Shared.NextBytes(bloco);
+
+        long totalEnviado = 0;
+        long contados = 0;
+        var relogio = Stopwatch.StartNew();
+        TimeSpan? inicioDaContagem = null;
+
+        using var conteudo = new ConteudoDeFluxo(async destino =>
+        {
+            while (relogio.Elapsed < DuracaoDaAmostra && totalEnviado < TetoDeBytes)
+            {
+                ct.ThrowIfCancellationRequested();
+
+                await destino.WriteAsync(bloco, ct);
+                await destino.FlushAsync(ct);
+
+                totalEnviado += bloco.Length;
+
+                if (relogio.Elapsed >= Aquecimento)
+                {
+                    inicioDaContagem ??= relogio.Elapsed;
+                    contados += bloco.Length;
+                }
+            }
+        });
+
+        using var resposta = await http.PostAsync(UrlUpload, conteudo, ct);
+        relogio.Stop();
+
+        if (!resposta.IsSuccessStatusCode || inicioDaContagem is null || contados == 0)
+            return (0, totalEnviado);
+
+        var janela = relogio.Elapsed - inicioDaContagem.Value;
+
+        return janela.TotalSeconds <= 0
+            ? (0, totalEnviado)
+            : (contados * 8.0 / janela.TotalSeconds / 1_000_000, totalEnviado);
+    }
+
+    /// <summary>
+    /// Conteúdo HTTP que escreve direto no fluxo de saída, sem montar o corpo
+    /// inteiro na memória antes. É o que permite cronometrar o envio enquanto
+    /// ele acontece.
+    /// </summary>
+    private sealed class ConteudoDeFluxo : HttpContent
+    {
+        private readonly Func<Stream, Task> _escrever;
+
+        public ConteudoDeFluxo(Func<Stream, Task> escrever)
+        {
+            _escrever = escrever;
+        }
+
+        protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context)
+            => _escrever(stream);
+
+        /// <summary>
+        /// Comprimento desconhecido de propósito: o envio termina por tempo, não
+        /// por tamanho. Sem Content-Length o .NET usa transferência em pedaços,
+        /// que é exatamente o que se quer.
+        /// </summary>
+        protected override bool TryComputeLength(out long length)
+        {
+            length = 0;
+            return false;
+        }
+    }
+
+    internal static double Mediana(List<double> valores)
+    {
+        if (valores.Count == 0)
+            return 0;
+
+        var ordenados = valores.OrderBy(v => v).ToList();
+        var meio = ordenados.Count / 2;
+
+        return ordenados.Count % 2 == 1
+            ? ordenados[meio]
+            : (ordenados[meio - 1] + ordenados[meio]) / 2;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Network/StunClient.cs b/GameBoost/src/GameBoost.Core/Modules/Network/StunClient.cs
new file mode 100644
index 0000000..d74ab10
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Network/StunClient.cs
@@ -0,0 +1,170 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace GameBoost.Core.Modules.Network;
+
+/// <summary>O que um servidor STUN respondeu: como o mundo vê esta máquina.</summary>
+public sealed record RespostaStun(IPAddress EnderecoPublico, int PortaPublica, IPEndPoint Local);
+
+/// <summary>
+/// Cliente STUN mínimo (RFC 5389), só o Binding Request.
+///
+/// É o que permite responder à pergunta que importa para jogo online: **qual é
+/// o meu endereço visto de fora, e a porta que eu abri sai com o mesmo número?**
+/// Sem isso não dá para distinguir um NAT que deixa o jogo receber conexão de
+/// um que não deixa — e é essa diferença que decide se o jogador consegue
+/// hospedar partida, entrar em lobby e falar por voz.
+///
+/// A implementação é propositalmente curta: só o suficiente para mandar um
+/// Binding Request e ler o XOR-MAPPED-ADDRESS da resposta. Uma biblioteca de
+/// STUN completa traria ICE, TURN e autenticação, nada disso usado aqui.
+/// </summary>
+public static class StunClient
+{
+    private const int TamanhoCabecalho = 20;
+    private const uint MagicCookie = 0x2112A442;
+
+    private const ushort BindingRequest = 0x0001;
+    private const ushort BindingResponse = 0x0101;
+
+    private const ushort AtributoMappedAddress = 0x0001;
+    private const ushort AtributoXorMappedAddress = 0x0020;
+
+    /// <summary>
+    /// Servidores usados na detecção. São dois de propósito: comparar a porta
+    /// devolvida por servidores diferentes é o que separa NAT de cone
+    /// (mesma porta para todos) de NAT simétrico (porta nova a cada destino),
+    /// que é o tipo que quebra jogo peer-to-peer.
+    /// </summary>
+    public static readonly (string Host, int Porta)[] Servidores =
+    {
+        ("stun.l.google.com", 19302),
+        ("stun1.l.google.com", 19302),
+        ("stun.cloudflare.com", 3478)
+    };
+
+    /// <summary>
+    /// Pergunta a um servidor STUN como esta máquina aparece de fora.
+    /// <paramref name="portaLocal"/> zero deixa o sistema escolher.
+    /// </summary>
+    public static async Task<RespostaStun?> ConsultarAsync(
+        string host, int porta, int portaLocal, CancellationToken ct)
+    {
+        using var socket = new UdpClient(portaLocal);
+
+        try
+        {
+            var enderecos = await Dns.GetHostAddressesAsync(host, ct);
+            var destino = enderecos.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork);
+
+            if (destino is null)
+                return null;
+
+            var transacao = new byte[12];
+            Random.Shared.NextBytes(transacao);
+
+            var pedido = MontarPedido(transacao);
+            await socket.SendAsync(pedido, pedido.Length, new IPEndPoint(destino, porta));
+
+            using var limite = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            limite.CancelAfter(TimeSpan.FromSeconds(3));
+
+            var resposta = await socket.ReceiveAsync(limite.Token);
+            var local = (IPEndPoint)socket.Client.LocalEndPoint!;
+
+            return Interpretar(resposta.Buffer, transacao, local);
+        }
+        catch (Exception ex) when (ex is SocketException or OperationCanceledException or ArgumentException)
+        {
+            return null;
+        }
+    }
+
+    private static byte[] MontarPedido(byte[] transacao)
+    {
+        var pacote = new byte[TamanhoCabecalho];
+
+        pacote[0] = (byte)(BindingRequest >> 8);
+        pacote[1] = (byte)(BindingRequest & 0xFF);
+
+        // Comprimento zero: o Binding Request não leva atributo nenhum.
+        pacote[2] = 0;
+        pacote[3] = 0;
+
+        pacote[4] = 0x21;
+        pacote[5] = 0x12;
+        pacote[6] = 0xA4;
+        pacote[7] = 0x42;
+
+        transacao.CopyTo(pacote, 8);
+        return pacote;
+    }
+
+    private static RespostaStun? Interpretar(byte[] buffer, byte[] transacao, IPEndPoint local)
+    {
+        if (buffer.Length < TamanhoCabecalho)
+            return null;
+
+        var tipo = (ushort)((buffer[0] << 8) | buffer[1]);
+
+        if (tipo != BindingResponse)
+            return null;
+
+        // A resposta tem que carregar o mesmo id de transação, senão é resposta
+        // de outra pergunta — ou de quem quis se passar pelo servidor.
+        for (var i = 0; i < 12; i++)
+        {
+            if (buffer[8 + i] != transacao[i])
+                return null;
+        }
+
+        var comprimento = (ushort)((buffer[2] << 8) | buffer[3]);
+        var fim = Math.Min(TamanhoCabecalho + comprimento, buffer.Length);
+        var i2 = TamanhoCabecalho;
+
+        while (i2 + 4 <= fim)
+        {
+            var atributo = (ushort)((buffer[i2] << 8) | buffer[i2 + 1]);
+            var tamanho = (ushort)((buffer[i2 + 2] << 8) | buffer[i2 + 3]);
+            var dados = i2 + 4;
+
+            if (dados + tamanho > buffer.Length)
+                break;
+
+            if (atributo is AtributoXorMappedAddress or AtributoMappedAddress && tamanho >= 8)
+            {
+                var familia = buffer[dados + 1];
+
+                // Só IPv4: o que importa aqui é o NAT, e NAT é coisa de IPv4.
+                if (familia == 0x01)
+                {
+                    var xor = atributo == AtributoXorMappedAddress;
+
+                    var porta = (buffer[dados + 2] << 8) | buffer[dados + 3];
+                    var endereco = new byte[4];
+                    Array.Copy(buffer, dados + 4, endereco, 0, 4);
+
+                    if (xor)
+                    {
+                        // O XOR com o magic cookie existe para o pacote não
+                        // trombar com middleboxes que reescrevem endereços que
+                        // reconhecem no corpo da mensagem.
+                        porta ^= (int)(MagicCookie >> 16);
+
+                        endereco[0] ^= 0x21;
+                        endereco[1] ^= 0x12;
+                        endereco[2] ^= 0xA4;
+                        endereco[3] ^= 0x42;
+                    }
+
+                    return new RespostaStun(new IPAddress(endereco), porta & 0xFFFF, local);
+                }
+            }
+
+            // Atributos são alinhados em 4 bytes.
+            i2 = dados + ((tamanho + 3) & ~3);
+        }
+
+        return null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Profiles/GameProfile.cs b/GameBoost/src/GameBoost.Core/Modules/Profiles/GameProfile.cs
new file mode 100644
index 0000000..f4ec8f5
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Profiles/GameProfile.cs
@@ -0,0 +1,135 @@
+using GameBoost.Core.Abstractions;
+
+namespace GameBoost.Core.Modules.Profiles;
+
+/// <summary>Um tweak por executável, aplicado só enquanto o jogo roda.</summary>
+public sealed class TweakDoPerfil
+{
+    public string Id { get; set; } = string.Empty;
+    public bool Ligar { get; set; } = true;
+}
+
+/// <summary>
+/// Perfil de um jogo (seção 5.11).
+///
+/// Um perfil diz o que fazer quando **este** jogo abre e o que desfazer quando
+/// ele fecha. A reversão não é opcional nem configurável: sair do jogo devolve
+/// a máquina ao estado anterior, sempre. Um perfil que só sabe ligar coisas
+/// seria a mesma armadilha dos boosters que deixam o Windows Update desligado
+/// para sempre.
+/// </summary>
+public sealed class GameProfile
+{
+    /// <summary>Nome do executável sem extensão, em minúsculas. É a chave.</summary>
+    public string Executavel { get; set; } = string.Empty;
+
+    public string Nome { get; set; } = string.Empty;
+    public string? Caminho { get; set; }
+    public string? Launcher { get; set; }
+
+    /// <summary>
+    /// Ativar o Modo Game sozinho ao detectar o jogo. **Desligado por padrão**:
+    /// a primeira vez sempre pergunta (regra 3).
+    /// </summary>
+    public bool Automatico { get; set; }
+
+    public bool AtivarModoGame { get; set; } = true;
+
+    /// <summary>GUID do plano de energia. Null usa o do Modo Game.</summary>
+    public string? PlanoDeEnergia { get; set; }
+
+    /// <summary>Prioridade do processo do jogo.</summary>
+    public ProcessPriority? Prioridade { get; set; } = ProcessPriority.AboveNormal;
+
+    /// <summary>
+    /// Núcleos reservados para o jogo, por índice. Lista vazia = não mexer.
+    ///
+    /// **Desligado por padrão, e com motivo.** Limitar afinidade quase sempre
+    /// piora: o agendador do Windows sabe mais sobre cache e SMT que qualquer
+    /// lista fixa. Isto existe para o caso raro de jogo antigo que se perde em
+    /// CPU de muitos núcleos.
+    /// </summary>
+    public List<int> Afinidade { get; set; } = new();
+
+    /// <summary>Resolução de timer em 0,5 ms enquanto o jogo roda.</summary>
+    public bool TimerDeMeioMilissegundo { get; set; }
+
+    /// <summary>Tweaks do catálogo aplicados só durante a sessão.</summary>
+    public List<TweakDoPerfil> Tweaks { get; set; } = new();
+
+    /// <summary>Processos a encerrar ao entrar. Nunca inclui protegido.</summary>
+    public List<string> FecharApps { get; set; } = new();
+
+    /// <summary>Apps a reabrir ao sair, no formato do Modo Game.</summary>
+    public List<string> ReabrirApps { get; set; } = new();
+
+    public DateTimeOffset? UltimaVez { get; set; }
+    public int VezesUsado { get; set; }
+
+    /// <summary>Resumo de uma linha para a tela.</summary>
+    public string Resumo
+    {
+        get
+        {
+            var partes = new List<string>();
+
+            if (AtivarModoGame)
+                partes.Add("Modo Game");
+
+            if (Prioridade is not null and not ProcessPriority.Normal)
+                partes.Add($"prioridade {TextoDaPrioridade(Prioridade.Value)}");
+
+            if (Afinidade.Count > 0)
+                partes.Add($"{Afinidade.Count} núcleos");
+
+            if (TimerDeMeioMilissegundo)
+                partes.Add("timer 0,5 ms");
+
+            if (FecharApps.Count > 0)
+                partes.Add($"fecha {FecharApps.Count} apps");
+
+            if (Tweaks.Count > 0)
+                partes.Add($"{Tweaks.Count} tweaks");
+
+            partes.Add(Automatico ? "ativa sozinho" : "pergunta antes");
+
+            return string.Join(" · ", partes);
+        }
+    }
+
+    public static string TextoDaPrioridade(ProcessPriority p) => p switch
+    {
+        ProcessPriority.High => "alta",
+        ProcessPriority.AboveNormal => "acima do normal",
+        ProcessPriority.Normal => "normal",
+        ProcessPriority.BelowNormal => "abaixo do normal",
+        ProcessPriority.Idle => "ociosa",
+        _ => "desconhecida"
+    };
+
+    /// <summary>
+    /// Perfil padrão para um jogo recém-detectado. Conservador de propósito: o
+    /// que ele faz é exatamente o que o Modo Game já faria, sem nada extra.
+    /// </summary>
+    public static GameProfile Padrao(string executavel, string nome, string? caminho, string? launcher)
+        => new()
+        {
+            Executavel = Normalizar(executavel),
+            Nome = nome,
+            Caminho = caminho,
+            Launcher = launcher,
+            Automatico = false,
+            AtivarModoGame = true,
+            Prioridade = ProcessPriority.AboveNormal
+        };
+
+    public static string Normalizar(string executavel)
+    {
+        var nome = executavel.Trim();
+
+        if (nome.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+            nome = nome[..^4];
+
+        return nome.ToLowerInvariant();
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Profiles/GameWatcher.cs b/GameBoost/src/GameBoost.Core/Modules/Profiles/GameWatcher.cs
new file mode 100644
index 0000000..8b82fb4
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Profiles/GameWatcher.cs
@@ -0,0 +1,216 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+
+namespace GameBoost.Core.Modules.Profiles;
+
+/// <summary>Um jogo começou a rodar.</summary>
+public sealed record JogoAbriu(DetectedGame Jogo, GameProfile? Perfil, bool TelaCheia);
+
+/// <summary>Um jogo que estava rodando saiu.</summary>
+public sealed record JogoFechou(string Executavel, string Nome, TimeSpan Duracao);
+
+/// <summary>
+/// Vigia os processos e avisa quando um jogo abre ou fecha (seção 5.1).
+///
+/// **Por polling, não por WMI.** O spec sugere `Win32_ProcessStartTrace`, que
+/// entrega o evento na hora. O problema é que ele exige uma consulta WMI
+/// permanente, e foi justamente WMI em laço que estourou o orçamento de CPU na
+/// Fase 1 — a coleta chegou a 5% antes de o WMI sair dela. Um polling de 2 s
+/// lista processos por `NtQuerySystemInformation`, que é o caminho barato, e
+/// 2 segundos de atraso não importam para algo que o usuário vai confirmar num
+/// diálogo.
+/// </summary>
+public sealed class GameWatcher : IDisposable
+{
+    /// <summary>Intervalo do spec (5.1).</summary>
+    private static readonly TimeSpan Intervalo = TimeSpan.FromSeconds(2);
+
+    private readonly IProcessService _processos;
+    private readonly GameDetector _detector;
+    private readonly ProfileStore _perfis;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    private Thread? _thread;
+    private CancellationTokenSource? _cts;
+
+    /// <summary>Jogo em execução agora, se houver.</summary>
+    private DetectedGame? _atual;
+    private DateTimeOffset _desde;
+
+    /// <summary>
+    /// Executáveis que o usuário já recusou nesta sessão. Sem isto, recusar o
+    /// convite faria a pergunta voltar dois segundos depois, para sempre.
+    /// </summary>
+    private readonly HashSet<string> _recusados = new(StringComparer.OrdinalIgnoreCase);
+
+    public GameWatcher(
+        IProcessService processos,
+        GameDetector detector,
+        ProfileStore perfis,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _processos = processos;
+        _detector = detector;
+        _perfis = perfis;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public event Action<JogoAbriu>? AoAbrir;
+    public event Action<JogoFechou>? AoFechar;
+
+    public bool Ativo => _thread is { IsAlive: true };
+
+    public DetectedGame? JogoAtual => _atual;
+
+    public void Iniciar()
+    {
+        if (Ativo)
+            return;
+
+        _cts = new CancellationTokenSource();
+
+        // Thread dedicada e de prioridade baixa, como o monitor de gargalos: o
+        // vigia nunca pode disputar CPU com o jogo que ele está vigiando.
+        _thread = new Thread(() => Laco(_cts.Token))
+        {
+            IsBackground = true,
+            Name = "GameBoost.GameWatcher",
+            Priority = ThreadPriority.BelowNormal
+        };
+
+        _thread.Start();
+        _log.Info("profiles", "Watcher", null, "vigia de jogos iniciado");
+    }
+
+    public void Parar()
+    {
+        if (_cts is null && _thread is null)
+            return;
+
+        try
+        {
+            _cts?.Cancel();
+        }
+        catch (ObjectDisposedException)
+        {
+            // Ja foi descartado. Nao e erro: significa que alguem parou antes.
+        }
+
+        _thread?.Join(TimeSpan.FromSeconds(3));
+        _thread = null;
+        _log.Info("profiles", "Watcher", null, "vigia de jogos parado");
+    }
+
+    /// <summary>O usuário disse não para este jogo; não perguntar de novo hoje.</summary>
+    public void Recusar(string executavel) => _recusados.Add(GameProfile.Normalizar(executavel));
+
+    public void EsquecerRecusas() => _recusados.Clear();
+
+    private void Laco(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            try
+            {
+                Verificar();
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+            {
+                _log.Warn("profiles", "Watcher", null, ex.Message);
+            }
+
+            if (ct.WaitHandle.WaitOne(Intervalo))
+                return;
+        }
+    }
+
+    private void Verificar()
+    {
+        var processos = _processos.GetProcesses();
+
+        // O jogo que já estava rodando ainda está?
+        if (_atual is not null)
+        {
+            var aindaVivo = processos.Any(p => p.Pid == _atual.Process.Pid);
+
+            if (!aindaVivo)
+            {
+                var fechado = _atual;
+                var duracao = _relogio.Now - _desde;
+                _atual = null;
+
+                _log.Info("profiles", "Watcher", fechado.Process.Name,
+                    $"jogo saiu depois de {duracao.TotalMinutes:0} min");
+
+                AoFechar?.Invoke(new JogoFechou(
+                    GameProfile.Normalizar(fechado.Process.Name),
+                    fechado.Process.Name,
+                    duracao));
+            }
+            else
+            {
+                // Já há jogo rodando: não procurar outro. Dois jogos ao mesmo
+                // tempo é caso raro, e trocar de perfil no meio seria pior que
+                // ficar no primeiro.
+                return;
+            }
+        }
+
+        var detectado = _detector.Detectar(processos);
+
+        if (detectado is null)
+            return;
+
+        var chave = GameProfile.Normalizar(detectado.Process.Name);
+
+        if (_recusados.Contains(chave))
+            return;
+
+        var telaCheia = Native.WindowInfo.EstaEmTelaCheia(detectado.Process.Pid);
+
+        // A tela cheia é o terceiro critério do spec, e vale como reforço: um
+        // processo pesado com janela ocupando o monitor inteiro é jogo com
+        // muito mais frequência do que é outra coisa.
+        if (detectado.Confianca < 50 && !telaCheia)
+            return;
+
+        _atual = detectado;
+        _desde = _relogio.Now;
+
+        var perfil = _perfis.Buscar(chave);
+
+        _log.Info("profiles", "Watcher", detectado.Process.Name,
+            $"{detectado.Motivo}, confiança {detectado.Confianca}, tela cheia {telaCheia}");
+
+        AoAbrir?.Invoke(new JogoAbriu(detectado, perfil, telaCheia));
+    }
+
+    private bool _descartado;
+
+    /// <summary>
+    /// Idempotente de proposito.
+    ///
+    /// O container de DI descarta todo singleton IDisposable ao ser fechado, e
+    /// o App tambem chamava Dispose aqui por conta propria. Na segunda chamada,
+    /// o `Cancel()` caia num CancellationTokenSource ja descartado e a excecao
+    /// subia ate a caixa de erro — em TODA saida do aplicativo.
+    ///
+    /// Quem escreve Dispose nao controla quantas vezes ele e chamado. A regra e
+    /// aguentar a segunda chamada em silencio.
+    /// </summary>
+    public void Dispose()
+    {
+        if (_descartado)
+            return;
+
+        _descartado = true;
+
+        Parar();
+        _cts?.Dispose();
+        _cts = null;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileRunner.cs b/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileRunner.cs
new file mode 100644
index 0000000..75629cd
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileRunner.cs
@@ -0,0 +1,246 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.Tweaks;
+using GameBoost.Core.Native;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.Profiles;
+
+/// <summary>O que foi aplicado numa sessão de perfil, para poder desfazer.</summary>
+public sealed class SessaoDePerfil
+{
+    public required GameProfile Perfil { get; init; }
+    public required int Pid { get; init; }
+    public DateTimeOffset Inicio { get; init; }
+
+    public ProcessPriority? PrioridadeAnterior { get; set; }
+    public IReadOnlyList<int> AfinidadeAnterior { get; set; } = Array.Empty<int>();
+    public bool TimerAlterado { get; set; }
+    public List<string> ChangeIds { get; } = new();
+    public List<string> Aplicado { get; } = new();
+}
+
+/// <summary>
+/// Aplica e desfaz um perfil de jogo (seção 5.11).
+///
+/// A regra que rege esta classe: **tudo que entra tem que sair.** Cada coisa
+/// aplicada guarda o valor anterior antes, e a saída percorre a lista de trás
+/// para frente. Se o jogo fecha e algo falha ao reverter, o resto continua
+/// sendo revertido — um erro no timer não pode deixar a prioridade alterada
+/// para sempre.
+/// </summary>
+public sealed class ProfileRunner
+{
+    private readonly IProcessService _processos;
+    private readonly TweaksModule _tweaks;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    public ProfileRunner(
+        IProcessService processos,
+        TweaksModule tweaks,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _processos = processos;
+        _tweaks = tweaks;
+        _backup = backup;
+        _rollback = rollback;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public SessaoDePerfil? Atual { get; private set; }
+
+    public bool EmSessao => Atual is not null;
+
+    // ==================================================================
+    // Entrar
+    // ==================================================================
+
+    public SessaoDePerfil Aplicar(GameProfile perfil, int pid)
+    {
+        if (Atual is not null)
+        {
+            _log.Warn("profiles", "Aplicar", perfil.Nome,
+                "já havia sessão aberta; a anterior é desfeita antes");
+            Desfazer();
+        }
+
+        var sessao = new SessaoDePerfil
+        {
+            Perfil = perfil,
+            Pid = pid,
+            Inicio = _relogio.Now
+        };
+
+        AplicarPrioridade(sessao);
+        AplicarAfinidade(sessao);
+        AplicarTimer(sessao);
+        AplicarTweaks(sessao);
+
+        Atual = sessao;
+
+        perfil.UltimaVez = _relogio.Now;
+        perfil.VezesUsado++;
+
+        _log.Info("profiles", "Aplicar", perfil.Nome,
+            sessao.Aplicado.Count == 0 ? "nada a aplicar" : string.Join(", ", sessao.Aplicado));
+
+        return sessao;
+    }
+
+    private void AplicarPrioridade(SessaoDePerfil sessao)
+    {
+        var alvo = sessao.Perfil.Prioridade;
+
+        if (alvo is null or ProcessPriority.Normal)
+            return;
+
+        sessao.PrioridadeAnterior = _processos.GetPriority(sessao.Pid);
+
+        if (_processos.SetPriority(sessao.Pid, alvo.Value))
+            sessao.Aplicado.Add($"prioridade {GameProfile.TextoDaPrioridade(alvo.Value)}");
+    }
+
+    private void AplicarAfinidade(SessaoDePerfil sessao)
+    {
+        if (sessao.Perfil.Afinidade.Count == 0)
+            return;
+
+        sessao.AfinidadeAnterior = _processos.GetAffinity(sessao.Pid);
+
+        if (_processos.SetAffinity(sessao.Pid, sessao.Perfil.Afinidade))
+            sessao.Aplicado.Add($"{sessao.Perfil.Afinidade.Count} núcleos reservados");
+    }
+
+    /// <summary>
+    /// Resolução de timer em 0,5 ms.
+    ///
+    /// Vale muito menos do que a internet promete. Desde o Windows 10 2004 o
+    /// pedido é **por processo**, não global: o GameBoost pedir 0,5 ms afeta o
+    /// GameBoost, não o jogo. O que ainda acontece é o sistema honrar a menor
+    /// resolução pedida por alguém para temporizadores globais, e é daí que vem
+    /// o ganho residual no Windows 10.
+    ///
+    /// Por isso fica desligado por padrão e o texto na tela não promete FPS.
+    /// </summary>
+    private void AplicarTimer(SessaoDePerfil sessao)
+    {
+        if (!sessao.Perfil.TimerDeMeioMilissegundo)
+            return;
+
+        // 5000 unidades de 100 ns = 0,5 ms.
+        if (NativeMethodsBridge.SetTimerResolution(5000, out var atual))
+        {
+            sessao.TimerAlterado = true;
+            sessao.Aplicado.Add($"timer em {atual / 10000.0:0.0} ms");
+
+            _backup.Registrar(new ChangeRecord
+            {
+                Modulo = "profiles",
+                Tipo = ChangeType.TimerResolution,
+                Alvo = "timer",
+                ValorAnterior = "padrão do sistema",
+                ValorNovo = "0,5 ms",
+                Extras = { ["nome"] = $"Timer de 0,5 ms para {sessao.Perfil.Nome}" }
+            });
+        }
+    }
+
+    private void AplicarTweaks(SessaoDePerfil sessao)
+    {
+        var ligar = sessao.Perfil.Tweaks.Where(t => t.Ligar).Select(t => "tweak:" + t.Id).ToList();
+
+        if (ligar.Count == 0)
+            return;
+
+        // Os ChangeRecord são criados pelo próprio TweaksModule. O que fica
+        // guardado aqui são os ids, para desfazer só o que este perfil ligou.
+        var antes = _backup.Pendentes.Select(r => r.Id).ToHashSet(StringComparer.Ordinal);
+
+        var resultado = _tweaks.ApplyAsync(ligar, dryRun: false, CancellationToken.None)
+            .GetAwaiter().GetResult();
+
+        foreach (var registro in _backup.Pendentes.Where(r => !antes.Contains(r.Id)))
+            sessao.ChangeIds.Add(registro.Id);
+
+        if (resultado.Sucessos > 0)
+            sessao.Aplicado.Add($"{resultado.Sucessos} tweaks");
+    }
+
+    // ==================================================================
+    // Sair
+    // ==================================================================
+
+    /// <summary>
+    /// Desfaz tudo o que a sessão aplicou, na ordem inversa.
+    ///
+    /// Cada passo é independente: uma falha não interrompe os seguintes. É o
+    /// mesmo princípio do RollbackEngine, e pelo mesmo motivo — o pior estado
+    /// possível é aquele em que metade das alterações ficou de pé.
+    /// </summary>
+    public IReadOnlyList<string> Desfazer()
+    {
+        var sessao = Atual;
+
+        if (sessao is null)
+            return Array.Empty<string>();
+
+        Atual = null;
+
+        var feitos = new List<string>();
+
+        if (sessao.ChangeIds.Count > 0)
+        {
+            try
+            {
+                var voltas = _rollback.Reverter(sessao.ChangeIds, dryRun: false);
+                feitos.Add($"{voltas.Count(v => v.Sucesso)} tweaks revertidos");
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or IOException)
+            {
+                _log.Error("profiles", "Desfazer", "tweaks", ex.Message, ex);
+            }
+        }
+
+        if (sessao.TimerAlterado)
+        {
+            try
+            {
+                if (NativeMethodsBridge.RestoreTimerResolution(5000, out _))
+                    feitos.Add("timer devolvido ao padrão");
+            }
+            catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException)
+            {
+                _log.Warn("profiles", "Desfazer", "timer", ex.Message);
+            }
+        }
+
+        // Prioridade e afinidade só valem se o processo ainda existir. Quando o
+        // jogo já fechou, não há o que restaurar — e é o caso normal.
+        if (_processos.GetProcess(sessao.Pid) is not null)
+        {
+            if (sessao.AfinidadeAnterior.Count > 0)
+            {
+                _processos.SetAffinity(sessao.Pid, sessao.AfinidadeAnterior);
+                feitos.Add("afinidade restaurada");
+            }
+
+            if (sessao.PrioridadeAnterior is not null)
+            {
+                _processos.SetPriority(sessao.Pid, sessao.PrioridadeAnterior.Value);
+                feitos.Add("prioridade restaurada");
+            }
+        }
+
+        _log.Info("profiles", "Desfazer", sessao.Perfil.Nome,
+            feitos.Count == 0 ? "nada a desfazer" : string.Join(", ", feitos));
+
+        return feitos;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileStore.cs b/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileStore.cs
new file mode 100644
index 0000000..127eade
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Profiles/ProfileStore.cs
@@ -0,0 +1,151 @@
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Profiles;
+
+/// <summary>
+/// Perfis em `profiles/*.json`, um arquivo por jogo (seção 7).
+///
+/// Um arquivo por perfil, e não um só com todos: perfil corrompido derruba
+/// aquele jogo, não a coleção inteira. É o mesmo motivo de o `state-backup.json`
+/// ser separado do `settings.json`.
+/// </summary>
+public sealed class ProfileStore
+{
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+
+    private readonly Dictionary<string, GameProfile> _perfis = new(StringComparer.OrdinalIgnoreCase);
+    private bool _carregado;
+
+    public ProfileStore(AppPaths paths, IFileSystem fs, IGameBoostLogger log)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+    }
+
+    public IReadOnlyCollection<GameProfile> Todos
+    {
+        get
+        {
+            Carregar();
+            return _perfis.Values.OrderByDescending(p => p.UltimaVez ?? DateTimeOffset.MinValue).ToList();
+        }
+    }
+
+    public GameProfile? Buscar(string executavel)
+    {
+        Carregar();
+        return _perfis.GetValueOrDefault(GameProfile.Normalizar(executavel));
+    }
+
+    public void Salvar(GameProfile perfil)
+    {
+        Carregar();
+
+        perfil.Executavel = GameProfile.Normalizar(perfil.Executavel);
+
+        if (perfil.Executavel.Length == 0)
+        {
+            _log.Warn("profiles", "Salvar", perfil.Nome, "perfil sem executável, ignorado");
+            return;
+        }
+
+        _perfis[perfil.Executavel] = perfil;
+
+        try
+        {
+            Directory.CreateDirectory(_paths.ProfilesDirectory);
+
+            _fs.WriteAllText(
+                Arquivo(perfil.Executavel),
+                JsonSerializer.Serialize(perfil, new JsonSerializerOptions { WriteIndented = true }));
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _log.Error("profiles", "Salvar", perfil.Executavel, ex.Message, ex);
+        }
+    }
+
+    public void Remover(string executavel)
+    {
+        Carregar();
+
+        var chave = GameProfile.Normalizar(executavel);
+        _perfis.Remove(chave);
+
+        try
+        {
+            var arquivo = Arquivo(chave);
+
+            if (_fs.FileExists(arquivo))
+                File.Delete(arquivo);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _log.Warn("profiles", "Remover", chave, ex.Message);
+        }
+    }
+
+    public void Recarregar()
+    {
+        _carregado = false;
+        _perfis.Clear();
+        Carregar();
+    }
+
+    private string Arquivo(string executavel)
+    {
+        // O nome do executável vira nome de arquivo, então tudo que não for
+        // letra, número, ponto, hífen ou sublinhado sai. Um jogo chamado
+        // "cs:go" não pode virar um caminho inválido.
+        var limpo = new string(executavel
+            .Select(c => char.IsLetterOrDigit(c) || c is '.' or '-' or '_' ? c : '_')
+            .ToArray());
+
+        return Path.Combine(_paths.ProfilesDirectory, limpo + ".json");
+    }
+
+    private void Carregar()
+    {
+        if (_carregado)
+            return;
+
+        _carregado = true;
+
+        try
+        {
+            if (!Directory.Exists(_paths.ProfilesDirectory))
+                return;
+
+            foreach (var arquivo in Directory.EnumerateFiles(_paths.ProfilesDirectory, "*.json"))
+            {
+                try
+                {
+                    var perfil = JsonSerializer.Deserialize<GameProfile>(_fs.ReadAllText(arquivo));
+
+                    if (perfil is null || perfil.Executavel.Length == 0)
+                        continue;
+
+                    _perfis[GameProfile.Normalizar(perfil.Executavel)] = perfil;
+                }
+                catch (JsonException ex)
+                {
+                    // Um perfil quebrado não impede os outros de carregar. O
+                    // arquivo fica onde está para o usuário poder olhar.
+                    _log.Warn("profiles", "Carregar", Path.GetFileName(arquivo), $"JSON inválido: {ex.Message}");
+                }
+            }
+
+            _log.Info("profiles", "Carregar", null, $"{_perfis.Count} perfis");
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _log.Error("profiles", "Carregar", null, ex.Message, ex);
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/RiskLevel.cs b/GameBoost/src/GameBoost.Core/Modules/RiskLevel.cs
new file mode 100644
index 0000000..be14636
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/RiskLevel.cs
@@ -0,0 +1,9 @@
+namespace GameBoost.Core.Modules;
+
+/// <summary>Badge de risco mostrado na UI: verde, amarelo, vermelho.</summary>
+public enum RiskLevel
+{
+    Baixo,
+    Medio,
+    Alto
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Startup/StartupEntry.cs b/GameBoost/src/GameBoost.Core/Modules/Startup/StartupEntry.cs
new file mode 100644
index 0000000..c46fabe
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Startup/StartupEntry.cs
@@ -0,0 +1,70 @@
+namespace GameBoost.Core.Modules.Startup;
+
+public enum StartupOrigem
+{
+    /// <summary>Chave Run do registro, do usuário ou da máquina.</summary>
+    Registro,
+
+    /// <summary>Atalho na pasta Inicializar.</summary>
+    Pasta,
+
+    /// <summary>Tarefa agendada com gatilho de logon.</summary>
+    Tarefa
+}
+
+public enum ImpactoNoBoot
+{
+    Desconhecido,
+    Baixo,
+    Medio,
+    Alto
+}
+
+/// <summary>Um programa que abre junto com o Windows (seção 5.6).</summary>
+public sealed record StartupEntry
+{
+    public required string Id { get; init; }
+    public required string Nome { get; init; }
+    public required StartupOrigem Origem { get; init; }
+
+    /// <summary>Onde mora: caminho da chave, do atalho ou da tarefa.</summary>
+    public required string Local { get; init; }
+
+    public string? Comando { get; init; }
+    public string? Executavel { get; init; }
+    public string? Publisher { get; init; }
+
+    public bool Ativo { get; set; } = true;
+
+    /// <summary>
+    /// True assinado, false sem assinatura, <c>null</c> quando nao deu para
+    /// verificar. O Teams mora em WindowsApps, onde nem o administrador le o
+    /// arquivo: dizer "sem assinatura digital" ali seria acusacao falsa.
+    /// </summary>
+    public bool? Assinado { get; init; }
+    public long TamanhoDoExecutavel { get; init; }
+
+    public ImpactoNoBoot Impacto { get; init; } = ImpactoNoBoot.Desconhecido;
+
+    public bool Protegido { get; set; }
+    public string? MotivoDaProtecao { get; set; }
+
+    /// <summary>Candidato óbvio a desativar, mas nunca pré-marcado (regra 3).</summary>
+    public bool Sugerido { get; set; }
+
+    public string TextoDoImpacto => Impacto switch
+    {
+        ImpactoNoBoot.Alto => "impacto alto no boot",
+        ImpactoNoBoot.Medio => "impacto médio no boot",
+        ImpactoNoBoot.Baixo => "impacto baixo no boot",
+        _ => "impacto desconhecido"
+    };
+
+    public string TextoDaOrigem => Origem switch
+    {
+        StartupOrigem.Registro => "registro",
+        StartupOrigem.Pasta => "pasta Inicializar",
+        StartupOrigem.Tarefa => "tarefa agendada",
+        _ => "desconhecido"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Startup/StartupModule.cs b/GameBoost/src/GameBoost.Core/Modules/Startup/StartupModule.cs
new file mode 100644
index 0000000..84787c2
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Startup/StartupModule.cs
@@ -0,0 +1,576 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Native;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.Startup;
+
+/// <summary>
+/// Gerenciador de inicialização (seção 5.6).
+///
+/// Desativar grava no `StartupApproved` **no mesmo formato do Gerenciador de
+/// Tarefas**: assim o Windows mostra o item como desativado nos dois lugares, e
+/// o usuário pode reverter por onde preferir. Escrever de outro jeito deixaria
+/// o Gerenciador de Tarefas mentindo.
+/// </summary>
+public sealed class StartupModule : IModule
+{
+    public const string ModuloId = "startup";
+
+    private const string RunUsuario = @"Software\Microsoft\Windows\CurrentVersion\Run";
+    private const string RunMaquina = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Run";
+    private const string RunMaquina32 = @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run";
+
+    private const string AprovadoUsuarioRun = @"Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run";
+    private const string AprovadoUsuarioPasta = @"Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder";
+
+    private readonly IRegistryService _registro;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    private IReadOnlyList<StartupEntry> _ultimaLista = Array.Empty<StartupEntry>();
+
+    public StartupModule(
+        IRegistryService registro,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _registro = registro;
+        _backup = backup;
+        _rollback = rollback;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Inicialização";
+    public string Descricao => "O que abre junto com o Windows, e quanto isso pesa no boot.";
+
+    // ---------------- Proteção ----------------
+
+    /// <summary>Nunca desativar: tira áudio, rede, acessibilidade ou proteção.</summary>
+    private static readonly (string Trecho, string Motivo)[] Intocaveis =
+    {
+        ("securityhealth", "É a Segurança do Windows."),
+        ("windows defender", "É o antivírus do Windows."),
+        ("realtek", "Driver de áudio: desativar pode tirar o som."),
+        ("audio", "Componente de áudio: desativar pode tirar o som."),
+        ("synaptics", "Driver do touchpad: desativar pode travar o touchpad."),
+        ("elan", "Driver do touchpad."),
+        ("touchpad", "Driver do touchpad."),
+        ("bluetooth", "Driver de Bluetooth: desativar derruba mouse e fone sem fio."),
+        ("intel(r) graphics", "Componente do driver de vídeo."),
+        ("nvidia", "Componente do driver de vídeo."),
+        ("amd", "Componente do driver de vídeo."),
+        ("kaspersky", "É o seu antivírus."),
+        ("avast", "É o seu antivírus."),
+        ("bitdefender", "É o seu antivírus."),
+        ("mcafee", "É o seu antivírus."),
+        ("norton", "É o seu antivírus."),
+        ("eset", "É o seu antivírus."),
+        ("narrator", "Recurso de acessibilidade."),
+        ("magnify", "Recurso de acessibilidade.")
+    };
+
+    /// <summary>Sugestões da seção 5.6: aparecem com dica, nunca marcadas.</summary>
+    private static readonly string[] Sugeridos =
+    {
+        "spotify", "discord", "steam", "epic", "ea app", "origin", "ubisoft",
+        "teams", "skype", "adobe", "acrobat", "itunes", "icloud", "cortana",
+        "onedrive", "dropbox", "zoom", "slack", "java update", "quicktime",
+        "wildtangent", "ccleaner", "utorrent", "qbittorrent"
+    };
+
+    // ---------------- Varredura ----------------
+
+    public Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+        => Task.Run(() => Varrer(progress, ct), ct);
+
+    private ScanResult Varrer(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        var entradas = new List<StartupEntry>();
+
+        progress?.Report(new ModuleProgress("Lendo o registro", 20));
+        entradas.AddRange(DoRegistro(RegistryRoot.CurrentUser, RunUsuario, "HKCU"));
+        entradas.AddRange(DoRegistro(RegistryRoot.LocalMachine, RunMaquina, "HKLM"));
+        entradas.AddRange(DoRegistro(RegistryRoot.LocalMachine, RunMaquina32, "HKLM32"));
+
+        progress?.Report(new ModuleProgress("Lendo a pasta Inicializar", 50));
+        entradas.AddRange(DaPasta(Environment.SpecialFolder.Startup, "usuário"));
+        entradas.AddRange(DaPasta(Environment.SpecialFolder.CommonStartup, "todos os usuários"));
+
+        progress?.Report(new ModuleProgress("Conferindo o que está desativado", 70));
+        AplicarEstado(entradas);
+
+        foreach (var entrada in entradas)
+        {
+            ct.ThrowIfCancellationRequested();
+            Avaliar(entrada);
+        }
+
+        _ultimaLista = entradas;
+
+        var ativos = entradas.Count(e => e.Ativo);
+        var estimativa = EstimarSegundos(entradas.Where(e => e.Ativo));
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = entradas.Select(MontarItem).ToList(),
+            Momento = _relogio.Now,
+            Resumo = $"{ativos} programas abrem com o Windows, de {entradas.Count} registrados. "
+                   + $"Estimativa grosseira: cerca de {estimativa} segundos a mais no boot.",
+            Avisos = new[]
+            {
+                "A estimativa de tempo é grosseira: vem do tamanho do executável, não de "
+              + "medição real do boot. Serve para comparar itens entre si, não como número absoluto."
+            }
+        };
+    }
+
+    private IEnumerable<StartupEntry> DoRegistro(RegistryRoot raiz, string chave, string rotulo)
+    {
+        IReadOnlyList<string> valores;
+
+        try
+        {
+            valores = _registro.GetValueNames(raiz, chave);
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or System.Security.SecurityException)
+        {
+            _log.Warn(ModuloId, "Registro", chave, ex.Message);
+            yield break;
+        }
+
+        foreach (var nome in valores)
+        {
+            var comando = _registro.GetValue(raiz, chave, nome) as string;
+
+            if (string.IsNullOrWhiteSpace(comando))
+                continue;
+
+            var executavel = ExtrairExecutavel(comando);
+
+            // Uma chamada só: WinVerifyTrust não é barato e antes rodava duas
+            // vezes por entrada.
+            var assinatura = Assinatura(executavel);
+
+            yield return new StartupEntry
+            {
+                Id = $"reg:{rotulo}:{nome}",
+                Nome = nome,
+                Origem = StartupOrigem.Registro,
+                Local = $"{rotulo}\\...\\Run",
+                Comando = comando,
+                Executavel = executavel,
+                Publisher = assinatura.Publisher,
+                Assinado = assinatura.Assinado,
+                TamanhoDoExecutavel = Tamanho(executavel),
+                Impacto = Estimar(executavel)
+            };
+        }
+    }
+
+    private IEnumerable<StartupEntry> DaPasta(Environment.SpecialFolder pasta, string rotulo)
+    {
+        var caminho = Environment.GetFolderPath(pasta);
+
+        if (string.IsNullOrWhiteSpace(caminho) || !Directory.Exists(caminho))
+            yield break;
+
+        foreach (var arquivo in Directory.EnumerateFiles(caminho))
+        {
+            if (arquivo.EndsWith(".ini", StringComparison.OrdinalIgnoreCase))
+                continue;
+
+            var nome = Path.GetFileNameWithoutExtension(arquivo);
+
+            yield return new StartupEntry
+            {
+                Id = $"pasta:{rotulo}:{Path.GetFileName(arquivo)}",
+                Nome = nome,
+                Origem = StartupOrigem.Pasta,
+                Local = $"Inicializar ({rotulo})",
+                Comando = arquivo,
+                Executavel = arquivo,
+                TamanhoDoExecutavel = Tamanho(arquivo),
+                Impacto = ImpactoNoBoot.Medio
+            };
+        }
+    }
+
+    /// <summary>
+    /// Lê o StartupApproved para saber o que já está desativado. O primeiro
+    /// byte diz o estado: valores ímpares e 2 significam ativo; 3 significa
+    /// desativado pelo usuário.
+    /// </summary>
+    private void AplicarEstado(List<StartupEntry> entradas)
+    {
+        foreach (var (chave, origem) in new[]
+                 {
+                     (AprovadoUsuarioRun, StartupOrigem.Registro),
+                     (AprovadoUsuarioPasta, StartupOrigem.Pasta)
+                 })
+        {
+            IReadOnlyList<string> nomes;
+
+            try
+            {
+                nomes = _registro.GetValueNames(RegistryRoot.CurrentUser, chave);
+            }
+            catch (Exception ex) when (ex is UnauthorizedAccessException or System.Security.SecurityException)
+            {
+                continue;
+            }
+
+            foreach (var nome in nomes)
+            {
+                if (_registro.GetValue(RegistryRoot.CurrentUser, chave, nome) is not byte[] dados || dados.Length == 0)
+                    continue;
+
+                var desativado = (dados[0] & 0x01) != 0 && dados[0] != 0x02;
+
+                foreach (var entrada in entradas.Where(e =>
+                             e.Origem == origem
+                             && (e.Nome.Equals(nome, StringComparison.OrdinalIgnoreCase)
+                                 || e.Id.EndsWith(nome, StringComparison.OrdinalIgnoreCase))))
+                {
+                    entrada.Ativo = !desativado;
+                }
+            }
+        }
+    }
+
+    private static void Avaliar(StartupEntry entrada)
+    {
+        var texto = $"{entrada.Nome} {entrada.Executavel} {entrada.Publisher}".ToLowerInvariant();
+
+        foreach (var (trecho, motivo) in Intocaveis)
+        {
+            if (texto.Contains(trecho, StringComparison.Ordinal))
+            {
+                entrada.Protegido = true;
+                entrada.MotivoDaProtecao = motivo;
+                return;
+            }
+        }
+
+        entrada.Sugerido = Sugeridos.Any(s => texto.Contains(s, StringComparison.Ordinal));
+    }
+
+    private ActionItem MontarItem(StartupEntry e)
+    {
+        // O impacto já aparece na coluna da direita; repetir aqui só poluía a
+        // linha.
+        var detalhes = new List<string> { e.TextoDaOrigem };
+
+        if (!e.Ativo)
+            detalhes.Insert(0, "já desativado");
+
+        if (e.Publisher is not null)
+            detalhes.Add(e.Publisher);
+        else if (EhExecutavel(e.Executavel))
+        {
+            // Atalho da pasta Inicializar aponta para outro lugar e nunca é
+            // assinado: falar de assinatura dele não diria nada sobre o programa.
+            detalhes.Add(e.Assinado == false
+                ? "sem assinatura digital"
+                : "assinatura não verificável");
+        }
+
+        return new ActionItem
+        {
+            Id = $"startup:{e.Id}",
+            Categoria = e.Protegido ? "Protegidos"
+                : !e.Ativo ? "Já desativados"
+                : e.Sugerido ? "Sugestões"
+                : "Ativos",
+            Titulo = e.Nome,
+            Descricao = string.Join(" · ", detalhes)
+                      + (e.Comando is not null ? $" · {e.Comando}" : string.Empty),
+            Risco = e.Protegido ? RiskLevel.Alto : e.Sugerido ? RiskLevel.Baixo : RiskLevel.Medio,
+            GanhoBytes = 0,
+            GanhoEstimado = e.Ativo ? e.TextoDoImpacto : "já desativado",
+
+            // Regra 3: o usuário decide o que abre com a máquina dele.
+            PreMarcado = false,
+
+            Bloqueado = e.Protegido || !e.Ativo,
+            MotivoBloqueio = e.Protegido ? e.MotivoDaProtecao
+                : !e.Ativo ? "Já está desativado."
+                : null,
+            ComoDesfazer = "Reativar pelo próprio GameBoost, pelo Gerenciador de Tarefas "
+                         + "ou em Configurações, Aplicativos, Inicializar. O programa continua "
+                         + "instalado: só deixa de abrir sozinho.",
+            Payload = e
+        };
+    }
+
+    // ---------------- Estimativa ----------------
+
+    /// <summary>
+    /// Estimativa pelo tamanho do executável. A seção 5.6 pede isso
+    /// explicitamente como aproximação, e o resumo avisa que é grosseira:
+    /// medir boot de verdade exigiria o Windows Performance Toolkit.
+    /// </summary>
+    private static ImpactoNoBoot Estimar(string? executavel)
+    {
+        var tamanho = Tamanho(executavel);
+
+        return tamanho switch
+        {
+            0 => ImpactoNoBoot.Desconhecido,
+            > 50L * 1024 * 1024 => ImpactoNoBoot.Alto,
+            > 5L * 1024 * 1024 => ImpactoNoBoot.Medio,
+            _ => ImpactoNoBoot.Baixo
+        };
+    }
+
+    private static int EstimarSegundos(IEnumerable<StartupEntry> ativos)
+        => ativos.Sum(e => e.Impacto switch
+        {
+            ImpactoNoBoot.Alto => 3,
+            ImpactoNoBoot.Medio => 1,
+            _ => 0
+        });
+
+    private static long Tamanho(string? executavel)
+    {
+        if (string.IsNullOrWhiteSpace(executavel))
+            return 0;
+
+        try
+        {
+            var info = new FileInfo(executavel);
+            return info.Exists ? info.Length : 0;
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
+        {
+            return 0;
+        }
+    }
+
+    private static bool EhExecutavel(string? caminho)
+        => caminho is not null && caminho.EndsWith(".exe", StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Assinatura e fabricante numa passada. Devolve <c>null</c> em Assinado
+    /// quando o comando aponta para um arquivo que não pode ser lido — caso
+    /// típico de app da Store em WindowsApps, cuja ACL barra até o
+    /// administrador. Dizer "sem assinatura digital" ali seria acusação falsa.
+    /// </summary>
+    private static (bool? Assinado, string? Publisher) Assinatura(string? executavel)
+    {
+        if (string.IsNullOrWhiteSpace(executavel) || !File.Exists(executavel))
+            return (null, null);
+
+        return (Authenticode.Assinado(executavel), Authenticode.Fabricante(executavel));
+    }
+
+    internal static string? ExtrairExecutavel(string comando)
+    {
+        var texto = comando.Trim();
+
+        if (texto.StartsWith('"'))
+        {
+            var fim = texto.IndexOf('"', 1);
+            return fim > 0 ? texto[1..fim] : null;
+        }
+
+        var indice = texto.IndexOf(".exe", StringComparison.OrdinalIgnoreCase);
+        return indice > 0 ? texto[..(indice + 4)] : null;
+    }
+
+    // ---------------- Desativar e reativar ----------------
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Alternar(itemIds, desativar: true, dryRun), ct);
+
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Reverter(changeIds, dryRun), ct);
+
+    private ApplyResult Alternar(IReadOnlyList<string> itemIds, bool desativar, bool dryRun)
+    {
+        var acoes = new List<AppliedAction>();
+
+        foreach (var itemId in itemIds)
+        {
+            var id = itemId.StartsWith("startup:", StringComparison.Ordinal) ? itemId[8..] : itemId;
+            var entrada = _ultimaLista.FirstOrDefault(e => e.Id == id);
+
+            if (entrada is null)
+            {
+                acoes.Add(new AppliedAction(itemId, false, "Item não encontrado: varra de novo.", null));
+                continue;
+            }
+
+            if (entrada.Protegido)
+            {
+                acoes.Add(new AppliedAction(itemId, false,
+                    $"{entrada.Nome} está protegido: {entrada.MotivoDaProtecao}", null));
+                continue;
+            }
+
+            if (dryRun)
+            {
+                acoes.Add(new AppliedAction(itemId, true,
+                    $"{(desativar ? "Desativaria" : "Reativaria")} {entrada.Nome}.", null));
+                continue;
+            }
+
+            acoes.Add(Gravar(entrada, desativar, itemId));
+        }
+
+        var mudados = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? "Simulação concluída. Nada foi alterado."
+                : $"{mudados} itens {(desativar ? "desativados" : "reativados")}.",
+            GanhoMedido = dryRun || mudados == 0
+                ? string.Empty
+                : "O efeito aparece no próximo boot. Os programas continuam instalados."
+        };
+    }
+
+    private AppliedAction Gravar(StartupEntry entrada, bool desativar, string itemId)
+    {
+        var chave = entrada.Origem == StartupOrigem.Pasta ? AprovadoUsuarioPasta : AprovadoUsuarioRun;
+        var nome = entrada.Origem == StartupOrigem.Pasta
+            ? entrada.Id.Split(':').Last()
+            : entrada.Nome;
+
+        try
+        {
+            var anterior = _registro.GetValue(RegistryRoot.CurrentUser, chave, nome) as byte[];
+
+            // Formato do Gerenciador de Tarefas: 12 bytes, primeiro byte com o
+            // estado e os 8 últimos com o FILETIME da mudança.
+            var valor = new byte[12];
+
+            if (anterior is { Length: 12 })
+                Array.Copy(anterior, valor, 12);
+
+            valor[0] = desativar ? (byte)0x03 : (byte)0x02;
+            BitConverter.GetBytes(DateTime.UtcNow.ToFileTimeUtc()).CopyTo(valor, 4);
+
+            _backup.Registrar(new ChangeRecord
+            {
+                Modulo = ModuloId,
+                Tipo = ChangeType.Startup,
+                Alvo = chave,
+                SubAlvo = nome,
+                ValorAnterior = anterior is null ? null : Convert.ToHexString(anterior),
+                ValorNovo = Convert.ToHexString(valor),
+                ValorAnteriorExistia = anterior is not null,
+                Extras =
+                {
+                    ["root"] = RegistryRoot.CurrentUser.ToString(),
+                    ["kind"] = RegistryValueKindLite.Binary.ToString(),
+                    ["nome"] = $"Inicialização: {entrada.Nome}"
+                }
+            });
+
+            _registro.SetValue(RegistryRoot.CurrentUser, chave, nome, valor, RegistryValueKindLite.Binary);
+            entrada.Ativo = !desativar;
+
+            _log.Info(ModuloId, desativar ? "Desativar" : "Reativar", entrada.Nome, "gravado em StartupApproved");
+
+            return new AppliedAction(itemId, true,
+                $"{entrada.Nome} {(desativar ? "não abre mais" : "volta a abrir")} com o Windows.", null);
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or System.Security.SecurityException or IOException)
+        {
+            _log.Error(ModuloId, "Gravar", entrada.Nome, ex.Message, ex);
+            return new AppliedAction(itemId, false, $"{entrada.Nome}: {ex.Message}", null);
+        }
+    }
+
+    /// <summary>
+    /// Desfaz pelo ChangeRecord, e não por nome.
+    ///
+    /// A primeira versão recebia os ids que a tela manda — que são **GUIDs de
+    /// ChangeRecord** — e tentava casá-los com o nome do programa
+    /// (`id.Contains(e.Nome)`). Um GUID nunca contém "WallpaperEngine", então a
+    /// lista de alvos saía vazia, nada era desfeito, e o método **devolvia
+    /// sucesso**: a tela dizia "Pronto" e o item continuava desativado.
+    ///
+    /// Além de errado, aquilo dependia de `_ultimaLista` estar preenchida —
+    /// ou seja, de alguém ter varrido nesta sessão. Reabrir o app e clicar em
+    /// Reverter não funcionaria nem com o casamento certo.
+    ///
+    /// O ChangeRecord já carrega tudo o que a reversão precisa: a chave, o nome
+    /// do valor, o conteúdo anterior e se ele existia. É o que o
+    /// <see cref="IRollbackEngine"/> consome, e é o mesmo caminho que os Tweaks
+    /// usam.
+    /// </summary>
+    private ApplyResult Reverter(IReadOnlyList<string> changeIds, bool dryRun)
+    {
+        var pendentes = _backup.Pendentes.Where(r => r.Modulo == ModuloId).ToList();
+
+        var alvos = changeIds.Count > 0
+            ? pendentes.Where(r => changeIds.Contains(r.Id)).Select(r => r.Id).ToList()
+            : pendentes.Select(r => r.Id).ToList();
+
+        if (alvos.Count == 0)
+        {
+            return new ApplyResult
+            {
+                ModuloId = ModuloId,
+                DryRun = dryRun,
+                Resumo = "Não há item de inicialização para reativar."
+            };
+        }
+
+        var resultados = _rollback.Reverter(alvos, dryRun);
+
+        var acoes = resultados
+            .Select(r => new AppliedAction(r.ChangeId, r.Sucesso, r.Detalhe, r.ChangeId))
+            .ToList();
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        // A lista em memória tem que acompanhar, senão a tela continua
+        // mostrando "já desativado" no item que acabou de voltar.
+        if (!dryRun && ok > 0)
+        {
+            var nomes = pendentes
+                .Where(r => alvos.Contains(r.Id))
+                .Select(r => r.SubAlvo)
+                .Where(n => n is not null)
+                .ToHashSet(StringComparer.OrdinalIgnoreCase)!;
+
+            foreach (var entrada in _ultimaLista.Where(e => nomes.Contains(e.Nome)))
+                entrada.Ativo = true;
+        }
+
+        _log.Info(ModuloId, dryRun ? "Reverter (dry-run)" : "Reverter", null,
+            $"{ok} de {acoes.Count} itens reativados");
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {ok} de {acoes.Count} programas voltariam a abrir com o Windows."
+                : $"{ok} de {acoes.Count} programas voltam a abrir com o Windows.",
+            GanhoMedido = "O efeito aparece no próximo boot."
+        };
+    }
+
+    /// <summary>Reativa um item específico, pelo botão da lista.</summary>
+    public Task<ApplyResult> ReativarAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Alternar(itemIds, desativar: false, dryRun), ct);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tools/QuickTool.cs b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickTool.cs
new file mode 100644
index 0000000..10c638e
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickTool.cs
@@ -0,0 +1,48 @@
+namespace GameBoost.Core.Modules.Tools;
+
+/// <summary>Onde a ferramenta age.</summary>
+public enum ToolKind
+{
+    /// <summary>Faz algo na máquina e devolve o resultado.</summary>
+    Acao,
+
+    /// <summary>Só abre uma ferramenta do Windows.</summary>
+    Atalho,
+
+    /// <summary>Só lê e devolve texto, sem alterar nada.</summary>
+    Leitura,
+
+    /// <summary>Processo longo, com saída acompanhada ao vivo.</summary>
+    Demorada
+}
+
+/// <summary>
+/// Uma ferramenta rápida da seção 5.13: atalhos para o que normalmente exige
+/// prompt de comando ou caça no Painel de Controle.
+/// </summary>
+public sealed record QuickTool
+{
+    public required string Id { get; init; }
+    public required string Categoria { get; init; }
+    public required string Titulo { get; init; }
+    public required string Descricao { get; init; }
+
+    public ToolKind Tipo { get; init; } = ToolKind.Acao;
+    public RiskLevel Risco { get; init; } = RiskLevel.Baixo;
+    public bool PrecisaAdmin { get; init; }
+
+    /// <summary>Texto do aviso antes de executar. Nulo roda direto.</summary>
+    public string? Confirmacao { get; init; }
+
+    public required string ComoDesfazer { get; init; }
+
+    /// <summary>Quanto tempo costuma levar, para a UI não parecer travada.</summary>
+    public string? Duracao { get; init; }
+}
+
+public sealed record ToolResult(bool Sucesso, string Mensagem, string? Detalhe = null)
+{
+    public static ToolResult Ok(string mensagem, string? detalhe = null) => new(true, mensagem, detalhe);
+
+    public static ToolResult Falha(string mensagem, string? detalhe = null) => new(false, mensagem, detalhe);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsCatalog.cs b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsCatalog.cs
new file mode 100644
index 0000000..adc024a
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsCatalog.cs
@@ -0,0 +1,149 @@
+namespace GameBoost.Core.Modules.Tools;
+
+/// <summary>Catálogo das ferramentas rápidas (seção 5.13).</summary>
+public static class QuickToolsCatalog
+{
+    public const string ReiniciarExplorer = "reiniciar-explorer";
+    public const string ReiniciarVideo = "reiniciar-video";
+    public const string LimparDns = "limpar-dns";
+    public const string EsvaziarLixeira = "esvaziar-lixeira";
+    public const string LimpezaDeDisco = "limpeza-de-disco";
+    public const string PontoDeRestauracao = "ponto-de-restauracao";
+    public const string VerificarIntegridade = "verificar-integridade";
+    public const string RepararImagem = "reparar-imagem";
+    public const string TesteDeDisco = "teste-de-disco";
+    public const string InfoDoSistema = "info-do-sistema";
+
+    public static IReadOnlyList<QuickTool> Todas() => new[]
+    {
+        new QuickTool
+        {
+            Id = ReiniciarExplorer,
+            Categoria = "Interface",
+            Titulo = "Reiniciar o Explorer",
+            Descricao = "Recarrega a barra de tarefas e o menu Iniciar. Resolve barra travada, "
+                      + "ícone sumido e menu que não abre.",
+            ComoDesfazer = "Não é preciso: o Explorer volta sozinho em segundos. "
+                         + "Suas janelas de pasta abertas fecham.",
+            Confirmacao = "A barra de tarefas vai sumir por alguns segundos e as janelas de pasta "
+                        + "abertas serão fechadas. Continuar?"
+        },
+
+        new QuickTool
+        {
+            Id = ReiniciarVideo,
+            Categoria = "Interface",
+            Titulo = "Reiniciar o driver de vídeo",
+            Descricao = "O mesmo que Win+Ctrl+Shift+B. Resolve tela preta, artefato e travamento "
+                      + "de vídeo sem reiniciar o PC.",
+            ComoDesfazer = "Não é preciso: o driver recarrega sozinho.",
+            Confirmacao = "A tela vai piscar e ficar preta por um instante.\n\n"
+                        + "Feche jogos e programas de vídeo antes: alguns não sobrevivem ao "
+                        + "reinício do driver. Continuar?",
+            Risco = RiskLevel.Medio
+        },
+
+        new QuickTool
+        {
+            Id = LimparDns,
+            Categoria = "Rede",
+            Titulo = "Limpar o cache de DNS",
+            Descricao = "Esquece os endereços de sites guardados. Resolve site que não abre "
+                      + "depois de trocar de servidor ou de rede.",
+            ComoDesfazer = "Não é preciso: o cache se refaz sozinho ao navegar."
+        },
+
+        new QuickTool
+        {
+            Id = EsvaziarLixeira,
+            Categoria = "Espaço",
+            Titulo = "Esvaziar a Lixeira",
+            Descricao = "Remove de vez o que está na Lixeira.",
+            ComoDesfazer = "Não há. Depois disso os arquivos não voltam.",
+            Confirmacao = "Os arquivos na Lixeira serão apagados de vez e não poderão ser "
+                        + "recuperados. Continuar?",
+            Risco = RiskLevel.Medio
+        },
+
+        new QuickTool
+        {
+            Id = LimpezaDeDisco,
+            Categoria = "Espaço",
+            Titulo = "Abrir a Limpeza de Disco do Windows",
+            Descricao = "A ferramenta do próprio Windows, que alcança coisas que o GameBoost "
+                      + "não mexe, como instalações anteriores do Windows.",
+            Tipo = ToolKind.Atalho,
+            ComoDesfazer = "O GameBoost só abre a ferramenta. O que acontece lá é decidido por você."
+        },
+
+        new QuickTool
+        {
+            Id = PontoDeRestauracao,
+            Categoria = "Segurança",
+            Titulo = "Criar ponto de restauração",
+            Descricao = "Uma foto do sistema para voltar atrás se algo der errado depois.",
+            PrecisaAdmin = true,
+            Duracao = "costuma levar de 30 segundos a 2 minutos",
+            ComoDesfazer = "O ponto fica salvo. Para usá-lo, abra Restauração do Sistema no Windows.",
+            Confirmacao = "Criar um ponto de restauração agora?\n\n"
+                        + "Por padrão o Windows só aceita um ponto a cada 24 horas: se já houver "
+                        + "um recente, ele pode recusar."
+        },
+
+        new QuickTool
+        {
+            Id = VerificarIntegridade,
+            Categoria = "Segurança",
+            Titulo = "Verificar arquivos do Windows (sfc)",
+            Descricao = "Procura arquivos de sistema corrompidos e repara o que encontrar.",
+            Tipo = ToolKind.Demorada,
+            PrecisaAdmin = true,
+            Duracao = "de 5 a 20 minutos",
+            ComoDesfazer = "Não é preciso: a verificação só repara arquivos do próprio Windows, "
+                         + "e não toca nos seus arquivos.",
+            Confirmacao = "A verificação leva de 5 a 20 minutos e usa bastante disco.\n\n"
+                        + "Não é para rodar antes de jogar. Continuar?"
+        },
+
+        new QuickTool
+        {
+            Id = RepararImagem,
+            Categoria = "Segurança",
+            Titulo = "Reparar a imagem do Windows (DISM)",
+            Descricao = "Conserta a base que o sfc usa para reparar. Vale quando o sfc encontra "
+                      + "erro e não consegue corrigir.",
+            Tipo = ToolKind.Demorada,
+            PrecisaAdmin = true,
+            Duracao = "de 10 a 30 minutos, e usa internet",
+            ComoDesfazer = "Não é preciso.",
+            Confirmacao = "O DISM baixa arquivos do Windows Update e leva de 10 a 30 minutos.\n\n"
+                        + "Rode isto quando o sfc encontrar erro que não consegue corrigir. Continuar?"
+        },
+
+        new QuickTool
+        {
+            Id = TesteDeDisco,
+            Categoria = "Diagnóstico",
+            Titulo = "Testar a velocidade do disco",
+            Descricao = "Mede leitura e escrita sequencial com um arquivo temporário de 1 GB. "
+                      + "Serve para saber se o disco é SSD de verdade e se está saudável.",
+            Tipo = ToolKind.Demorada,
+            Duracao = "de 10 a 60 segundos, conforme o disco",
+            ComoDesfazer = "Não é preciso: o arquivo de teste é apagado no fim, inclusive se o "
+                         + "teste falhar.",
+            Confirmacao = "O teste grava 1 GB temporário no disco do sistema e apaga em seguida.\n\n"
+                        + "Feche programas pesados para a medição não sair distorcida. Continuar?"
+        },
+
+        new QuickTool
+        {
+            Id = InfoDoSistema,
+            Categoria = "Diagnóstico",
+            Titulo = "Informações do sistema",
+            Descricao = "Processador, memória, placa de vídeo, discos e versão do Windows, "
+                      + "num texto pronto para copiar e mandar a quem dá suporte.",
+            Tipo = ToolKind.Leitura,
+            ComoDesfazer = "Não altera nada: só lê."
+        }
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsService.cs b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsService.cs
new file mode 100644
index 0000000..85e63a9
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tools/QuickToolsService.cs
@@ -0,0 +1,467 @@
+using System.Diagnostics;
+using System.Management;
+using System.Text;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.Tools;
+
+/// <summary>
+/// Executa as ferramentas rápidas (seção 5.13).
+///
+/// Não é um IModule: aqui não há lista de ActionItem para marcar, aplicar e
+/// reverter. Forçar o contrato de módulo daria um ApplyAsync que não faz nada e
+/// um RevertAsync que mente.
+/// </summary>
+public sealed class QuickToolsService
+{
+    public const string ModuloId = "tools";
+
+    private readonly IProcessService _processos;
+    private readonly IMemoryService _memoria;
+    private readonly IGameBoostLogger _log;
+
+    public QuickToolsService(IProcessService processos, IMemoryService memoria, IGameBoostLogger log)
+    {
+        _processos = processos;
+        _memoria = memoria;
+        _log = log;
+    }
+
+    public async Task<ToolResult> ExecutarAsync(
+        string id,
+        IProgress<string>? saida,
+        CancellationToken ct)
+    {
+        _log.Info(ModuloId, "Executar", id, "inicio");
+
+        var resultado = id switch
+        {
+            QuickToolsCatalog.ReiniciarExplorer => ReiniciarExplorer(),
+            QuickToolsCatalog.ReiniciarVideo => ReiniciarVideo(),
+            QuickToolsCatalog.LimparDns => LimparDns(),
+            QuickToolsCatalog.EsvaziarLixeira => EsvaziarLixeira(),
+            QuickToolsCatalog.LimpezaDeDisco => AbrirLimpezaDeDisco(),
+            QuickToolsCatalog.PontoDeRestauracao => await Task.Run(CriarPontoDeRestauracao, ct),
+            QuickToolsCatalog.VerificarIntegridade => await RodarAsync("sfc.exe", "/scannow", saida, ct),
+            QuickToolsCatalog.RepararImagem => await RodarAsync("DISM.exe", "/Online /Cleanup-Image /RestoreHealth", saida, ct),
+            QuickToolsCatalog.TesteDeDisco => await Task.Run(() => TestarDisco(saida, ct), ct),
+            QuickToolsCatalog.InfoDoSistema => await Task.Run(ColetarInfo, ct),
+            _ => ToolResult.Falha($"Ferramenta desconhecida: {id}")
+        };
+
+        _log.Log(resultado.Sucesso ? LogLevel.Info : LogLevel.Warn,
+            ModuloId, "Executar", id, resultado.Mensagem);
+
+        return resultado;
+    }
+
+    // ---------------- Interface ----------------
+
+    private ToolResult ReiniciarExplorer()
+    {
+        var explorers = _processos.GetProcesses()
+            .Where(p => p.Name.Equals("explorer", StringComparison.OrdinalIgnoreCase))
+            .ToList();
+
+        if (explorers.Count == 0)
+            return ToolResult.Falha("O Explorer não está em execução.");
+
+        foreach (var p in explorers)
+            _processos.Kill(p.Pid);
+
+        // O Windows costuma reabrir sozinho. Se não reabrir em 3 s, força:
+        // deixar o usuário sem barra de tarefas seria pior que o problema original.
+        Thread.Sleep(3000);
+
+        var voltou = _processos.GetProcesses()
+            .Any(p => p.Name.Equals("explorer", StringComparison.OrdinalIgnoreCase));
+
+        if (!voltou)
+        {
+            var windows = Environment.GetFolderPath(Environment.SpecialFolder.Windows);
+            _processos.Start(Path.Combine(windows, "explorer.exe"), null, windows);
+            Thread.Sleep(1500);
+
+            voltou = _processos.GetProcesses()
+                .Any(p => p.Name.Equals("explorer", StringComparison.OrdinalIgnoreCase));
+        }
+
+        return voltou
+            ? ToolResult.Ok("Explorer reiniciado. A barra de tarefas já deve estar de volta.")
+            : ToolResult.Falha("O Explorer não voltou sozinho. Abra o Gerenciador de Tarefas e "
+                             + "use Arquivo, Executar nova tarefa, explorer.exe.");
+    }
+
+    private ToolResult ReiniciarVideo()
+        => ToolsNative.ReiniciarDriverDeVideo()
+            ? ToolResult.Ok("Pedido enviado. A tela pisca e o driver recarrega em instantes.")
+            : ToolResult.Falha("Não foi possível enviar o atalho. Tente Win+Ctrl+Shift+B pelo teclado.");
+
+    // ---------------- Rede ----------------
+
+    private ToolResult LimparDns()
+        => ToolsNative.LimparCacheDeDns()
+            ? ToolResult.Ok("Cache de DNS limpo.")
+            : ToolResult.Falha("O Windows recusou limpar o cache de DNS.");
+
+    // ---------------- Espaço ----------------
+
+    private ToolResult EsvaziarLixeira()
+    {
+        var (bytes, itens) = RecycleBinBridge.Consultar();
+
+        if (itens == 0)
+            return ToolResult.Ok("A Lixeira já está vazia.");
+
+        return RecycleBinBridge.Esvaziar()
+            ? ToolResult.Ok($"Lixeira esvaziada: {GameModeModule.Formatar(bytes)} em {itens} itens.")
+            : ToolResult.Falha("O Windows recusou esvaziar a Lixeira.");
+    }
+
+    private ToolResult AbrirLimpezaDeDisco()
+    {
+        try
+        {
+            var windows = Environment.GetFolderPath(Environment.SpecialFolder.System);
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = Path.Combine(windows, "cleanmgr.exe"),
+                UseShellExecute = true
+            });
+
+            return ToolResult.Ok("Limpeza de Disco aberta. O que acontece lá é decisão sua.");
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or FileNotFoundException)
+        {
+            return ToolResult.Falha($"Não foi possível abrir a Limpeza de Disco: {ex.Message}");
+        }
+    }
+
+    // ---------------- Segurança ----------------
+
+    /// <summary>
+    /// Ponto de restauração via WMI, e não via Checkpoint-Computer do
+    /// PowerShell: é a mesma API, sem depender de política de execução (regra 9).
+    /// </summary>
+    private ToolResult CriarPontoDeRestauracao()
+    {
+        try
+        {
+            using var classe = new ManagementClass(@"\\.\root\default", "SystemRestore", null);
+            var parametros = classe.GetMethodParameters("CreateRestorePoint");
+
+            parametros["Description"] = $"GameBoost {DateTime.Now:dd/MM/yyyy HH:mm}";
+            parametros["RestorePointType"] = 12;  // MODIFY_SETTINGS
+            parametros["EventType"] = 100;        // BEGIN_SYSTEM_CHANGE
+
+            var retorno = classe.InvokeMethod("CreateRestorePoint", parametros, null);
+            var codigo = Convert.ToUInt32(retorno?["ReturnValue"] ?? 1u);
+
+            return codigo switch
+            {
+                0 => ToolResult.Ok("Ponto de restauração criado."),
+                1058 => ToolResult.Falha("A Restauração do Sistema está desativada neste computador. "
+                                       + "Ative em Proteção do Sistema antes."),
+                _ => ToolResult.Falha($"O Windows recusou criar o ponto (código {codigo}). "
+                                    + "Normalmente é porque já existe um ponto das últimas 24 horas.")
+            };
+        }
+        catch (ManagementException ex)
+        {
+            return ToolResult.Falha($"Não foi possível criar o ponto: {ex.Message}");
+        }
+        catch (UnauthorizedAccessException)
+        {
+            return ToolResult.Falha("Criar ponto de restauração exige executar como administrador.");
+        }
+    }
+
+    /// <summary>
+    /// Roda um utilitário do Windows mostrando a saída ao vivo. sfc e DISM
+    /// demoram muito para rodar em silêncio: sem acompanhamento o usuário acha
+    /// que travou.
+    /// </summary>
+    private async Task<ToolResult> RodarAsync(
+        string executavel,
+        string argumentos,
+        IProgress<string>? saida,
+        CancellationToken ct)
+    {
+        var caminho = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), executavel);
+
+        if (!File.Exists(caminho))
+            return ToolResult.Falha($"{executavel} não encontrado neste Windows.");
+
+        var info = new ProcessStartInfo
+        {
+            FileName = caminho,
+            Arguments = argumentos,
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            CreateNoWindow = true,
+            // sfc escreve em UTF-16; sem isto a saída vira caracteres soltos.
+            StandardOutputEncoding = executavel.StartsWith("sfc", StringComparison.OrdinalIgnoreCase)
+                ? Encoding.Unicode
+                : Encoding.UTF8
+        };
+
+        try
+        {
+            using var processo = new Process { StartInfo = info, EnableRaisingEvents = true };
+            var linhas = new StringBuilder();
+
+            processo.OutputDataReceived += (_, e) =>
+            {
+                if (string.IsNullOrWhiteSpace(e.Data))
+                    return;
+
+                linhas.AppendLine(e.Data);
+                saida?.Report(e.Data);
+            };
+
+            processo.ErrorDataReceived += (_, e) =>
+            {
+                if (!string.IsNullOrWhiteSpace(e.Data))
+                    saida?.Report(e.Data);
+            };
+
+            processo.Start();
+            processo.BeginOutputReadLine();
+            processo.BeginErrorReadLine();
+
+            await processo.WaitForExitAsync(ct);
+
+            var texto = linhas.ToString();
+
+            return processo.ExitCode == 0
+                ? ToolResult.Ok($"{executavel} terminou sem erro.", texto)
+                : ToolResult.Falha($"{executavel} terminou com código {processo.ExitCode}.", texto);
+        }
+        catch (OperationCanceledException)
+        {
+            return ToolResult.Falha($"{executavel} foi cancelado. "
+                                  + "Ele pode continuar rodando por conta própria até terminar.");
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            return ToolResult.Falha($"Não foi possível rodar {executavel}: {ex.Message}");
+        }
+    }
+
+    // ---------------- Diagnóstico ----------------
+
+    /// <summary>
+    /// Escrita e leitura sequencial de 1 GB. WriteThrough desliga o cache de
+    /// escrita do Windows: sem isso a medição mostraria a velocidade da RAM, não
+    /// a do disco, e um HDD pareceria um SSD.
+    /// </summary>
+    private ToolResult TestarDisco(IProgress<string>? saida, CancellationToken ct)
+    {
+        const int tamanhoDoBloco = 4 * 1024 * 1024;
+        const long total = 1024L * 1024 * 1024;
+
+        var arquivo = Path.Combine(Path.GetTempPath(), $"gameboost-disco-{Guid.NewGuid():N}.tmp");
+        var bloco = new byte[tamanhoDoBloco];
+        Random.Shared.NextBytes(bloco);
+
+        try
+        {
+            saida?.Report("Gravando 1 GB...");
+            var relogio = Stopwatch.StartNew();
+
+            using (var escrita = new FileStream(arquivo, FileMode.CreateNew, FileAccess.Write,
+                       FileShare.None, tamanhoDoBloco, FileOptions.WriteThrough))
+            {
+                for (long escrito = 0; escrito < total; escrito += tamanhoDoBloco)
+                {
+                    ct.ThrowIfCancellationRequested();
+                    escrita.Write(bloco, 0, tamanhoDoBloco);
+                }
+
+                escrita.Flush(flushToDisk: true);
+            }
+
+            relogio.Stop();
+            var escritaMbs = total / 1024.0 / 1024.0 / relogio.Elapsed.TotalSeconds;
+
+            saida?.Report($"Escrita: {escritaMbs:0} MB/s");
+            saida?.Report("Lendo 1 GB...");
+
+            relogio.Restart();
+
+            using (var leitura = new FileStream(arquivo, FileMode.Open, FileAccess.Read,
+                       FileShare.None, tamanhoDoBloco, FileOptions.SequentialScan))
+            {
+                var destino = new byte[tamanhoDoBloco];
+                int lido;
+                while ((lido = leitura.Read(destino, 0, tamanhoDoBloco)) > 0)
+                {
+                    ct.ThrowIfCancellationRequested();
+                    _ = lido;
+                }
+            }
+
+            relogio.Stop();
+            var leituraMbs = total / 1024.0 / 1024.0 / relogio.Elapsed.TotalSeconds;
+
+            saida?.Report($"Leitura: {leituraMbs:0} MB/s");
+
+            var veredito = Interpretar(escritaMbs, leituraMbs);
+
+            return ToolResult.Ok(
+                $"Escrita {escritaMbs:0} MB/s, leitura {leituraMbs:0} MB/s.",
+                veredito);
+        }
+        catch (OperationCanceledException)
+        {
+            return ToolResult.Falha("Teste cancelado.");
+        }
+        catch (IOException ex)
+        {
+            return ToolResult.Falha($"Não foi possível testar o disco: {ex.Message}");
+        }
+        finally
+        {
+            // O arquivo sai mesmo se o teste falhar ou for cancelado.
+            try
+            {
+                if (File.Exists(arquivo))
+                    File.Delete(arquivo);
+            }
+            catch (IOException)
+            {
+                _log.Warn(ModuloId, "TesteDeDisco", arquivo, "nao consegui apagar o arquivo de teste");
+            }
+        }
+    }
+
+    /// <summary>Traduz o número em algo que signifique alguma coisa para o usuário.</summary>
+    private static string Interpretar(double escritaMbs, double leituraMbs)
+    {
+        var menor = Math.Min(escritaMbs, leituraMbs);
+
+        return menor switch
+        {
+            < 150 => "Estes números são de disco mecânico (HDD). Jogos novos assumem SSD e vão "
+                   + "engasgar ao carregar textura. Mover o jogo para um SSD resolve engasgo que "
+                   + "nenhum ajuste de software resolve.",
+            < 600 => "Faixa de SSD SATA. Suficiente para qualquer jogo atual.",
+            < 3000 => "Faixa de SSD NVMe. Está ótimo.",
+            _ => "Faixa de NVMe rápido. Está ótimo."
+        };
+    }
+
+    private ToolResult ColetarInfo()
+    {
+        var sb = new StringBuilder();
+        var memoria = _memoria.GetSnapshot();
+
+        sb.AppendLine("=== Sistema ===");
+        sb.AppendLine($"Windows           : {Wmi("Win32_OperatingSystem", "Caption")} (build {Environment.OSVersion.Version.Build})");
+        sb.AppendLine($"Nome do computador: {Environment.MachineName}");
+        sb.AppendLine();
+
+        sb.AppendLine("=== Processador ===");
+        sb.AppendLine($"Modelo            : {Wmi("Win32_Processor", "Name")}");
+        sb.AppendLine($"Núcleos lógicos   : {Environment.ProcessorCount}");
+        sb.AppendLine();
+
+        sb.AppendLine("=== Memória ===");
+        sb.AppendLine($"Total             : {GameModeModule.Formatar(memoria.TotalBytes)}");
+        sb.AppendLine($"Disponível        : {GameModeModule.Formatar(memoria.AvailableBytes)}");
+        sb.AppendLine(DescreverPentes());
+        sb.AppendLine();
+
+        sb.AppendLine("=== Vídeo ===");
+        foreach (var placa in TodosOsValores("Win32_VideoController", "Name"))
+            sb.AppendLine($"Placa             : {placa}");
+
+        sb.AppendLine($"Driver            : {Wmi("Win32_VideoController", "DriverVersion")}");
+        sb.AppendLine();
+
+        sb.AppendLine("=== Discos ===");
+        foreach (var unidade in DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Fixed))
+        {
+            var usado = unidade.TotalSize - unidade.TotalFreeSpace;
+            var percentual = unidade.TotalSize == 0 ? 0 : usado * 100.0 / unidade.TotalSize;
+
+            sb.AppendLine($"{unidade.Name,-18}: {GameModeModule.Formatar(unidade.TotalFreeSpace)} livres "
+                        + $"de {GameModeModule.Formatar(unidade.TotalSize)} ({percentual:0}% em uso)");
+        }
+
+        sb.AppendLine();
+        sb.AppendLine("=== BIOS ===");
+        sb.AppendLine($"Placa-mãe         : {Wmi("Win32_BaseBoard", "Manufacturer")} {Wmi("Win32_BaseBoard", "Product")}");
+        sb.AppendLine($"BIOS              : {Wmi("Win32_BIOS", "SMBIOSBIOSVersion")}");
+        sb.AppendLine();
+        sb.AppendLine($"Coletado pelo GameBoost em {DateTime.Now:dd/MM/yyyy HH:mm}.");
+
+        return ToolResult.Ok("Informações coletadas.", sb.ToString());
+    }
+
+    /// <summary>
+    /// Canal único ou duplo muda a banda de memória e rende FPS de verdade em
+    /// jogo limitado por CPU. Por isso vale mais que só o total instalado.
+    /// </summary>
+    private string DescreverPentes()
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher(
+                "SELECT Capacity, Speed FROM Win32_PhysicalMemory");
+
+            var pentes = consulta.Get().Cast<ManagementObject>().ToList();
+
+            if (pentes.Count == 0)
+                return "Pentes            : não foi possível ler";
+
+            var velocidade = pentes[0]["Speed"];
+            var canal = pentes.Count == 1 ? " (canal único)" : " (canal duplo ou mais)";
+
+            var texto = $"Pentes            : {pentes.Count}{canal}";
+
+            if (velocidade is not null)
+                texto += $", {velocidade} MHz";
+
+            foreach (var p in pentes)
+                p.Dispose();
+
+            return texto;
+        }
+        catch (ManagementException)
+        {
+            return "Pentes            : não foi possível ler";
+        }
+    }
+
+    private static string Wmi(string classe, string propriedade)
+        => TodosOsValores(classe, propriedade).FirstOrDefault() ?? "desconhecido";
+
+    private static IReadOnlyList<string> TodosOsValores(string classe, string propriedade)
+    {
+        try
+        {
+            using var consulta = new ManagementObjectSearcher($"SELECT {propriedade} FROM {classe}");
+
+            return consulta.Get()
+                .Cast<ManagementObject>()
+                .Select(mo =>
+                {
+                    var valor = mo[propriedade]?.ToString()?.Trim();
+                    mo.Dispose();
+                    return valor;
+                })
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .Select(v => v!)
+                .ToList();
+        }
+        catch (Exception ex) when (ex is ManagementException or UnauthorizedAccessException)
+        {
+            return Array.Empty<string>();
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tweaks/ServiceCatalog.cs b/GameBoost/src/GameBoost.Core/Modules/Tweaks/ServiceCatalog.cs
new file mode 100644
index 0000000..1cd6826
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tweaks/ServiceCatalog.cs
@@ -0,0 +1,212 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules;
+
+namespace GameBoost.Core.Modules.Tweaks;
+
+/// <summary>
+/// Um serviço do catálogo da seção 5.7, com a ação sugerida e o porquê.
+/// </summary>
+public sealed record ServiceTweak
+{
+    public required string Nome { get; init; }
+    public required string Titulo { get; init; }
+    public required string Explicacao { get; init; }
+    public required RiskLevel Risco { get; init; }
+
+    /// <summary>Para onde o GameBoost sugere mover o tipo de inicialização.</summary>
+    public ServiceStartMode Sugerido { get; init; } = ServiceStartMode.Manual;
+
+    /// <summary>
+    /// Aparece na lista mas não pode ser alterado (regra 6). O motivo é o texto
+    /// de <see cref="Explicacao"/>.
+    /// </summary>
+    public bool Protegido { get; init; }
+
+    /// <summary>
+    /// Serviço que o GameBoost não mexe e também não sugere mexer, mas que vale
+    /// explicar porque toda lista de "otimização" da internet manda desligar.
+    /// </summary>
+    public bool SomenteExplicar { get; init; }
+}
+
+/// <summary>
+/// Serviços do Windows (seção 5.7).
+///
+/// A régua aqui é diferente da dos tweaks: um serviço desligado por engano não
+/// tira alguns FPS, tira a impressora, a busca ou o Game Pass. Por isso a lista
+/// é curta, cada linha diz o que o usuário perde, e **nada vem pré-marcado**.
+///
+/// Três entradas existem só para desmentir listas de otimização da internet:
+/// SysMain, os serviços Xbox e o Windows Update. Elas aparecem explicadas e
+/// bloqueadas, porque a informação de que **não** se deve mexer vale tanto
+/// quanto a sugestão de mexer.
+/// </summary>
+public static class ServiceCatalog
+{
+    public const string Categoria = "Serviços do Windows";
+
+    public static IReadOnlyList<ServiceTweak> Todos { get; } = new[]
+    {
+        new ServiceTweak
+        {
+            Nome = "DiagTrack",
+            Titulo = "Experiências do Usuário Conectado e Telemetria",
+            Explicacao = "Coleta e envia dados de uso para a Microsoft. Desativar não quebra "
+                       + "nada do sistema e não afeta atualizações. É o desligamento mais seguro "
+                       + "desta lista. Ganho de desempenho: perto de zero — o motivo de desligar é "
+                       + "privacidade, não FPS.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Disabled
+        },
+
+        new ServiceTweak
+        {
+            Nome = "MapsBroker",
+            Titulo = "Gerenciador de Mapas Baixados",
+            Explicacao = "Só serve ao aplicativo Mapas com mapas offline. Se você não usa o "
+                       + "aplicativo Mapas, não perde nada.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Disabled
+        },
+
+        new ServiceTweak
+        {
+            Nome = "RemoteRegistry",
+            Titulo = "Registro Remoto",
+            Explicacao = "Permite que outra máquina leia e altere o registro desta. Já vem "
+                       + "desativado no Windows doméstico; se estiver ligado aqui, desligar é ganho "
+                       + "de segurança.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Disabled
+        },
+
+        new ServiceTweak
+        {
+            Nome = "WMPNetworkSvc",
+            Titulo = "Compartilhamento de Rede do Windows Media Player",
+            Explicacao = "Compartilha a biblioteca do Windows Media Player na rede local. "
+                       + "Herança de uma época em que isso era usado.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Disabled
+        },
+
+        new ServiceTweak
+        {
+            Nome = "Fax",
+            Titulo = "Fax",
+            Explicacao = "Envia e recebe fax por um modem. Se você tem um modem de fax ligado "
+                       + "nesta máquina, mantenha.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Disabled
+        },
+
+        new ServiceTweak
+        {
+            Nome = "WSearch",
+            Titulo = "Windows Search",
+            Explicacao = "Mantém o índice que faz a busca do menu Iniciar e do Explorer ser "
+                       + "instantânea. Em Manual, a busca continua funcionando, mas fica lenta e "
+                       + "passa a varrer as pastas na hora. Vale considerar em máquina com HDD; em "
+                       + "SSD o serviço custa pouco e a busca rápida compensa.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Manual
+        },
+
+        new ServiceTweak
+        {
+            Nome = "Spooler",
+            Titulo = "Spooler de Impressão",
+            Explicacao = "Sem ele não há impressão, nem para PDF. Em Manual ele sobe quando "
+                       + "alguma coisa tenta imprimir. Só mude se você realmente não imprime nesta "
+                       + "máquina — e lembre que salvar em PDF conta como imprimir.",
+            Risco = RiskLevel.Baixo,
+            Sugerido = ServiceStartMode.Manual
+        },
+
+        // ------------------------------------------------------------------
+        // Daqui para baixo: aparece para explicar por que NÃO mexer
+        // ------------------------------------------------------------------
+
+        new ServiceTweak
+        {
+            Nome = "SysMain",
+            Titulo = "SysMain (antigo Superfetch)",
+            Explicacao = "Toda lista de otimização manda desligar, e está errada. Em SSD o "
+                       + "SysMain praticamente não faz leitura antecipada, e o que ele faz hoje é "
+                       + "gerenciar memória — inclusive a compressão. Desligar não devolve RAM, "
+                       + "devolve cache, e o Windows usa RAM livre para cache de qualquer jeito. "
+                       + "Fica como está.",
+            Risco = RiskLevel.Medio,
+            SomenteExplicar = true,
+            Protegido = true
+        },
+
+        new ServiceTweak
+        {
+            Nome = "XblAuthManager",
+            Titulo = "Gerenciador de Autenticação do Xbox Live",
+            Explicacao = "Sem ele o Game Pass não abre, jogos da Microsoft Store não "
+                       + "autenticam e alguns anti-cheat que usam a conta Microsoft falham. Se você "
+                       + "não usa nada da Xbox, o serviço fica parado sozinho e não custa nada.",
+            Risco = RiskLevel.Medio,
+            SomenteExplicar = true,
+            Protegido = true
+        },
+
+        new ServiceTweak
+        {
+            Nome = "XboxNetApiSvc",
+            Titulo = "Serviço de Rede do Xbox Live",
+            Explicacao = "Rede para jogos da Microsoft Store e Game Pass. Mesma história do "
+                       + "anterior: parado, não custa; desligado, quebra o Game Pass.",
+            Risco = RiskLevel.Medio,
+            SomenteExplicar = true,
+            Protegido = true
+        },
+
+        new ServiceTweak
+        {
+            Nome = "wuauserv",
+            Titulo = "Windows Update",
+            Explicacao = "Nunca desativar. Uma máquina sem atualização de segurança é um "
+                       + "problema maior do que qualquer FPS que isso renda. O Modo Game já pausa o "
+                       + "Update enquanto você joga e o religa ao desligar, que é o jeito certo de "
+                       + "resolver a reclamação de update no meio da partida.",
+            Risco = RiskLevel.Alto,
+            Protegido = true
+        },
+
+        new ServiceTweak
+        {
+            Nome = "WinDefend",
+            Titulo = "Antivírus do Microsoft Defender",
+            Explicacao = "Proteção em tempo real da máquina. O GameBoost não desliga "
+                       + "antivírus, nem o do Windows nem o de terceiros.",
+            Risco = RiskLevel.Alto,
+            Protegido = true
+        },
+
+        new ServiceTweak
+        {
+            Nome = "SecurityHealthService",
+            Titulo = "Serviço de Segurança do Windows",
+            Explicacao = "É a Central de Segurança. Desligar cega o Windows sobre o próprio "
+                       + "estado de proteção.",
+            Risco = RiskLevel.Alto,
+            Protegido = true
+        }
+    };
+
+    public static ServiceTweak? PorNome(string nome)
+        => Todos.FirstOrDefault(s => string.Equals(s.Nome, nome, StringComparison.OrdinalIgnoreCase));
+
+    public static string TextoDoModo(ServiceStartMode modo) => modo switch
+    {
+        ServiceStartMode.Automatic => "automático",
+        ServiceStartMode.Manual => "manual",
+        ServiceStartMode.Disabled => "desativado",
+        ServiceStartMode.Boot => "boot",
+        ServiceStartMode.System => "sistema",
+        _ => "desconhecido"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakCatalog.cs b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakCatalog.cs
new file mode 100644
index 0000000..3cfe257
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakCatalog.cs
@@ -0,0 +1,315 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules;
+
+namespace GameBoost.Core.Modules.Tweaks;
+
+/// <summary>
+/// O catálogo da seção 5.8, inteiro e por extenso.
+///
+/// Duas ausências são propositais e valem tanto quanto o que está aqui:
+///
+/// - **Mitigações de Spectre/Meltdown** não entram. Desligar rende alguns por
+///   cento em CPU antiga e abre um buraco de segurança real. O spec diz "Nunca",
+///   e nem como item bloqueado isso aparece: item na tela vira ideia na cabeça
+///   de alguém.
+/// - **VBS / Isolamento de núcleo** aparece, mas só de leitura. O GameBoost
+///   mostra o estado, explica o custo e abre a tela da Microsoft. Quem decide
+///   trocar segurança por FPS é o dono da máquina, na tela dele.
+/// </summary>
+public static class TweakCatalog
+{
+    public const string CategoriaJogos = "Jogos";
+    public const string CategoriaSistema = "Sistema";
+    public const string CategoriaRede = "Rede";
+    public const string CategoriaEntrada = "Mouse e teclado";
+    public const string CategoriaEnergia = "Energia";
+    public const string CategoriaSeguranca = "Segurança";
+
+    private const string GameConfigStore = @"System\GameConfigStore";
+    private const string GameBar = @"Software\Microsoft\GameBar";
+    private const string SystemProfile = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile";
+    private const string TarefasJogos = SystemProfile + @"\Tasks\Games";
+    private const string GraphicsDrivers = @"SYSTEM\CurrentControlSet\Control\GraphicsDrivers";
+    private const string Dwm = @"SOFTWARE\Microsoft\Windows\Dwm";
+    private const string Mouse = @"Control Panel\Mouse";
+    private const string DeviceGuard = @"SYSTEM\CurrentControlSet\Control\DeviceGuard";
+
+    public static IReadOnlyList<TweakDefinition> Todos { get; } = new[]
+    {
+        // ------------------------------------------------------------------
+        // Jogos
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "hags",
+            Nome = "Agendamento de GPU por hardware (HAGS)",
+            Categoria = CategoriaJogos,
+            EfeitoReal = "Obrigatório para o Frame Generation do DLSS 3. Em placas RTX 30 ou "
+                       + "superiores e RX 6000 ou superiores, com driver atual, costuma melhorar a "
+                       + "regularidade dos quadros. Em CPU antiga pode piorar. Consome até 1 GB de VRAM. "
+                       + "Se você não usa Frame Generation, ligue, jogue uma sessão e compare: é o único "
+                       + "jeito honesto de saber se ajuda na sua máquina.",
+            Evidencia = "Documentação da Microsoft sobre GPU scheduling e requisito declarado do "
+                      + "DLSS 3 pela NVIDIA. O efeito em frame pacing varia por máquina, e por isso "
+                      + "o texto acima não promete número.",
+            Risco = RiskLevel.Medio,
+            ExigeReboot = true,
+            ComoDesfazer = "Voltar o valor anterior por aqui e reiniciar. Se o vídeo ficar instável, "
+                         + "o Modo de Segurança do Windows também permite desfazer.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, GraphicsDrivers, "HwSchMode", 2, RegistryValueKindLite.DWord)
+            }
+        },
+
+        new TweakDefinition
+        {
+            Id = "game-mode",
+            Nome = "Modo Jogo do Windows",
+            Categoria = CategoriaJogos,
+            EfeitoReal = "No Windows 11 e no 10 22H2 em diante ele segura o Windows Update e a "
+                       + "instalação de driver enquanto você joga, que é o ganho concreto. Ligado é a "
+                       + "recomendação padrão; desligue só se atrapalhar software de captura ou live.",
+            Evidencia = "Comportamento documentado pela Microsoft a partir do 22H2. Versões "
+                      + "anteriores tinham relatos de stutter, hoje resolvidos.",
+            Risco = RiskLevel.Baixo,
+            Recomendado = true,
+            ComoDesfazer = "Desligar por aqui ou em Configurações, Jogos, Modo Jogo.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.CurrentUser, GameBar, "AutoGameModeEnabled", 1, RegistryValueKindLite.DWord)
+            }
+        },
+
+        new TweakDefinition
+        {
+            Id = "game-dvr",
+            Nome = "Gravação em segundo plano (Game DVR)",
+            Categoria = CategoriaJogos,
+            EfeitoReal = "Desliga a gravação contínua que a Game Bar mantém aberta. Ganho real em "
+                       + "máquina modesta; em PC forte é pequeno. Você perde o atalho de gravar os "
+                       + "últimos 30 segundos.",
+            Evidencia = "Overhead medido pela própria Microsoft ao documentar a captura em "
+                      + "segundo plano. A ordem de grandeza depende da GPU.",
+            Risco = RiskLevel.Baixo,
+            Recomendado = true,
+            ComoDesfazer = "Religar por aqui, ou em Configurações, Jogos, Capturas.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.CurrentUser, GameConfigStore, "GameDVR_Enabled", 0, RegistryValueKindLite.DWord),
+                new TweakValue(RegistryRoot.CurrentUser, GameBar, "UseNexusForGameBarEnabled", 0, RegistryValueKindLite.DWord)
+            },
+            Tipo = TweakKind.RegistroMultiplo
+        },
+
+        new TweakDefinition
+        {
+            Id = "tarefas-jogos",
+            Nome = "Prioridade da categoria Jogos no agendador",
+            Categoria = CategoriaJogos,
+            EfeitoReal = "Marginal. Diz ao agendador multimídia que tarefas da categoria Jogos têm "
+                       + "prioridade alta. Na maioria das máquinas modernas a diferença não aparece nem "
+                       + "no gráfico de frametime. Está aqui porque é reversível e não custa nada, "
+                       + "não porque vá render FPS.",
+            Evidencia = "Chave documentada do Multimedia Class Scheduler Service. Nenhuma medição "
+                      + "pública consistente mostra ganho em hardware atual.",
+            Risco = RiskLevel.Baixo,
+            ComoDesfazer = "Voltar os três valores anteriores por aqui.",
+            Tipo = TweakKind.RegistroMultiplo,
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, TarefasJogos, "GPU Priority", 8, RegistryValueKindLite.DWord),
+                new TweakValue(RegistryRoot.LocalMachine, TarefasJogos, "Priority", 6, RegistryValueKindLite.DWord),
+                new TweakValue(RegistryRoot.LocalMachine, TarefasJogos, "Scheduling Category", "High", RegistryValueKindLite.String)
+            }
+        },
+
+        new TweakDefinition
+        {
+            Id = "mpo",
+            Nome = "Desativar Multi-Plane Overlay (MPO)",
+            Categoria = CategoriaJogos,
+            EfeitoReal = "Só vale se você tem um sintoma específico: piscada preta, tremulação ou "
+                       + "stutter na área de trabalho e em janelas, comum em setups NVIDIA com dois "
+                       + "monitores. Se você não tem esse sintoma, não ligue: isto não dá FPS.",
+            Evidencia = "Contorno reconhecido pela própria NVIDIA e pela Microsoft para o problema "
+                      + "de flicker com MPO.",
+            Risco = RiskLevel.Medio,
+            ExigeReboot = true,
+            ComoDesfazer = "Apagar o valor por aqui e reiniciar.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, Dwm, "OverlayTestMode", 5, RegistryValueKindLite.DWord)
+            }
+        },
+
+        // ------------------------------------------------------------------
+        // Sistema
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "system-responsiveness",
+            Nome = "Reserva de CPU para tarefas de fundo",
+            Categoria = CategoriaSistema,
+            EfeitoReal = "Marginal. O Windows reserva 20% da CPU para tarefas multimídia de fundo; "
+                       + "isto zera a reserva e devolve a fatia ao aplicativo em primeiro plano. "
+                       + "Pode causar engasgo em áudio de gravação ou transmissão.",
+            Evidencia = "Chave documentada do MMCSS. O valor padrão 20 existe justamente para "
+                      + "proteger áudio, e é por isso que este está marcado como marginal e não como "
+                      + "recomendado.",
+            Risco = RiskLevel.Baixo,
+            ComoDesfazer = "Voltar o valor anterior por aqui, normalmente 20.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, SystemProfile, "SystemResponsiveness", 0, RegistryValueKindLite.DWord)
+            }
+        },
+
+        new TweakDefinition
+        {
+            Id = "efeitos-visuais",
+            Nome = "Efeitos visuais no melhor desempenho",
+            Categoria = CategoriaSistema,
+            EfeitoReal = "Tira animação de janela, sombra e transparência. Ajuda de verdade só em "
+                       + "máquina bem fraca ou sem GPU dedicada. Em PC de jogo o ganho é nulo e a "
+                       + "interface fica visivelmente mais crua.",
+            Evidencia = "Afeta composição da área de trabalho, não o jogo em tela cheia, que nem "
+                      + "passa pelo DWM.",
+            Risco = RiskLevel.Baixo,
+            ComoDesfazer = "Voltar o valor anterior por aqui, ou marcar Ajustar para melhor "
+                         + "aparência nas opções de desempenho do Windows.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.CurrentUser,
+                    @"Software\Microsoft\Windows\CurrentVersion\Explorer\VisualEffects",
+                    "VisualFXSetting", 2, RegistryValueKindLite.DWord)
+            }
+        },
+
+        // ------------------------------------------------------------------
+        // Rede
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "network-throttling",
+            Nome = "Desativar limite de tráfego multimídia",
+            Categoria = CategoriaRede,
+            EfeitoReal = "Marginal. O Windows limita o processamento de rede a 10 pacotes por "
+                       + "milissegundo enquanto há áudio ou vídeo tocando. Isto remove o limite. Em "
+                       + "conexão doméstica normal você não vai notar.",
+            Evidencia = "Chave documentada do MMCSS. O limite foi criado para placas de rede de "
+                      + "2007 e praticamente não morde em hardware atual.",
+            Risco = RiskLevel.Baixo,
+            ComoDesfazer = "Voltar o valor anterior por aqui, normalmente 10.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, SystemProfile,
+                    "NetworkThrottlingIndex", unchecked((int)0xFFFFFFFF), RegistryValueKindLite.DWord)
+            }
+        },
+
+        // ------------------------------------------------------------------
+        // Mouse e teclado
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "aceleracao-mouse",
+            Nome = "Desativar aceleração do mouse",
+            Categoria = CategoriaEntrada,
+            EfeitoReal = "Faz o cursor andar sempre a mesma distância para o mesmo movimento de "
+                       + "mão, independente da velocidade. Não é ganho de desempenho, é consistência "
+                       + "de mira, e a maioria dos jogos de tiro já ignora isso pelo input bruto. "
+                       + "Vai atrapalhar se você está acostumado com a aceleração ligada.",
+            Evidencia = "A aceleração é aplicada pelo Windows antes de o jogo receber o evento, "
+                       + "exceto quando o jogo usa Raw Input, e aí esta chave não muda nada.",
+            Risco = RiskLevel.Baixo,
+            Tipo = TweakKind.RegistroMultiplo,
+            ComoDesfazer = "Voltar os três valores por aqui, ou remarcar Aumentar a precisão do "
+                         + "ponteiro nas propriedades do mouse.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.CurrentUser, Mouse, "MouseSpeed", "0", RegistryValueKindLite.String),
+                new TweakValue(RegistryRoot.CurrentUser, Mouse, "MouseThreshold1", "0", RegistryValueKindLite.String),
+                new TweakValue(RegistryRoot.CurrentUser, Mouse, "MouseThreshold2", "0", RegistryValueKindLite.String)
+            }
+        },
+
+        // ------------------------------------------------------------------
+        // Energia
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "power-throttling",
+            Nome = "Desativar limitação de energia do processador",
+            Categoria = CategoriaEnergia,
+            EfeitoReal = "Impede o Windows de reduzir o clock de processos que ele julga ociosos. "
+                       + "Faz diferença em notebook, onde a limitação é agressiva. Em desktop na "
+                       + "tomada, quase nada. Custa consumo e temperatura.",
+            Evidencia = "Power Throttling documentado pela Microsoft, ativo por padrão em "
+                      + "plataformas com Speed Shift.",
+            Risco = RiskLevel.Baixo,
+            ComoDesfazer = "Voltar o valor anterior por aqui.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine,
+                    @"SYSTEM\CurrentControlSet\Control\Power\PowerThrottling",
+                    "PowerThrottlingOff", 1, RegistryValueKindLite.DWord)
+            }
+        },
+
+        new TweakDefinition
+        {
+            Id = "hibernacao",
+            Nome = "Desativar hibernação",
+            Categoria = CategoriaEnergia,
+            EfeitoReal = "Libera em disco o equivalente à sua memória RAM, apagando o "
+                       + "hiberfil.sys. Em troca você perde a hibernação e a Inicialização Rápida, "
+                       + "então o boot fica alguns segundos mais lento. Vale quando o SSD está "
+                       + "apertado; não vale por desempenho.",
+            Evidencia = "O hiberfil.sys ocupa por padrão cerca de 40% da RAM instalada, e 100% "
+                      + "quando a hibernação completa está ativa. A página de Espaço mostra o tamanho "
+                      + "real do seu.",
+            Risco = RiskLevel.Medio,
+            Tipo = TweakKind.Powercfg,
+            ComandoLigar = "/h off",
+            ComandoDesligar = "/h on",
+            ComoDesfazer = "Religar por aqui, que roda powercfg /h on e recria o arquivo."
+        },
+
+        // ------------------------------------------------------------------
+        // Segurança: aparece, explica, e não mexe
+        // ------------------------------------------------------------------
+
+        new TweakDefinition
+        {
+            Id = "vbs",
+            Nome = "Isolamento de núcleo (VBS)",
+            Categoria = CategoriaSeguranca,
+            EfeitoReal = "A virtualização de segurança do Windows custa desempenho em jogos "
+                       + "limitados por processador. As medições da comunidade ficam entre 5% e 15%, "
+                       + "variando muito com o jogo e a CPU. Em troca ela é o que impede um driver "
+                       + "malicioso de ler a memória do sistema. Num PC que também é o seu banco e o "
+                       + "seu trabalho, desligar é uma troca ruim. Num PC só de jogo, é uma escolha "
+                       + "defensável — sua, não do GameBoost.",
+            Evidencia = "Faixa de 5% a 15% vem de testes independentes publicados por veículos de "
+                      + "hardware. Não é número medido nesta máquina, e o texto diz isso.",
+            Risco = RiskLevel.Alto,
+            Tipo = TweakKind.SomenteLeitura,
+            ComoDesfazer = "O GameBoost não altera isto. O botão abre a Segurança do Windows, "
+                         + "em Segurança do dispositivo, Isolamento de núcleo.",
+            Valores = new[]
+            {
+                new TweakValue(RegistryRoot.LocalMachine, DeviceGuard + @"\Scenarios\HypervisorEnforcedCodeIntegrity",
+                    "Enabled", 1, RegistryValueKindLite.DWord)
+            }
+        }
+    };
+
+    public static TweakDefinition? PorId(string id)
+        => Todos.FirstOrDefault(t => t.Id == id);
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakDefinition.cs b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakDefinition.cs
new file mode 100644
index 0000000..50ab9d0
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweakDefinition.cs
@@ -0,0 +1,80 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules;
+
+namespace GameBoost.Core.Modules.Tweaks;
+
+/// <summary>
+/// Como o tweak é aplicado. Nem tudo é chave de registro.
+/// </summary>
+public enum TweakKind
+{
+    /// <summary>Um valor no registro. O caso comum.</summary>
+    Registro,
+
+    /// <summary>Vários valores de uma vez, aplicados e revertidos em bloco.</summary>
+    RegistroMultiplo,
+
+    /// <summary>Chama `powercfg`. Reversão pelo comando inverso.</summary>
+    Powercfg,
+
+    /// <summary>
+    /// Só diagnóstico: o GameBoost mostra o estado e explica, mas não altera.
+    /// É o caso do VBS / Isolamento de núcleo (seção 5.8) — mexer ali é decisão
+    /// de segurança do usuário, tomada na tela da Microsoft, não aqui.
+    /// </summary>
+    SomenteLeitura
+}
+
+/// <summary>Um par chave/valor dentro de um tweak.</summary>
+public sealed record TweakValue(
+    RegistryRoot Root,
+    string SubKey,
+    string ValueName,
+    object ValorLigado,
+    RegistryValueKindLite Kind);
+
+/// <summary>
+/// Um ajuste do catálogo da seção 5.8, documentado em docs/TWEAKS.md.
+///
+/// A propriedade <see cref="EfeitoReal"/> é a que a UI mostra, e ela é honesta
+/// por obrigação (regra 4): quando o ganho é marginal, o texto diz que é
+/// marginal. Um booster que promete FPS em cima de `SystemResponsiveness` está
+/// mentindo, e este não vai fazer isso.
+/// </summary>
+public sealed record TweakDefinition
+{
+    public required string Id { get; init; }
+    public required string Nome { get; init; }
+    public required string Categoria { get; init; }
+
+    /// <summary>O que o ajuste faz de verdade, sem promessa inflada.</summary>
+    public required string EfeitoReal { get; init; }
+
+    /// <summary>De onde vem a afirmação acima. Vai para docs/TWEAKS.md.</summary>
+    public required string Evidencia { get; init; }
+
+    public required RiskLevel Risco { get; init; }
+    public required string ComoDesfazer { get; init; }
+
+    public TweakKind Tipo { get; init; } = TweakKind.Registro;
+
+    /// <summary>Os valores gravados quando o tweak é ligado.</summary>
+    public IReadOnlyList<TweakValue> Valores { get; init; } = Array.Empty<TweakValue>();
+
+    /// <summary>Só vale depois de reiniciar, e a UI precisa avisar antes.</summary>
+    public bool ExigeReboot { get; init; }
+
+    /// <summary>Precisa de elevação para gravar (qualquer coisa em HKLM).</summary>
+    public bool ExigeAdmin => Valores.Any(v => v.Root == RegistryRoot.LocalMachine)
+                              || Tipo == TweakKind.Powercfg;
+
+    /// <summary>
+    /// Recomendado pelo GameBoost. **Recomendado não é pré-marcado** (regra 3):
+    /// o selo aparece na lista, a caixa continua vazia.
+    /// </summary>
+    public bool Recomendado { get; init; }
+
+    /// <summary>Comando de powercfg para ligar e para desligar, quando Tipo = Powercfg.</summary>
+    public string? ComandoLigar { get; init; }
+    public string? ComandoDesligar { get; init; }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweaksModule.cs b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweaksModule.cs
new file mode 100644
index 0000000..6290a92
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Tweaks/TweaksModule.cs
@@ -0,0 +1,623 @@
+using System.Diagnostics;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Safety;
+using GameBoost.Core.State;
+
+namespace GameBoost.Core.Modules.Tweaks;
+
+/// <summary>
+/// Tweaks de jogos (seção 5.8) e serviços do Windows (seção 5.7) na mesma tela.
+///
+/// São duas coisas diferentes com a mesma cara para o usuário: "um ajuste do
+/// sistema que eu ligo ou desligo, e que dá para voltar atrás". O catálogo de
+/// cada um vive separado (<see cref="TweakCatalog"/> e
+/// <see cref="ServiceCatalog"/>); aqui eles viram uma lista só, agrupada por
+/// categoria.
+///
+/// **Nada vem pré-marcado**, nem o que o próprio GameBoost recomenda. O selo
+/// "recomendado" aparece no texto; a caixa continua vazia (regra 3).
+/// </summary>
+public sealed class TweaksModule : IModule
+{
+    public const string ModuloId = "tweaks";
+
+    private const string PrefixoTweak = "tweak:";
+    private const string PrefixoServico = "servico:";
+
+    private readonly IRegistryService _registro;
+    private readonly IServiceControllerService _servicos;
+    private readonly ISafetyGuard _guarda;
+    private readonly IStateBackup _backup;
+    private readonly IRollbackEngine _rollback;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    public TweaksModule(
+        IRegistryService registro,
+        IServiceControllerService servicos,
+        ISafetyGuard guarda,
+        IStateBackup backup,
+        IRollbackEngine rollback,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _registro = registro;
+        _servicos = servicos;
+        _guarda = guarda;
+        _backup = backup;
+        _rollback = rollback;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Tweaks";
+    public string Descricao => "Ajustes do Windows para jogos e serviços que dá para desligar, cada um com o efeito real.";
+
+    /// <summary>True quando algum tweak aplicado nesta sessão só vale após reiniciar.</summary>
+    public bool PrecisaReiniciar { get; private set; }
+
+    // ==================================================================
+    // Varredura
+    // ==================================================================
+
+    public Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+        => Task.Run(() => Varrer(progress, ct), ct);
+
+    private ScanResult Varrer(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        progress?.Report(new ModuleProgress("Lendo os ajustes atuais", 20));
+
+        var itens = new List<ActionItem>();
+
+        foreach (var tweak in TweakCatalog.Todos)
+        {
+            ct.ThrowIfCancellationRequested();
+            itens.Add(MontarTweak(tweak));
+        }
+
+        progress?.Report(new ModuleProgress("Lendo os serviços", 60));
+
+        foreach (var servico in ServiceCatalog.Todos)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var item = MontarServico(servico);
+            if (item is not null)
+                itens.Add(item);
+        }
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        var ligados = itens.Count(i => i.Payload is TweakEstado { Ligado: true });
+        var disponiveis = itens.Count(i => !i.Bloqueado);
+
+        var avisos = new List<string>();
+
+        if (itens.Any(i => i.Payload is TweakEstado { Definicao.ExigeReboot: true, Ligado: false }))
+            avisos.Add("Alguns ajustes desta lista só passam a valer depois de reiniciar. O aviso aparece na confirmação.");
+
+        if (!CoreServices.RodandoComoAdministrador())
+            avisos.Add("Sem privilégios de administrador, os ajustes que gravam em HKLM aparecem, mas não podem ser aplicados.");
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens,
+            Momento = _relogio.Now,
+            Resumo = $"{itens.Count} ajustes no catálogo, {ligados} já ativos na sua máquina. "
+                   + $"{disponiveis} podem ser alterados por aqui.",
+            Avisos = avisos
+        };
+    }
+
+    /// <summary>O que a UI guarda por trás de cada linha.</summary>
+    public sealed record TweakEstado(TweakDefinition Definicao, bool Ligado, string EstadoAtual);
+
+    /// <summary>Estado de um serviço por trás da linha.</summary>
+    public sealed record ServicoEstado(ServiceTweak Catalogo, ServiceInfo Atual);
+
+    private ActionItem MontarTweak(TweakDefinition tweak)
+    {
+        var (ligado, estado) = LerEstado(tweak);
+
+        var bloqueado = tweak.Tipo == TweakKind.SomenteLeitura
+                        || (tweak.ExigeAdmin && !CoreServices.RodandoComoAdministrador());
+
+        var precisaDeAdmin = tweak.ExigeAdmin && !CoreServices.RodandoComoAdministrador();
+
+        var motivo = tweak.Tipo == TweakKind.SomenteLeitura
+            ? "O GameBoost não altera isto. O botão abre a tela do Windows onde a decisão é sua."
+            : precisaDeAdmin
+                ? "Precisa de privilégios de administrador. Reabra o GameBoost como administrador."
+                : null;
+
+        // Selo honesto: "Protegido" é o GameBoost se recusando a mexer;
+        // precisar de elevação é outra coisa, e some ao reabrir elevado.
+        var rotulo = tweak.Tipo == TweakKind.SomenteLeitura ? "Só informativo"
+            : precisaDeAdmin ? "Precisa de admin"
+            : "Protegido";
+
+        var detalhes = new List<string> { estado };
+
+        if (tweak.Recomendado)
+            detalhes.Add("recomendado");
+
+        if (tweak.ExigeReboot)
+            detalhes.Add("só vale após reiniciar");
+
+        return new ActionItem
+        {
+            Id = PrefixoTweak + tweak.Id,
+            Categoria = tweak.Categoria,
+            Titulo = tweak.Nome,
+            Descricao = string.Join(" · ", detalhes) + " — " + tweak.EfeitoReal,
+            Risco = tweak.Risco,
+            GanhoEstimado = ligado ? "já ativo" : "desligado",
+
+            // Regra 3. Nem o que o GameBoost recomenda vem marcado: recomendação
+            // é informação, não consentimento.
+            PreMarcado = false,
+
+            Bloqueado = bloqueado,
+            MotivoBloqueio = motivo,
+            RotuloBloqueio = rotulo,
+            ComoDesfazer = tweak.ComoDesfazer,
+            Payload = new TweakEstado(tweak, ligado, estado)
+        };
+    }
+
+    /// <summary>
+    /// Lê o estado atual do tweak. Um tweak "desligado" quase nunca significa
+    /// valor zero: na maioria das chaves ele significa **valor ausente**, e o
+    /// Windows assume o padrão. Confundir os dois é o que faz ferramenta de
+    /// tweak gravar lixo que nunca sai.
+    /// </summary>
+    private (bool Ligado, string Estado) LerEstado(TweakDefinition tweak)
+    {
+        if (tweak.Tipo == TweakKind.Powercfg)
+            return LerHibernacao();
+
+        if (tweak.Valores.Count == 0)
+            return (false, "estado desconhecido");
+
+        var ligados = 0;
+
+        foreach (var valor in tweak.Valores)
+        {
+            var atual = _registro.GetValue(valor.Root, valor.SubKey, valor.ValueName);
+
+            if (atual is not null && IgualAo(atual, valor.ValorLigado))
+                ligados++;
+        }
+
+        if (ligados == tweak.Valores.Count)
+            return (true, "ativo");
+
+        if (ligados == 0)
+            return (false, "desligado");
+
+        return (false, $"aplicado pela metade ({ligados} de {tweak.Valores.Count})");
+    }
+
+    private const string ChavePower = @"SYSTEM\CurrentControlSet\Control\Power";
+
+    /// <summary>
+    /// Estado da hibernação, lido do registro.
+    ///
+    /// A tentação era procurar `C:\hiberfil.sys`: se o arquivo está lá, a
+    /// hibernação está ligada. Só que `File.Exists` devolve **false** para ele
+    /// mesmo com a hibernação ligada — o arquivo é de sistema e a ACL barra a
+    /// consulta sem elevação. O resultado seria dizer "já desligada" para todo
+    /// mundo que não abriu o app como administrador, que é o caminho padrão.
+    ///
+    /// `powercfg /a` daria a resposta certa, mas o texto dele é traduzido, e
+    /// procurar a palavra "Hibernar" quebraria em qualquer outro idioma.
+    /// </summary>
+    private (bool, string) LerHibernacao()
+    {
+        var explicito = _registro.GetValue(RegistryRoot.LocalMachine, ChavePower, "HibernateEnabled");
+
+        if (explicito is int valor)
+        {
+            return valor == 0
+                ? (true, "hibernação já desligada")
+                : (false, "hibernação ligada");
+        }
+
+        // Sem o valor explícito, vale o padrão da plataforma. É o caso de quem
+        // nunca mexeu nisso.
+        var padrao = _registro.GetValue(RegistryRoot.LocalMachine, ChavePower, "HibernateEnabledDefault");
+
+        if (padrao is int p)
+        {
+            return p == 0
+                ? (true, "hibernação já desligada")
+                : (false, "hibernação ligada");
+        }
+
+        return (false, "estado da hibernação desconhecido");
+    }
+
+    private static bool IgualAo(object atual, object esperado)
+    {
+        if (atual is int a && esperado is int b)
+            return a == b;
+
+        return string.Equals(
+            Convert.ToString(atual, System.Globalization.CultureInfo.InvariantCulture),
+            Convert.ToString(esperado, System.Globalization.CultureInfo.InvariantCulture),
+            StringComparison.OrdinalIgnoreCase);
+    }
+
+    private ActionItem? MontarServico(ServiceTweak catalogo)
+    {
+        var atual = _servicos.GetService(catalogo.Nome);
+
+        // Serviço que não existe nesta instalação não vira linha na tela. O Fax
+        // sumiu de boa parte das instalações do Windows 11, e listar um serviço
+        // inexistente só gera dúvida.
+        if (atual is null)
+            return null;
+
+        // A blindagem central manda mais que o catalogo: se o SafetyGuard diz
+        // que o servico e intocavel, nem importa o que esta escrito aqui
+        // (regra 6).
+        var veredito = _guarda.CheckService(catalogo.Nome, apenasPausar: false);
+        var protegido = catalogo.Protegido || veredito.Protegido;
+
+        var jaNoAlvo = atual.StartMode == catalogo.Sugerido;
+
+        var bloqueado = protegido
+                        || catalogo.SomenteExplicar
+                        || jaNoAlvo
+                        || !CoreServices.RodandoComoAdministrador();
+
+        var motivo = veredito.Protegido
+            ? veredito.Explicacao
+            : protegido
+            ? catalogo.Explicacao
+            : catalogo.SomenteExplicar
+                ? "Está aqui para explicar por que não vale mexer."
+                : jaNoAlvo
+                    ? $"Já está em {ServiceCatalog.TextoDoModo(catalogo.Sugerido)}."
+                    : !CoreServices.RodandoComoAdministrador()
+                        ? "Precisa de privilégios de administrador."
+                        : null;
+
+        var rotulo = protegido ? "Protegido"
+            : catalogo.SomenteExplicar ? "Só informativo"
+            : jaNoAlvo ? "Já está assim"
+            : "Precisa de admin";
+
+        var acao = protegido || catalogo.SomenteExplicar
+            ? "não mexer"
+            : $"passar de {ServiceCatalog.TextoDoModo(atual.StartMode)} para {ServiceCatalog.TextoDoModo(catalogo.Sugerido)}";
+
+        return new ActionItem
+        {
+            Id = PrefixoServico + catalogo.Nome,
+            Categoria = ServiceCatalog.Categoria,
+            Titulo = catalogo.Titulo,
+            Descricao = $"{catalogo.Nome} · {ServiceCatalog.TextoDoModo(atual.StartMode)}"
+                      + (atual.IsRunning ? ", rodando agora" : ", parado")
+                      + $" · {acao} — {catalogo.Explicacao}",
+            Risco = catalogo.Risco,
+            GanhoEstimado = ServiceCatalog.TextoDoModo(atual.StartMode),
+            PreMarcado = false,
+            Bloqueado = bloqueado,
+            MotivoBloqueio = motivo,
+            RotuloBloqueio = rotulo,
+            ComoDesfazer = "Voltar o tipo de inicialização anterior por aqui, ou em services.msc. "
+                         + "O estado antigo fica guardado no histórico.",
+            Payload = new ServicoEstado(catalogo, atual)
+        };
+    }
+
+    // ==================================================================
+    // Aplicação
+    // ==================================================================
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Aplicar(itemIds, dryRun, ct), ct);
+
+    private ApplyResult Aplicar(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+    {
+        var acoes = new List<AppliedAction>();
+        var reiniciar = false;
+
+        foreach (var id in itemIds)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            if (id.StartsWith(PrefixoTweak, StringComparison.Ordinal))
+            {
+                var tweak = TweakCatalog.PorId(id[PrefixoTweak.Length..]);
+
+                if (tweak is null)
+                {
+                    acoes.Add(new AppliedAction(id, false, "Ajuste não está no catálogo.", null));
+                    continue;
+                }
+
+                if (tweak.Tipo == TweakKind.SomenteLeitura)
+                {
+                    acoes.Add(new AppliedAction(id, false,
+                        $"{tweak.Nome} é só informativo: o GameBoost não altera isto.", null));
+                    continue;
+                }
+
+                var resultado = AplicarTweak(tweak, id, dryRun);
+                acoes.Add(resultado);
+
+                if (resultado.Sucesso && tweak.ExigeReboot)
+                    reiniciar = true;
+            }
+            else if (id.StartsWith(PrefixoServico, StringComparison.Ordinal))
+            {
+                acoes.Add(AplicarServico(id[PrefixoServico.Length..], id, dryRun));
+            }
+            else
+            {
+                acoes.Add(new AppliedAction(id, false, "Item desconhecido.", null));
+            }
+        }
+
+        if (!dryRun && reiniciar)
+            PrecisaReiniciar = true;
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {ok} de {acoes.Count} ajustes seriam aplicados."
+                : $"{ok} de {acoes.Count} ajustes aplicados."
+                  + (reiniciar ? " Alguns só passam a valer depois de reiniciar." : string.Empty),
+
+            // Regra 4: tweak de registro não tem ganho mensurável na hora. Dizer
+            // "+12 FPS" aqui seria invenção, então o campo fica honesto.
+            GanhoMedido = reiniciar
+                ? "O efeito só aparece depois de reiniciar."
+                : "Ajustes de sistema não têm ganho mensurável no instante em que são aplicados."
+        };
+    }
+
+    private AppliedAction AplicarTweak(TweakDefinition tweak, string itemId, bool dryRun)
+    {
+        if (tweak.Tipo == TweakKind.Powercfg)
+            return AplicarPowercfg(tweak, itemId, dryRun);
+
+        var gravados = new List<string>();
+
+        foreach (var valor in tweak.Valores)
+        {
+            try
+            {
+                var anterior = _registro.GetValue(valor.Root, valor.SubKey, valor.ValueName);
+
+                if (dryRun)
+                {
+                    gravados.Add($"{valor.ValueName}: {anterior ?? "(não existe)"} vira {valor.ValorLigado}");
+                    continue;
+                }
+
+                // Regra 1: o ChangeRecord vem antes da escrita, sempre.
+                _backup.Registrar(new ChangeRecord
+                {
+                    Modulo = ModuloId,
+                    Tipo = ChangeType.Registry,
+                    Alvo = valor.SubKey,
+                    SubAlvo = valor.ValueName,
+                    ValorAnterior = anterior?.ToString(),
+                    ValorNovo = valor.ValorLigado.ToString(),
+                    ValorAnteriorExistia = anterior is not null,
+                    Extras =
+                    {
+                        ["root"] = valor.Root.ToString(),
+                        ["kind"] = valor.Kind.ToString(),
+                        ["nome"] = tweak.Nome,
+                        ["tweak"] = tweak.Id
+                    }
+                });
+
+                _registro.SetValue(valor.Root, valor.SubKey, valor.ValueName, valor.ValorLigado, valor.Kind);
+                gravados.Add(valor.ValueName);
+            }
+            catch (Exception ex) when (ex is UnauthorizedAccessException or System.Security.SecurityException or IOException)
+            {
+                _log.Error(ModuloId, "Aplicar", tweak.Id, ex.Message, ex);
+
+                // Um valor falhou no meio de um tweak de vários. Os anteriores
+                // já têm ChangeRecord, então a reversão os desfaz; o que não dá
+                // é declarar sucesso.
+                return new AppliedAction(itemId, false, $"{tweak.Nome}: {ex.Message}", null);
+            }
+        }
+
+        _log.Info(ModuloId, dryRun ? "Aplicar (dry-run)" : "Aplicar", tweak.Id, string.Join(", ", gravados));
+
+        return new AppliedAction(itemId, true,
+            dryRun
+                ? $"{tweak.Nome}: {string.Join("; ", gravados)}"
+                : $"{tweak.Nome} aplicado."
+                  + (tweak.ExigeReboot ? " Só vale depois de reiniciar." : string.Empty),
+            null);
+    }
+
+    private AppliedAction AplicarPowercfg(TweakDefinition tweak, string itemId, bool dryRun)
+    {
+        if (tweak.ComandoLigar is null || tweak.ComandoDesligar is null)
+            return new AppliedAction(itemId, false, $"{tweak.Nome}: catálogo sem comando.", null);
+
+        if (dryRun)
+            return new AppliedAction(itemId, true, $"Rodaria powercfg {tweak.ComandoLigar}.", null);
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(itemId, false, $"{tweak.Nome} precisa de administrador.", null);
+
+        try
+        {
+            _backup.Registrar(new ChangeRecord
+            {
+                Modulo = ModuloId,
+                Tipo = ChangeType.Power,
+                Alvo = "powercfg",
+                SubAlvo = tweak.Id,
+                ValorAnterior = tweak.ComandoDesligar,
+                ValorNovo = tweak.ComandoLigar,
+                Extras =
+                {
+                    // O engine de rollback lê isto e roda o comando inverso.
+                    ["powercfg"] = tweak.ComandoDesligar,
+                    ["nome"] = tweak.Nome
+                }
+            });
+
+            using var processo = Process.Start(new ProcessStartInfo
+            {
+                FileName = "powercfg.exe",
+                Arguments = tweak.ComandoLigar,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            });
+
+            if (processo is null)
+                return new AppliedAction(itemId, false, "Não foi possível iniciar o powercfg.", null);
+
+            processo.WaitForExit(30_000);
+
+            return processo.ExitCode == 0
+                ? new AppliedAction(itemId, true, $"{tweak.Nome} aplicado.", null)
+                : new AppliedAction(itemId, false, $"powercfg saiu com código {processo.ExitCode}.", null);
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            _log.Error(ModuloId, "Powercfg", tweak.Id, ex.Message, ex);
+            return new AppliedAction(itemId, false, $"{tweak.Nome}: {ex.Message}", null);
+        }
+    }
+
+    private AppliedAction AplicarServico(string nome, string itemId, bool dryRun)
+    {
+        var catalogo = ServiceCatalog.PorNome(nome);
+
+        if (catalogo is null)
+            return new AppliedAction(itemId, false, "Serviço não está no catálogo.", null);
+
+        // Dupla checagem: a UI já bloqueia, mas um id pode chegar pela CLI.
+        var veredito = _guarda.CheckService(nome, apenasPausar: false);
+
+        if (veredito.Protegido)
+            return new AppliedAction(itemId, false, $"{catalogo.Titulo} é protegido: {veredito.Explicacao}", null);
+
+        if (catalogo.Protegido)
+            return new AppliedAction(itemId, false, $"{catalogo.Titulo} é protegido: {catalogo.Explicacao}", null);
+
+        if (catalogo.SomenteExplicar)
+            return new AppliedAction(itemId, false, $"{catalogo.Titulo} está na lista só para explicar.", null);
+
+        var atual = _servicos.GetService(nome);
+
+        if (atual is null)
+            return new AppliedAction(itemId, false, $"{nome} não existe nesta instalação.", null);
+
+        if (atual.StartMode == catalogo.Sugerido)
+            return new AppliedAction(itemId, true,
+                $"{catalogo.Titulo} já está em {ServiceCatalog.TextoDoModo(catalogo.Sugerido)}.", null);
+
+        if (dryRun)
+            return new AppliedAction(itemId, true,
+                $"{catalogo.Titulo}: {ServiceCatalog.TextoDoModo(atual.StartMode)} viraria "
+              + $"{ServiceCatalog.TextoDoModo(catalogo.Sugerido)}.", null);
+
+        if (!CoreServices.RodandoComoAdministrador())
+            return new AppliedAction(itemId, false, $"{catalogo.Titulo} precisa de administrador.", null);
+
+        var registro = _backup.Registrar(new ChangeRecord
+        {
+            Modulo = ModuloId,
+            Tipo = ChangeType.Service,
+            Alvo = nome,
+            SubAlvo = null,
+            ValorAnterior = atual.StartMode.ToString(),
+            ValorNovo = catalogo.Sugerido.ToString(),
+            Extras =
+            {
+                ["estavaRodando"] = atual.IsRunning.ToString(),
+                ["nome"] = catalogo.Titulo
+            }
+        });
+
+        var ok = _servicos.SetStartMode(nome, catalogo.Sugerido);
+
+        if (!ok)
+            return new AppliedAction(itemId, false, $"Não foi possível alterar {catalogo.Titulo}.", registro.Id);
+
+        // Desativar o tipo de inicialização não para o serviço que já está
+        // rodando: sem isto, o usuário aplica, não vê mudança nenhuma e conclui
+        // que a ferramenta não fez nada.
+        var detalhe = $"{catalogo.Titulo} agora é {ServiceCatalog.TextoDoModo(catalogo.Sugerido)}.";
+
+        if (catalogo.Sugerido == ServiceStartMode.Disabled && atual.IsRunning)
+        {
+            var parou = _servicos.Stop(nome, TimeSpan.FromSeconds(30));
+            detalhe += parou ? " Serviço parado." : " O serviço só para de vez no próximo boot.";
+        }
+
+        _log.Info(ModuloId, "Servico", nome, detalhe);
+
+        return new AppliedAction(itemId, true, detalhe, registro.Id);
+    }
+
+    // ==================================================================
+    // Reversão
+    // ==================================================================
+
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Reverter(changeIds, dryRun), ct);
+
+    private ApplyResult Reverter(IReadOnlyList<string> changeIds, bool dryRun)
+    {
+        // Sem ids explícitos, reverte tudo que este módulo aplicou e ainda está
+        // pendente. Não toca no que os outros módulos fizeram.
+        var alvos = changeIds.Count > 0
+            ? changeIds
+            : _backup.Pendentes.Where(r => r.Modulo == ModuloId).Select(r => r.Id).ToList();
+
+        if (alvos.Count == 0)
+        {
+            return new ApplyResult
+            {
+                ModuloId = ModuloId,
+                DryRun = dryRun,
+                Resumo = "Não há ajuste deste módulo para desfazer."
+            };
+        }
+
+        var resultados = _rollback.Reverter(alvos, dryRun);
+
+        var acoes = resultados
+            .Select(r => new AppliedAction(r.ChangeId, r.Sucesso, r.Detalhe, r.ChangeId))
+            .ToList();
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {ok} de {acoes.Count} ajustes voltariam ao estado anterior."
+                : $"{ok} de {acoes.Count} ajustes revertidos.",
+            GanhoMedido = string.Empty
+        };
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/AppInventory.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/AppInventory.cs
new file mode 100644
index 0000000..f0c4cf6
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/AppInventory.cs
@@ -0,0 +1,410 @@
+using System.Diagnostics;
+using System.Text;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+using Microsoft.Win32;
+
+namespace GameBoost.Core.Modules.Uninstaller;
+
+/// <summary>
+/// Monta a lista de aplicativos instalados (seção 5.3): registro, Store e
+/// último uso pelo UserAssist.
+/// </summary>
+public sealed class AppInventory
+{
+    private readonly IRegistryService _registro;
+    private readonly IGameBoostLogger _log;
+
+    public AppInventory(IRegistryService registro, IGameBoostLogger log)
+    {
+        _registro = registro;
+        _log = log;
+    }
+
+    private static readonly (RegistryRoot Raiz, string Caminho)[] ChavesDeDesinstalacao =
+    {
+        (RegistryRoot.LocalMachine, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"),
+        (RegistryRoot.LocalMachine, @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall"),
+        (RegistryRoot.CurrentUser, @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall")
+    };
+
+    public IReadOnlyList<InstalledApp> Listar(bool medirTamanho, CancellationToken ct)
+    {
+        var apps = new Dictionary<string, InstalledApp>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var app in DoRegistro(ct))
+            apps.TryAdd(app.Id, app);
+
+        foreach (var app in DaStore(ct))
+            apps.TryAdd(app.Id, app);
+
+        var usos = LerUltimoUso();
+
+        foreach (var app in apps.Values)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            UninstallerProtection.Avaliar(app);
+
+            if (app.PastaDeInstalacao is not null)
+            {
+                var executavel = Path.GetFileName(app.PastaDeInstalacao);
+
+                if (usos.TryGetValue(executavel, out var quando))
+                    app.UltimoUso = quando;
+                else if (Directory.Exists(app.PastaDeInstalacao))
+                    app.UltimoUso = UltimoAcessoDaPasta(app.PastaDeInstalacao);
+
+                if (medirTamanho && app.TamanhoMedido == 0)
+                    app.TamanhoMedido = TamanhoDaPasta(app.PastaDeInstalacao, ct);
+            }
+        }
+
+        return apps.Values.OrderByDescending(a => a.Tamanho).ToList();
+    }
+
+    // ---------------- Registro ----------------
+
+    private IEnumerable<InstalledApp> DoRegistro(CancellationToken ct)
+    {
+        foreach (var (raiz, caminho) in ChavesDeDesinstalacao)
+        {
+            IReadOnlyList<string> chaves;
+
+            try
+            {
+                chaves = _registro.GetSubKeyNames(raiz, caminho);
+            }
+            catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException)
+            {
+                _log.Warn("Uninstaller", "Registro", caminho, ex.Message);
+                continue;
+            }
+
+            foreach (var chave in chaves)
+            {
+                ct.ThrowIfCancellationRequested();
+
+                var app = Montar(raiz, $@"{caminho}\{chave}", chave);
+                if (app is not null)
+                    yield return app;
+            }
+        }
+    }
+
+    private InstalledApp? Montar(RegistryRoot raiz, string caminho, string chave)
+    {
+        var nome = Texto(raiz, caminho, "DisplayName");
+
+        if (string.IsNullOrWhiteSpace(nome))
+            return null;
+
+        // Atualizações e componentes de sistema não são "aplicativos": listar
+        // encheria a tela com centenas de entradas que ninguém desinstala.
+        if (Numero(raiz, caminho, "SystemComponent") == 1)
+            return null;
+
+        if (!string.IsNullOrWhiteSpace(Texto(raiz, caminho, "ParentKeyName")))
+            return null;
+
+        if (Texto(raiz, caminho, "ReleaseType") is "Security Update" or "Update" or "Hotfix")
+            return null;
+
+        var comando = Texto(raiz, caminho, "UninstallString");
+        var silencioso = Texto(raiz, caminho, "QuietUninstallString");
+        var pasta = Texto(raiz, caminho, "InstallLocation");
+
+        // Chave no formato {GUID} com WindowsInstaller=1 é MSI: dá para
+        // desinstalar em silêncio mesmo sem QuietUninstallString.
+        var ehMsi = Numero(raiz, caminho, "WindowsInstaller") == 1
+                 && chave.StartsWith('{') && chave.EndsWith('}');
+
+        return new InstalledApp
+        {
+            Id = chave,
+            Nome = nome!.Trim(),
+            Origem = AppOrigem.Win32,
+            Versao = Texto(raiz, caminho, "DisplayVersion"),
+            Publisher = Texto(raiz, caminho, "Publisher"),
+            PastaDeInstalacao = string.IsNullOrWhiteSpace(pasta) ? null : pasta.Trim('"'),
+            TamanhoEstimado = Numero(raiz, caminho, "EstimatedSize") * 1024L,
+            Instalado = DataDeInstalacao(Texto(raiz, caminho, "InstallDate")),
+            Comando = comando,
+            ComandoSilencioso = silencioso,
+            CodigoMsi = ehMsi ? chave : null
+        };
+    }
+
+    private string? Texto(RegistryRoot raiz, string caminho, string valor)
+    {
+        try
+        {
+            return _registro.GetValue(raiz, caminho, valor) as string;
+        }
+        catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    private int Numero(RegistryRoot raiz, string caminho, string valor)
+    {
+        try
+        {
+            return _registro.GetValue(raiz, caminho, valor) is int i ? i : 0;
+        }
+        catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException)
+        {
+            return 0;
+        }
+    }
+
+    private static DateTimeOffset? DataDeInstalacao(string? bruto)
+        => !string.IsNullOrWhiteSpace(bruto)
+           && DateTime.TryParseExact(bruto, "yyyyMMdd", null,
+               System.Globalization.DateTimeStyles.None, out var data)
+            ? new DateTimeOffset(data)
+            : null;
+
+    // ---------------- Store ----------------
+
+    /// <summary>
+    /// Aplicativos da Store. É o único ponto do GameBoost que usa PowerShell,
+    /// porque Get-AppxPackage não tem equivalente acessível de um processo
+    /// comum (regra 9 prevê exatamente esta exceção).
+    /// </summary>
+    private IEnumerable<InstalledApp> DaStore(CancellationToken ct)
+    {
+        var saida = RodarPowerShell(
+            // Sem isto o PowerShell escreve barras de progresso em CLIXML no
+            // stderr, que e justamente o que enchia o buffer e travava a leitura.
+            "$ProgressPreference = 'SilentlyContinue'; " +
+            "Get-AppxPackage | Where-Object { -not $_.IsFramework } | " +
+            "ForEach-Object { \"$($_.Name)|$($_.PackageFullName)|$($_.InstallLocation)|$($_.Version)|$($_.Publisher)|$($_.NonRemovable)\" }",
+            ct);
+
+        if (saida is null)
+            yield break;
+
+        foreach (var linha in saida.Split('\n', StringSplitOptions.RemoveEmptyEntries))
+        {
+            var partes = linha.Trim().Split('|');
+            if (partes.Length < 6)
+                continue;
+
+            var naoRemovivel = partes[5].Equals("True", StringComparison.OrdinalIgnoreCase);
+
+            yield return new InstalledApp
+            {
+                Id = partes[1],
+                Nome = Legivel(partes[0]),
+                Origem = AppOrigem.Store,
+                PacoteDaStore = partes[1],
+                PastaDeInstalacao = string.IsNullOrWhiteSpace(partes[2]) ? null : partes[2],
+                Versao = partes[3],
+                Publisher = LimparPublisher(partes[4]),
+                Protegido = naoRemovivel,
+                MotivoDaProtecao = naoRemovivel
+                    ? "O Windows marca este pacote como não removível."
+                    : null
+            };
+        }
+    }
+
+    /// <summary>"Microsoft.WindowsCalculator" fica ilegível; vira "Windows Calculator".</summary>
+    private static string Legivel(string nomeDoPacote)
+    {
+        var nome = nomeDoPacote;
+
+        var ponto = nome.LastIndexOf('.');
+        if (ponto > 0 && ponto < nome.Length - 1)
+            nome = nome[(ponto + 1)..];
+
+        var sb = new StringBuilder();
+
+        for (var i = 0; i < nome.Length; i++)
+        {
+            if (i > 0 && char.IsUpper(nome[i]) && !char.IsUpper(nome[i - 1]))
+                sb.Append(' ');
+
+            sb.Append(nome[i]);
+        }
+
+        return sb.ToString();
+    }
+
+    private static string? LimparPublisher(string publisher)
+    {
+        // Vem como "CN=Microsoft Corporation, O=..., L=...".
+        var cn = publisher.Split(',')
+            .FirstOrDefault(p => p.TrimStart().StartsWith("CN=", StringComparison.OrdinalIgnoreCase));
+
+        return cn is null ? null : cn.TrimStart()[3..].Trim();
+    }
+
+    private string? RodarPowerShell(string comando, CancellationToken ct)
+    {
+        try
+        {
+            // -EncodedCommand em vez de -Command: o script tem pipes, cifroes e
+            // aspas, e passar isso pela linha de comando faz o shell reinterpretar
+            // os simbolos. Foi o que aconteceu na primeira versao, que devolvia
+            // zero pacotes numa maquina com 142 instalados.
+            var codificado = Convert.ToBase64String(Encoding.Unicode.GetBytes(comando));
+
+            var info = new ProcessStartInfo
+            {
+                FileName = "powershell.exe",
+                // Regra 9: quando PowerShell é inevitável, sempre com estes flags.
+                Arguments = $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand {codificado}",
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+                StandardOutputEncoding = Encoding.UTF8
+            };
+
+            using var processo = Process.Start(info);
+            if (processo is null)
+                return null;
+
+            // Os dois fluxos precisam ser lidos ao mesmo tempo. Ler so o stdout
+            // e deixar o stderr redirecionado sem leitor trava o processo assim
+            // que o buffer do stderr enche: foi o que fez esta consulta devolver
+            // zero pacotes numa maquina com 142 instalados.
+            var lendoSaida = processo.StandardOutput.ReadToEndAsync(ct);
+            var lendoErro = processo.StandardError.ReadToEndAsync(ct);
+
+            if (!processo.WaitForExit(30_000))
+            {
+                processo.Kill(entireProcessTree: true);
+                _log.Warn("Uninstaller", "Store", null, "Get-AppxPackage demorou demais e foi encerrado");
+                return null;
+            }
+
+            var erro = lendoErro.GetAwaiter().GetResult();
+            if (!string.IsNullOrWhiteSpace(erro))
+                _log.Warn("Uninstaller", "Store", null, erro.Split(Environment.NewLine)[0]);
+
+            return lendoSaida.GetAwaiter().GetResult();
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException or IOException)
+        {
+            _log.Warn("Uninstaller", "Store", null, $"nao foi possivel listar apps da Store: {ex.Message}");
+            return null;
+        }
+    }
+
+    // ---------------- Último uso ----------------
+
+    /// <summary>
+    /// Lê o UserAssist, onde o Explorer registra o que o usuário abriu. Os
+    /// nomes vêm em ROT13 — não é criptografia, é ofuscação simples da Microsoft.
+    /// </summary>
+    private Dictionary<string, DateTimeOffset> LerUltimoUso()
+    {
+        var resultado = new Dictionary<string, DateTimeOffset>(StringComparer.OrdinalIgnoreCase);
+        const string raiz = @"Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist";
+
+        try
+        {
+            foreach (var guid in _registro.GetSubKeyNames(RegistryRoot.CurrentUser, raiz))
+            {
+                var contagem = $@"{raiz}\{guid}\Count";
+
+                foreach (var valor in _registro.GetValueNames(RegistryRoot.CurrentUser, contagem))
+                {
+                    var nome = Rot13(valor);
+                    var executavel = Path.GetFileName(nome);
+
+                    if (string.IsNullOrWhiteSpace(executavel))
+                        continue;
+
+                    if (_registro.GetValue(RegistryRoot.CurrentUser, contagem, valor) is not byte[] dados
+                        || dados.Length < 68)
+                    {
+                        continue;
+                    }
+
+                    // Deslocamento 60: FILETIME do último uso.
+                    var ticks = BitConverter.ToInt64(dados, 60);
+                    if (ticks <= 0)
+                        continue;
+
+                    try
+                    {
+                        var quando = DateTimeOffset.FromFileTime(ticks);
+
+                        if (!resultado.TryGetValue(executavel, out var atual) || quando > atual)
+                            resultado[executavel] = quando;
+                    }
+                    catch (ArgumentOutOfRangeException)
+                    {
+                    }
+                }
+            }
+        }
+        catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException)
+        {
+            _log.Warn("Uninstaller", "UserAssist", null, ex.Message);
+        }
+
+        return resultado;
+    }
+
+    internal static string Rot13(string texto)
+    {
+        var saida = texto.ToCharArray();
+
+        for (var i = 0; i < saida.Length; i++)
+        {
+            var c = saida[i];
+
+            if (c is >= 'a' and <= 'z')
+                saida[i] = (char)('a' + (c - 'a' + 13) % 26);
+            else if (c is >= 'A' and <= 'Z')
+                saida[i] = (char)('A' + (c - 'A' + 13) % 26);
+        }
+
+        return new string(saida);
+    }
+
+    private static DateTimeOffset? UltimoAcessoDaPasta(string pasta)
+    {
+        try
+        {
+            return new DateTimeOffset(Directory.GetLastWriteTimeUtc(pasta), TimeSpan.Zero);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return null;
+        }
+    }
+
+    private static long TamanhoDaPasta(string pasta, CancellationToken ct)
+    {
+        if (!Directory.Exists(pasta))
+            return 0;
+
+        long total = 0;
+        var pilha = new Stack<string>();
+        pilha.Push(pasta);
+
+        while (pilha.Count > 0)
+        {
+            ct.ThrowIfCancellationRequested();
+            var atual = pilha.Pop();
+
+            foreach (var entrada in FastFind.Listar(atual))
+            {
+                if (entrada.EhPasta)
+                    pilha.Push(Path.Combine(atual, entrada.Nome));
+                else
+                    total += entrada.Tamanho;
+            }
+        }
+
+        return total;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/InstalledApp.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/InstalledApp.cs
new file mode 100644
index 0000000..c639608
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/InstalledApp.cs
@@ -0,0 +1,72 @@
+namespace GameBoost.Core.Modules.Uninstaller;
+
+public enum AppOrigem
+{
+    Win32,
+    Store,
+    Portatil
+}
+
+/// <summary>
+/// Um aplicativo instalado, venha do registro ou da Store.
+/// </summary>
+public sealed record InstalledApp
+{
+    public required string Id { get; init; }
+    public required string Nome { get; init; }
+    public AppOrigem Origem { get; init; } = AppOrigem.Win32;
+
+    public string? Versao { get; init; }
+    public string? Publisher { get; init; }
+    public string? PastaDeInstalacao { get; init; }
+
+    /// <summary>Do registro. Pouco confiável: serve como piso quando não dá para medir a pasta.</summary>
+    public long TamanhoEstimado { get; init; }
+
+    /// <summary>Medido na pasta de instalação. Zero quando não foi possível medir.</summary>
+    public long TamanhoMedido { get; set; }
+
+    public long Tamanho => TamanhoMedido > 0 ? TamanhoMedido : TamanhoEstimado;
+
+    public DateTimeOffset? Instalado { get; init; }
+    public DateTimeOffset? UltimoUso { get; set; }
+
+    /// <summary>Comando de desinstalação silenciosa, quando o app oferece um.</summary>
+    public string? ComandoSilencioso { get; init; }
+
+    /// <summary>Comando normal: abre o desinstalador do próprio app.</summary>
+    public string? Comando { get; init; }
+
+    /// <summary>Pacote MSI: dá para desinstalar com msiexec /x {GUID} /qn.</summary>
+    public string? CodigoMsi { get; init; }
+
+    /// <summary>Nome completo do pacote da Store.</summary>
+    public string? PacoteDaStore { get; init; }
+
+    public bool Protegido { get; set; }
+    public string? MotivoDaProtecao { get; set; }
+
+    /// <summary>Bloatware conhecido. Sugerido na lista, nunca pré-marcado (regra 3).</summary>
+    public bool Sugerido { get; set; }
+
+    public bool TemDesinstalacaoSilenciosa
+        => !string.IsNullOrWhiteSpace(ComandoSilencioso)
+        || !string.IsNullOrWhiteSpace(CodigoMsi)
+        || Origem == AppOrigem.Store;
+
+    public string QuandoUsou => UltimoUso is null
+        ? "sem registro de uso"
+        : (DateTimeOffset.Now - UltimoUso.Value).TotalDays switch
+        {
+            < 7 => "usado esta semana",
+            < 31 => "usado este mês",
+            < 180 => $"usado há {(int)((DateTimeOffset.Now - UltimoUso.Value).TotalDays / 30)} meses",
+            < 365 => "usado há mais de 6 meses",
+            _ => "usado há mais de um ano"
+        };
+
+    /// <summary>Grande e parado: é onde o espaço realmente está.</summary>
+    public bool NuncaUsado
+        => UltimoUso is null
+        || (DateTimeOffset.Now - UltimoUso.Value).TotalDays > 365;
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/LeftoverScanner.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/LeftoverScanner.cs
new file mode 100644
index 0000000..cfcad33
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/LeftoverScanner.cs
@@ -0,0 +1,272 @@
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.Uninstaller;
+
+public sealed record Resto(
+    string Nome,
+    string Caminho,
+    long Bytes,
+    DateTime Modificado,
+    string Local)
+{
+    public string Idade
+    {
+        get
+        {
+            var dias = (DateTime.Now - Modificado).TotalDays;
+
+            return dias switch
+            {
+                < 31 => "mexido este mês",
+                < 180 => $"parado há {(int)(dias / 30)} meses",
+                < 365 => "parado há mais de 6 meses",
+                _ => $"parado há {(int)(dias / 365)} ano(s)"
+            };
+        }
+    }
+}
+
+/// <summary>
+/// Aba "Restos de apps antigos" (pedido de 13/09/2026, registrado na seção 5.3).
+///
+/// Varre %APPDATA%, %LOCALAPPDATA% e %PROGRAMDATA% procurando pastas cujo nome
+/// não corresponde a nenhum app instalado. É a sobra que fica depois de
+/// desinstalar, e que nenhum desinstalador limpa.
+///
+/// **Nada aqui é apagado automaticamente.** O casamento de nomes é uma
+/// heurística: uma pasta pode pertencer a um app que o registro não declara.
+/// Por isso tudo entra desmarcado e a remoção vai para a Lixeira.
+/// </summary>
+public sealed class LeftoverScanner
+{
+    private readonly IGameBoostLogger _log;
+
+    public LeftoverScanner(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    /// <summary>
+    /// Fabricantes cujas pastas nunca entram na lista: são de sistema, de
+    /// driver ou compartilhadas por vários programas. Documentado em
+    /// docs/PROTECAO.md.
+    /// </summary>
+    private static readonly IReadOnlySet<string> Ignoradas = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        // Microsoft e Windows
+        "microsoft", "microsoftedge", "microsoft corporation", "windows", "windowsapps",
+        "microsoft onedrive", "onedrive", "packages", "temp", "tmp", "cache",
+        "comms", "connecteddevicesplatform", "d3dscache", "elevatedDiagnostics",
+        "publisher cache", "virtualstore", "webcachelock", "iconcache",
+        "package cache", "installer", "assembly", "diagnostics", "history",
+        "application data", "appdata", "programdata", "usoshared", "usoprivate",
+        "windowsholographicdevices", "desktop", "start menu", "ssh",
+        // Pastas-guarda-chuva: contem varios apps ativos dentro, nao sao resto
+        // de nada. "Programs" apareceu com 9 GB no primeiro teste real.
+        "programs", "apps", "local", "roaming", "lowlevel", "virtual machines",
+
+        // Fabricantes de hardware e driver
+        "nvidia", "nvidia corporation", "amd", "ati", "intel", "intelgraphicsprofiles",
+        "realtek", "logishrd", "logitech", "razer", "corsair", "steelseries",
+        "synaptics", "elan", "qualcomm", "broadcom",
+
+        // Compartilhadas por muitos programas
+        "adobe", "common files", "oracle", "java", "sun", "mozilla", "google",
+        "chromium", "chrome", "crashdumps", "crashpad", "crashreports",
+        "sentry", "squirreltemp", "node", "npm", "npm-cache", "yarn", "pip",
+        "nuget", ".nuget", "dotnet", "jetbrains", "visualstudio", "vscode",
+        "code", "github", "git", "docker", "kaspersky lab", "eset", "avast software"
+    };
+
+    public IReadOnlyList<Resto> Varrer(
+        IReadOnlyList<InstalledApp> instalados,
+        IProgress<string>? progresso,
+        CancellationToken ct)
+    {
+        // O conjunto de nomes conhecidos vem dos apps instalados e dos seus
+        // fabricantes: "Discord" e "Discord Inc." devem casar com a mesma pasta.
+        var conhecidos = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var app in instalados)
+        {
+            AdicionarTermos(conhecidos, app.Nome);
+
+            if (app.Publisher is not null)
+                AdicionarTermos(conhecidos, app.Publisher);
+
+            if (app.PastaDeInstalacao is not null)
+                conhecidos.Add(Path.GetFileName(app.PastaDeInstalacao.TrimEnd('\\')));
+        }
+
+        var restos = new List<Resto>();
+
+        foreach (var (rotulo, raiz) in Locais())
+        {
+            ct.ThrowIfCancellationRequested();
+
+            if (raiz is null || !Directory.Exists(raiz))
+                continue;
+
+            progresso?.Report($"Procurando restos em {rotulo}");
+
+            foreach (var entrada in FastFind.Listar(raiz))
+            {
+                ct.ThrowIfCancellationRequested();
+
+                if (!entrada.EhPasta)
+                    continue;
+
+                var nome = entrada.Nome;
+
+                if (Ignoradas.Contains(nome) || nome.StartsWith('.'))
+                    continue;
+
+                if (EhConhecida(nome, conhecidos))
+                    continue;
+
+                var caminho = Path.Combine(raiz, nome);
+                var tamanho = TamanhoDaPasta(caminho, ct);
+
+                // Pasta minuscula nao vale o ruido na lista.
+                if (tamanho < 1024 * 1024)
+                    continue;
+
+                restos.Add(new Resto(nome, caminho, tamanho, UltimaModificacao(caminho), rotulo));
+            }
+        }
+
+        _log.Info("Uninstaller", "Restos", null,
+            $"{restos.Count} pastas sem app correspondente, "
+          + $"{GameMode.GameModeModule.Formatar(restos.Sum(r => r.Bytes))}");
+
+        return restos.OrderByDescending(r => r.Bytes).ToList();
+    }
+
+    /// <summary>
+    /// Decide se a pasta pertence a algum app instalado.
+    ///
+    /// Casamento exato sozinho é rígido demais: no primeiro teste real ele
+    /// acusou "BraveSoftware" e "EpicGamesLauncher" como restos, sendo que os
+    /// dois estão instalados — só escrevem a pasta sem os espaços do nome. Por
+    /// isso a comparação normaliza espaços e pontuação, e aceita prefixo a
+    /// partir de 5 caracteres.
+    ///
+    /// Falso positivo aqui é pior que falso negativo: deixar de listar um resto
+    /// custa espaço, apontar um app ativo como resto custa os dados do usuário.
+    /// </summary>
+    private static bool EhConhecida(string pasta, HashSet<string> conhecidos)
+    {
+        if (conhecidos.Contains(pasta))
+            return true;
+
+        var alvo = Normalizar(pasta);
+
+        if (alvo.Length < 3)
+            return true;
+
+        foreach (var conhecido in conhecidos)
+        {
+            var termo = Normalizar(conhecido);
+
+            if (termo.Length < 4)
+                continue;
+
+            if (termo == alvo)
+                return true;
+
+            // "brave" cobre "bravesoftware"; "epicgameslauncher" cobre a pasta
+            // de mesmo nome sem espacos.
+            if (termo.Length >= 5 && alvo.StartsWith(termo, StringComparison.Ordinal))
+                return true;
+
+            if (alvo.Length >= 5 && termo.StartsWith(alvo, StringComparison.Ordinal))
+                return true;
+        }
+
+        return false;
+    }
+
+    private static string Normalizar(string texto)
+    {
+        Span<char> destino = stackalloc char[texto.Length];
+        var tamanho = 0;
+
+        foreach (var c in texto)
+        {
+            if (char.IsLetterOrDigit(c))
+                destino[tamanho++] = char.ToLowerInvariant(c);
+        }
+
+        return new string(destino[..tamanho]);
+    }
+
+    /// <summary>
+    /// Quebra "Discord Inc." em termos aproveitáveis e descarta sufixos de
+    /// razão social, que nunca viram nome de pasta.
+    /// </summary>
+    private static void AdicionarTermos(HashSet<string> destino, string texto)
+    {
+        destino.Add(texto);
+
+        var limpo = texto;
+
+        foreach (var sufixo in new[] { ", Inc.", " Inc.", " Inc", " LLC", " Ltd.", " Ltd",
+                                        " GmbH", " S.A.", " Corporation", " Corp.", " Corp",
+                                        " Software", " Technologies", " Studios", " Entertainment" })
+        {
+            if (limpo.EndsWith(sufixo, StringComparison.OrdinalIgnoreCase))
+                limpo = limpo[..^sufixo.Length].Trim();
+        }
+
+        if (limpo.Length > 2)
+            destino.Add(limpo);
+
+        // A primeira palavra cobre "Epic Games Launcher" contra a pasta "Epic".
+        var primeira = limpo.Split(' ', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
+        if (primeira is { Length: > 3 })
+            destino.Add(primeira);
+    }
+
+    private static IEnumerable<(string Rotulo, string? Raiz)> Locais()
+    {
+        yield return ("AppData\\Roaming", Environment.GetEnvironmentVariable("APPDATA"));
+        yield return ("AppData\\Local", Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
+        yield return ("ProgramData", Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData));
+    }
+
+    private static long TamanhoDaPasta(string pasta, CancellationToken ct)
+    {
+        long total = 0;
+        var pilha = new Stack<string>();
+        pilha.Push(pasta);
+
+        while (pilha.Count > 0)
+        {
+            ct.ThrowIfCancellationRequested();
+            var atual = pilha.Pop();
+
+            foreach (var entrada in FastFind.Listar(atual))
+            {
+                if (entrada.EhPasta)
+                    pilha.Push(Path.Combine(atual, entrada.Nome));
+                else
+                    total += entrada.Tamanho;
+            }
+        }
+
+        return total;
+    }
+
+    private static DateTime UltimaModificacao(string pasta)
+    {
+        try
+        {
+            return Directory.GetLastWriteTime(pasta);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return DateTime.MinValue;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerModule.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerModule.cs
new file mode 100644
index 0000000..67eb726
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerModule.cs
@@ -0,0 +1,725 @@
+using System.Diagnostics;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Modules.Uninstaller;
+
+/// <summary>
+/// Desinstalador (seção 5.3).
+///
+/// Cada app é desinstalado pelo seu próprio desinstalador — o GameBoost nunca
+/// apaga arquivos de programa por conta própria. O que ele faz depois é
+/// procurar o que ficou para trás e oferecer a remoção disso, sempre para a
+/// Lixeira e sempre desmarcado.
+/// </summary>
+public sealed class UninstallerModule : IModule
+{
+    public const string ModuloId = "uninstaller";
+
+    /// <summary>Um app que não sai em 10 minutos não vai sair (seção 5.3).</summary>
+    private static readonly TimeSpan Limite = TimeSpan.FromMinutes(10);
+
+    private readonly AppInventory _inventario;
+    private readonly LeftoverScanner _restos;
+    private readonly WingetService _winget;
+    private readonly IProcessService _processos;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    private IReadOnlyList<InstalledApp> _ultimaLista = Array.Empty<InstalledApp>();
+
+    public UninstallerModule(
+        AppInventory inventario,
+        LeftoverScanner restos,
+        WingetService winget,
+        IProcessService processos,
+        IGameBoostLogger log,
+        IClock relogio)
+    {
+        _inventario = inventario;
+        _restos = restos;
+        _winget = winget;
+        _processos = processos;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string Id => ModuloId;
+    public string Nome => "Aplicativos";
+    public string Descricao => "Lista tudo que está instalado e desinstala em lote, com os restos.";
+
+    public IReadOnlyList<InstalledApp> UltimaLista => _ultimaLista;
+
+    // ------------------------------------------------------------------
+
+    public Task<ScanResult> ScanAsync(IProgress<ModuleProgress>? progress, CancellationToken ct)
+        => Task.Run(() => Varrer(progress, ct), ct);
+
+    private ScanResult Varrer(IProgress<ModuleProgress>? progress, CancellationToken ct)
+    {
+        progress?.Report(new ModuleProgress("Lendo o registro e a Store", 10));
+
+        var apps = _inventario.Listar(medirTamanho: false, ct);
+        _ultimaLista = apps;
+
+        progress?.Report(new ModuleProgress("Medindo o tamanho de cada app", 40));
+
+        // Medir pasta a pasta é o passo caro; só vale para os que têm pasta
+        // propria e confiavel, e em paralelo.
+        var comPasta = apps
+            .Where(a => a.PastaDeInstalacao is not null && PastaConfiavel(a.PastaDeInstalacao!))
+            .ToList();
+
+        Parallel.ForEach(
+            comPasta,
+            new ParallelOptions { MaxDegreeOfParallelism = 4, CancellationToken = ct },
+            app =>
+            {
+                if (app.TamanhoMedido == 0 && Directory.Exists(app.PastaDeInstalacao!))
+                    app.TamanhoMedido = Medir(app.PastaDeInstalacao!, ct);
+            });
+
+        progress?.Report(new ModuleProgress("Montando a lista", 90));
+
+        // Reordenar aqui, e não no inventário: lá o tamanho ainda é só o que o
+        // registro declara. O ARK ocupa 309 GB de verdade e aparecia atrás do
+        // AutoCAD, que declara 4 GB — justo o contrário do que a tela serve para
+        // mostrar.
+        var itens = apps
+            .OrderByDescending(a => a.Tamanho)
+            .ThenBy(a => a.Nome, StringComparer.CurrentCultureIgnoreCase)
+            .Select(MontarItem)
+            .ToList();
+
+        // Somar o tamanho de todos daria numero maior que o disco: varios
+        // apps declaram a MESMA pasta (suites, componentes de um mesmo
+        // produto) e seriam contados uma vez cada. Conta pasta unica.
+        var total = apps
+            .Where(a => a.PastaDeInstalacao is not null)
+            .GroupBy(a => a.PastaDeInstalacao!, StringComparer.OrdinalIgnoreCase)
+            .Sum(g => g.Max(a => a.Tamanho))
+            + apps.Where(a => a.PastaDeInstalacao is null).Sum(a => a.Tamanho);
+
+        var naoUsados = apps.Count(a => a.NuncaUsado && !a.Protegido);
+
+        progress?.Report(new ModuleProgress("Pronto", 100));
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens,
+            Momento = _relogio.Now,
+            Resumo = $"{apps.Count} aplicativos, cerca de {GameModeModule.Formatar(total)} no total. "
+                   + $"{naoUsados} sem registro de uso no último ano.",
+            Avisos = apps.Any(a => a.Sugerido)
+                ? new[] { $"{apps.Count(a => a.Sugerido)} apps parecem bloatware. Aparecem marcados como sugestão, nunca selecionados." }
+                : Array.Empty<string>()
+        };
+    }
+
+    private ActionItem MontarItem(InstalledApp app)
+    {
+        var detalhes = new List<string>();
+
+        if (app.Versao is not null)
+            detalhes.Add($"v{app.Versao}");
+
+        if (app.Publisher is not null)
+            detalhes.Add(app.Publisher);
+
+        detalhes.Add(app.Origem == AppOrigem.Store ? "Microsoft Store" : "Win32");
+        detalhes.Add(app.QuandoUsou);
+
+        if (!app.TemDesinstalacaoSilenciosa && !app.Protegido)
+            detalhes.Add("abre o desinstalador próprio");
+
+        var risco = app.Protegido ? RiskLevel.Alto
+            : app.Sugerido ? RiskLevel.Baixo
+            : RiskLevel.Medio;
+
+        return new ActionItem
+        {
+            Id = $"app:{app.Id}",
+            Categoria = app.Protegido ? "Protegidos"
+                : app.Sugerido ? "Sugestões de bloatware"
+                : app.Origem == AppOrigem.Store ? "Microsoft Store"
+                : "Programas",
+            Titulo = app.Nome,
+            Descricao = string.Join(" · ", detalhes),
+            Risco = risco,
+            GanhoBytes = app.Tamanho,
+            GanhoEstimado = app.Tamanho > 0 ? GameModeModule.Formatar(app.Tamanho) : "tamanho desconhecido",
+
+            // Regra 3: desinstalar apaga configuração e às vezes save. Nada
+            // vem marcado, nem o bloatware mais óbvio.
+            PreMarcado = false,
+
+            Bloqueado = app.Protegido,
+            MotivoBloqueio = app.MotivoDaProtecao,
+            ComoDesfazer = app.Origem == AppOrigem.Store
+                ? "Reinstale pela Microsoft Store. Configurações e dados do app se perdem."
+                : "Só reinstalando pelo instalador original. Configurações e dados se perdem.",
+            Payload = app
+        };
+    }
+
+    /// <summary>
+    /// Recusa pasta generica como se fosse do app. Varios instaladores gravam
+    /// InstallLocation apontando para "C:\Program Files" ou para a raiz do
+    /// disco; medir aquilo atribuiria o disco inteiro a um unico programa, e foi
+    /// o que fez o resumo somar 1812 GB num disco de 953 GB.
+    /// </summary>
+    internal static bool PastaConfiavel(string pasta)
+    {
+        var limpo = pasta.Trim().TrimEnd('\\', '/');
+
+        if (limpo.Length < 4)
+            return false;
+
+        // Raiz de volume: "C:" ou "C:\".
+        if (limpo.Length <= 3 && limpo.Contains(':'))
+            return false;
+
+        var genericas = new[]
+        {
+            Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
+            Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86),
+            Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles),
+            Environment.GetFolderPath(Environment.SpecialFolder.Windows),
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)
+        };
+
+        foreach (var generica in genericas)
+        {
+            if (!string.IsNullOrWhiteSpace(generica)
+                && limpo.Equals(generica.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static long Medir(string pasta, CancellationToken ct)
+    {
+        long total = 0;
+        var pilha = new Stack<string>();
+        pilha.Push(pasta);
+
+        while (pilha.Count > 0)
+        {
+            ct.ThrowIfCancellationRequested();
+            var atual = pilha.Pop();
+
+            foreach (var entrada in FastFind.Listar(atual))
+            {
+                if (entrada.EhPasta)
+                    pilha.Push(Path.Combine(atual, entrada.Nome));
+                else
+                    total += entrada.Tamanho;
+            }
+        }
+
+        return total;
+    }
+
+    // ------------------------------------------------------------------
+    // Desinstalação
+    // ------------------------------------------------------------------
+
+    public Task<ApplyResult> ApplyAsync(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+        => Task.Run(() => Desinstalar(itemIds, dryRun, ct), ct);
+
+    private ApplyResult Desinstalar(IReadOnlyList<string> itemIds, bool dryRun, CancellationToken ct)
+    {
+        var acoes = new List<AppliedAction>();
+        long liberado = 0;
+        var removidos = 0;
+
+        foreach (var itemId in itemIds)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var id = itemId.StartsWith("app:", StringComparison.Ordinal) ? itemId[4..] : itemId;
+            var app = _ultimaLista.FirstOrDefault(a => a.Id == id);
+
+            if (app is null)
+            {
+                acoes.Add(new AppliedAction(itemId, false, "App não encontrado: varra de novo.", null));
+                continue;
+            }
+
+            // Segunda checagem antes de agir: a lista pode ter vindo de um scan
+            // antigo, e protegido continua protegido.
+            if (app.Protegido)
+            {
+                acoes.Add(new AppliedAction(itemId, false,
+                    $"{app.Nome} está protegido: {app.MotivoDaProtecao}", null));
+                continue;
+            }
+
+            if (dryRun)
+            {
+                acoes.Add(new AppliedAction(itemId, true,
+                    $"Desinstalaria {app.Nome} ({GameModeModule.Formatar(app.Tamanho)}) "
+                    + $"{(app.TemDesinstalacaoSilenciosa ? "em silêncio" : "abrindo o desinstalador próprio")}.",
+                    null));
+                continue;
+            }
+
+            if (EstaEmExecucao(app))
+            {
+                acoes.Add(new AppliedAction(itemId, false,
+                    $"{app.Nome} está em execução. Feche antes de desinstalar.", null));
+                continue;
+            }
+
+            var resultado = Executar(app, ct);
+            acoes.Add(new AppliedAction(itemId, resultado.Sucesso, resultado.Detalhe, null));
+
+            if (resultado.Sucesso)
+            {
+                removidos++;
+                liberado += app.Tamanho;
+            }
+        }
+
+        _log.Info(ModuloId, dryRun ? "Desinstalar (dry-run)" : "Desinstalar", null,
+            $"{removidos} de {itemIds.Count}, {GameModeModule.Formatar(liberado)}");
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? "Simulação concluída. Nada foi desinstalado."
+                : $"{removidos} de {itemIds.Count} desinstalados.",
+            GanhoMedido = dryRun
+                ? "Dry-run não mede ganho."
+                : removidos == 0
+                    ? "Nada foi removido."
+                    : $"Cerca de {GameModeModule.Formatar(liberado)} liberados. "
+                    + "Varra de novo para ver o que ficou para trás."
+        };
+    }
+
+    private bool EstaEmExecucao(InstalledApp app)
+    {
+        if (app.PastaDeInstalacao is null)
+            return false;
+
+        try
+        {
+            return _processos.GetProcesses().Any(p =>
+                p.ExecutablePath is not null
+                && p.ExecutablePath.StartsWith(app.PastaDeInstalacao, StringComparison.OrdinalIgnoreCase));
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException)
+        {
+            return false;
+        }
+    }
+
+    private (bool Sucesso, string Detalhe) Executar(InstalledApp app, CancellationToken ct)
+    {
+        try
+        {
+            if (app.Origem == AppOrigem.Store && app.PacoteDaStore is not null)
+                return RemoverDaStore(app, ct);
+
+            if (app.CodigoMsi is not null)
+                return Rodar("msiexec.exe", $"/x {app.CodigoMsi} /qn /norestart", app, ct);
+
+            if (!string.IsNullOrWhiteSpace(app.ComandoSilencioso))
+            {
+                var (exe, args) = Separar(app.ComandoSilencioso!);
+                return Rodar(exe, args, app, ct);
+            }
+
+            if (!string.IsNullOrWhiteSpace(app.Comando))
+            {
+                // Sem comando silencioso, o desinstalador do app abre a própria
+                // janela. O GameBoost não fica esperando: o usuário conduz.
+                var (exe, args) = Separar(app.Comando!);
+
+                Process.Start(new ProcessStartInfo
+                {
+                    FileName = exe,
+                    Arguments = args,
+                    UseShellExecute = true
+                });
+
+                return (true, $"{app.Nome}: o desinstalador do próprio app foi aberto. "
+                            + "Conclua por ele e varra de novo.");
+            }
+
+            return (false, $"{app.Nome} não informa como ser desinstalado.");
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception
+                                      or InvalidOperationException
+                                      or FileNotFoundException)
+        {
+            _log.Error(ModuloId, "Desinstalar", app.Nome, ex.Message, ex);
+            return (false, $"{app.Nome}: {ex.Message}");
+        }
+    }
+
+    private (bool, string) RemoverDaStore(InstalledApp app, CancellationToken ct)
+    {
+        var comando = $"$ProgressPreference='SilentlyContinue'; "
+                    + $"Remove-AppxPackage -Package '{app.PacoteDaStore}' -ErrorAction Stop";
+
+        var codificado = Convert.ToBase64String(System.Text.Encoding.Unicode.GetBytes(comando));
+
+        return Rodar("powershell.exe",
+            $"-NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand {codificado}", app, ct);
+    }
+
+    private (bool, string) Rodar(string executavel, string argumentos, InstalledApp app, CancellationToken ct)
+    {
+        var info = new ProcessStartInfo
+        {
+            FileName = executavel,
+            Arguments = argumentos,
+            UseShellExecute = false,
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            CreateNoWindow = true
+        };
+
+        using var processo = Process.Start(info);
+
+        if (processo is null)
+            return (false, $"{app.Nome}: não foi possível iniciar a desinstalação.");
+
+        // Os dois fluxos precisam de leitor, senão o processo trava quando um
+        // deles enche.
+        var saida = processo.StandardOutput.ReadToEndAsync(ct);
+        var erro = processo.StandardError.ReadToEndAsync(ct);
+
+        if (!processo.WaitForExit((int)Limite.TotalMilliseconds))
+        {
+            processo.Kill(entireProcessTree: true);
+            return (false, $"{app.Nome}: passou de {Limite.TotalMinutes:0} minutos e foi interrompido.");
+        }
+
+        var codigo = processo.ExitCode;
+
+        // 0 é sucesso; 3010 é sucesso pedindo reinício; 1605 é "já não estava
+        // instalado", que para o usuário dá no mesmo.
+        return codigo switch
+        {
+            0 => (true, $"{app.Nome} desinstalado."),
+            3010 => (true, $"{app.Nome} desinstalado. Reinicie para concluir."),
+            1605 => (true, $"{app.Nome} já não estava instalado."),
+            1602 => (false, $"{app.Nome}: a desinstalação foi cancelada."),
+            _ => (false, $"{app.Nome}: o desinstalador terminou com código {codigo}. "
+                       + Primeira(erro.GetAwaiter().GetResult()))
+        };
+    }
+
+    private static string Primeira(string texto)
+    {
+        var linha = texto.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
+        return string.IsNullOrWhiteSpace(linha) ? string.Empty : linha.Trim();
+    }
+
+    /// <summary>Separa "C:\App\unins.exe /S" em executável e argumentos, respeitando aspas.</summary>
+    internal static (string Executavel, string Argumentos) Separar(string comando)
+    {
+        var texto = comando.Trim();
+
+        if (texto.StartsWith('"'))
+        {
+            var fim = texto.IndexOf('"', 1);
+
+            if (fim > 0)
+                return (texto[1..fim], fim + 1 < texto.Length ? texto[(fim + 1)..].Trim() : string.Empty);
+        }
+
+        // Sem aspas: o executável vai até o ".exe".
+        var indice = texto.IndexOf(".exe", StringComparison.OrdinalIgnoreCase);
+
+        if (indice > 0)
+        {
+            var corte = indice + 4;
+            return (texto[..corte], corte < texto.Length ? texto[corte..].Trim() : string.Empty);
+        }
+
+        var espaco = texto.IndexOf(' ');
+        return espaco > 0 ? (texto[..espaco], texto[(espaco + 1)..]) : (texto, string.Empty);
+    }
+
+    // ------------------------------------------------------------------
+
+    /// <summary>
+    /// Desinstalação não se desfaz. Dizer isso é mais honesto que oferecer um
+    /// botão que não funciona (regra 4).
+    /// </summary>
+    public Task<ApplyResult> RevertAsync(IReadOnlyList<string> changeIds, bool dryRun, CancellationToken ct)
+        => Task.FromResult(new ApplyResult
+        {
+            ModuloId = ModuloId,
+            DryRun = dryRun,
+            Resumo = "Desinstalação não tem reversão automática.",
+            GanhoMedido = "Para voltar atrás é preciso reinstalar o app. "
+                        + "Se você criou um ponto de restauração antes, ele também serve."
+        });
+
+    // ==================================================================
+    // Aba "Atualizações" (winget)
+    // ==================================================================
+
+    private IReadOnlyList<AtualizacaoDisponivel> _ultimasAtualizacoes = Array.Empty<AtualizacaoDisponivel>();
+
+    public IReadOnlyList<AtualizacaoDisponivel> UltimasAtualizacoes => _ultimasAtualizacoes;
+
+    public WingetService Winget => _winget;
+
+    /// <summary>
+    /// Lista o que tem versão nova, já classificado e com o que estiver aberto
+    /// marcado como tal.
+    ///
+    /// O winget **não** é chamado na varredura principal de propósito: ele
+    /// consulta a rede e leva dezenas de segundos na primeira vez do dia.
+    /// Amarrar isso à lista de apps instalados faria a tela inteira esperar por
+    /// uma informação que nem todo mundo abriu para ver.
+    /// </summary>
+    public async Task<ScanResult> VarrerAtualizacoesAsync(IProgress<ModuleProgress>? progresso, CancellationToken ct)
+    {
+        progresso?.Report(new ModuleProgress("Procurando o winget", 10));
+
+        if (await _winget.DetectarAsync(ct) is null)
+        {
+            return new ScanResult
+            {
+                ModuloId = ModuloId,
+                Momento = _relogio.Now,
+                Resumo = "O winget não está instalado nesta máquina.",
+                Avisos = new[]
+                {
+                    "O winget vem junto com o App Installer, da Microsoft. Sem ele esta aba "
+                  + "não tem como funcionar. O botão abre a página dele na Microsoft Store."
+                }
+            };
+        }
+
+        progresso?.Report(new ModuleProgress("Consultando o winget (pode demorar)", 30));
+
+        var lista = await _winget.ListarAsync(ct);
+        _ultimasAtualizacoes = lista;
+
+        progresso?.Report(new ModuleProgress("Cruzando com os apps instalados", 80));
+
+        // Quais estão rodando agora: atualizar app aberto falha ou, pior, mata
+        // o que o usuário estava usando.
+        var rodando = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        try
+        {
+            foreach (var processo in _processos.GetProcesses())
+                rodando.Add(processo.Name);
+        }
+        catch (Exception ex) when (ex is InvalidOperationException)
+        {
+            _log.Warn(ModuloId, "Atualizacoes", null, ex.Message);
+        }
+
+        var itens = lista.Select(a => MontarAtualizacao(a, rodando)).ToList();
+
+        progresso?.Report(new ModuleProgress("Pronto", 100));
+
+        var seguranca = lista.Count(UpdateCatalog.EhDeSeguranca);
+        var sozinhos = lista.Count(a => UpdateCatalog.Classificar(a) == ClasseDeAtualizacao.AtualizaSozinho);
+
+        var avisos = new List<string>();
+
+        if (seguranca > 0)
+        {
+            avisos.Add($"{seguranca} são de programas que abrem arquivo vindo da internet "
+                     + "(navegador, compactador, leitor de PDF, Java). Nesses, ficar "
+                     + "desatualizado é problema de segurança, não de conforto.");
+        }
+
+        if (sozinhos > 0)
+        {
+            avisos.Add($"{sozinhos} se atualizam sozinhos e aparecem marcados assim. "
+                     + "Forçar pelo winget pode brigar com o atualizador do próprio app.");
+        }
+
+        return new ScanResult
+        {
+            ModuloId = ModuloId,
+            Itens = itens,
+            Momento = _relogio.Now,
+            Resumo = lista.Count == 0
+                ? "Tudo em dia: o winget não encontrou atualização pendente."
+                : $"{lista.Count} aplicativos com versão nova disponível.",
+            Avisos = avisos
+        };
+    }
+
+    private ActionItem MontarAtualizacao(AtualizacaoDisponivel a, IReadOnlySet<string> rodando)
+    {
+        var classe = UpdateCatalog.Classificar(a);
+        var seguranca = UpdateCatalog.EhDeSeguranca(a);
+
+        // O executável do app não vem na tabela do winget. O que dá para
+        // comparar é o nome, e só quando ele é específico o bastante: um nome de
+        // três letras casaria com qualquer coisa.
+        var primeiraPalavra = a.Nome.Split(' ', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? string.Empty;
+
+        var aberto = primeiraPalavra.Length >= 4
+                     && rodando.Any(nome => nome.StartsWith(primeiraPalavra, StringComparison.OrdinalIgnoreCase));
+
+        var detalhes = new List<string>
+        {
+            a.VersaoIncerta ? $"versão instalada desconhecida, repositório tem {a.VersaoNova}"
+                            : $"{a.VersaoAtual} para {a.VersaoNova}"
+        };
+
+        detalhes.Add(a.DaStore ? "Microsoft Store" : "winget");
+
+        if (seguranca)
+            detalhes.Add("atualização de segurança");
+
+        if (aberto)
+            detalhes.Add($"{primeiraPalavra} parece estar aberto — feche antes");
+
+        var explicacao = UpdateCatalog.Explicacao(classe);
+
+        if (explicacao.Length > 0)
+            detalhes.Add(explicacao);
+
+        var risco = classe switch
+        {
+            ClasseDeAtualizacao.Driver => RiskLevel.Alto,
+            ClasseDeAtualizacao.Runtime => RiskLevel.Medio,
+            ClasseDeAtualizacao.AtualizaSozinho => RiskLevel.Medio,
+            ClasseDeAtualizacao.Incerta => RiskLevel.Medio,
+            _ => RiskLevel.Baixo
+        };
+
+        return new ActionItem
+        {
+            Id = $"update:{a.Id}",
+            Categoria = UpdateCatalog.Categoria(classe),
+            Titulo = a.Nome,
+            Descricao = string.Join(" · ", detalhes),
+            Risco = risco,
+            GanhoEstimado = a.VersaoNova,
+
+            // Regra 3: nem a atualização de segurança vem marcada. Instalar
+            // versão nova pode quebrar o que funcionava, e a escolha é de quem
+            // usa a máquina.
+            PreMarcado = false,
+
+            // Driver é o único bloqueado: o GameBoost não instala driver, e
+            // isso vale também quando o winget se oferece para fazer.
+            Bloqueado = classe == ClasseDeAtualizacao.Driver,
+            MotivoBloqueio = classe == ClasseDeAtualizacao.Driver
+                ? UpdateCatalog.Explicacao(ClasseDeAtualizacao.Driver)
+                : null,
+            RotuloBloqueio = "Driver",
+
+            ComoDesfazer = a.DaStore
+                ? "A Microsoft Store não permite voltar a uma versão anterior."
+                : "Não há como voltar a versão pelo winget. Se a versão nova der problema, "
+                + "reinstale a antiga pelo instalador do fabricante.",
+            Payload = a
+        };
+    }
+
+    /// <summary>
+    /// Atualiza um app por vez, em sequência, com progresso por item.
+    ///
+    /// `winget upgrade --all` faria tudo de uma vez e seria mais curto, mas
+    /// perde o que importa: com `--all`, um app que falha some no meio da saída
+    /// e não dá para dizer ao usuário qual foi nem por quê.
+    /// </summary>
+    public async Task<ApplyResult> AtualizarAsync(
+        IReadOnlyList<string> itemIds, bool dryRun, IProgress<ModuleProgress>? progresso, CancellationToken ct)
+    {
+        var alvos = itemIds
+            .Where(id => id.StartsWith("update:", StringComparison.Ordinal))
+            .Select(id => id["update:".Length..])
+            .Select(id => _ultimasAtualizacoes.FirstOrDefault(a => a.Id == id))
+            .Where(a => a is not null)
+            .Select(a => a!)
+            .ToList();
+
+        var acoes = new List<AppliedAction>();
+
+        for (var i = 0; i < alvos.Count; i++)
+        {
+            ct.ThrowIfCancellationRequested();
+
+            var alvo = alvos[i];
+
+            progresso?.Report(new ModuleProgress(
+                $"Atualizando {alvo.Nome} ({i + 1} de {alvos.Count})",
+                alvos.Count == 0 ? 100 : (i + 1) * 100 / alvos.Count));
+
+            if (UpdateCatalog.Classificar(alvo) == ClasseDeAtualizacao.Driver)
+            {
+                acoes.Add(new AppliedAction($"update:{alvo.Id}", false,
+                    $"{alvo.Nome} é driver: o GameBoost não instala driver.", null));
+                continue;
+            }
+
+            var registro = await _winget.AtualizarAsync(alvo, dryRun, ct);
+
+            acoes.Add(new AppliedAction(
+                $"update:{alvo.Id}",
+                registro.Sucesso,
+                registro.Sucesso
+                    ? $"{alvo.Nome} atualizado para {alvo.VersaoNova}."
+                    : $"{alvo.Nome}: {registro.Erro}",
+                null));
+        }
+
+        var ok = acoes.Count(a => a.Sucesso);
+
+        return new ApplyResult
+        {
+            ModuloId = ModuloId,
+            Acoes = acoes,
+            DryRun = dryRun,
+            Resumo = dryRun
+                ? $"Simulação: {acoes.Count} aplicativos seriam atualizados."
+                : $"{ok} de {acoes.Count} aplicativos atualizados.",
+            GanhoMedido = acoes.Any(a => !a.Sucesso)
+                ? $"O log detalhado do winget fica em {WingetService.PastaDeLogs()}"
+                : string.Empty
+        };
+    }
+
+    /// <summary>Restos deixados por apps já removidos (aba própria, seção 5.3).</summary>
+    public IReadOnlyList<Resto> VarrerRestos(IProgress<string>? progresso, CancellationToken ct)
+        => _restos.Varrer(_ultimaLista, progresso, ct);
+
+    /// <summary>Manda restos para a Lixeira. Nunca apaga de vez.</summary>
+    public (int Removidos, long Bytes) RemoverRestos(IReadOnlyList<Resto> escolhidos)
+    {
+        if (escolhidos.Count == 0)
+            return (0, 0);
+
+        var caminhos = escolhidos.Select(r => r.Caminho).ToList();
+        var bytes = escolhidos.Sum(r => r.Bytes);
+
+        var ok = RecycleBinBridge.ParaLixeira(caminhos);
+
+        _log.Info(ModuloId, "RemoverRestos", null,
+            ok ? $"{caminhos.Count} pastas para a Lixeira, {GameModeModule.Formatar(bytes)}"
+               : "o Windows recusou mover para a Lixeira");
+
+        return ok ? (caminhos.Count, bytes) : (0, 0);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerProtection.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerProtection.cs
new file mode 100644
index 0000000..2b3efc4
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UninstallerProtection.cs
@@ -0,0 +1,138 @@
+namespace GameBoost.Core.Modules.Uninstaller;
+
+/// <summary>
+/// Quem nunca pode ser desinstalado, e quem é apenas sugerido (seção 5.3).
+/// Documentado em docs/PROTECAO.md.
+/// </summary>
+public static class UninstallerProtection
+{
+    /// <summary>
+    /// Trechos de nome que tornam o app intocável. Remover qualquer um destes
+    /// quebra outros programas, o Windows ou o próprio jogo.
+    /// </summary>
+    private static readonly (string Trecho, string Motivo)[] Intocaveis =
+    {
+        ("visual c++", "Outros programas dependem deste runtime para abrir."),
+        ("vc_redist", "Outros programas dependem deste runtime para abrir."),
+        ("visual studio", "Remova pelo instalador do Visual Studio, não por aqui."),
+        (".net runtime", "Programas em .NET param de abrir sem ele."),
+        (".net host", "Programas em .NET param de abrir sem ele."),
+        (".net sdk", "Necessário para compilar. Remova pelo instalador oficial."),
+        ("asp.net core", "Programas em .NET param de abrir sem ele."),
+        ("windows desktop runtime", "Programas em .NET param de abrir sem ele."),
+        ("directx", "Jogos param de abrir sem o DirectX."),
+        ("microsoft edge", "O WebView2 depende dele, e muitos aplicativos usam o WebView2."),
+        ("webview2", "Vários aplicativos usam o WebView2 para desenhar a interface."),
+        ("xbox identity", "Jogos do Game Pass e anti-cheats da Microsoft dependem disso."),
+        ("gaming services", "Jogos do Game Pass dependem disso."),
+        ("nvidia", "Componente de driver de vídeo. Use o instalador da NVIDIA."),
+        ("amd software", "Componente de driver de vídeo. Use o instalador da AMD."),
+        ("radeon", "Componente de driver de vídeo. Use o instalador da AMD."),
+        ("intel(r)", "Componente de driver ou de chipset."),
+        ("realtek", "Driver de áudio ou de rede."),
+        ("audio driver", "Driver de áudio."),
+        ("chipset", "Driver de chipset."),
+        ("windows sdk", "Ferramenta de desenvolvimento. Remova pelo instalador oficial."),
+        ("update for windows", "Atualização do Windows."),
+        ("security update", "Atualização de segurança do Windows."),
+        ("microsoft store", "Componente do Windows."),
+        ("app installer", "Componente do Windows."),
+        ("windows app runtime", "Aplicativos modernos dependem dele.")
+    };
+
+    /// <summary>
+    /// Antivírus: desinstalar pelo GameBoost deixaria a máquina desprotegida e
+    /// costuma exigir a ferramenta do próprio fabricante.
+    /// </summary>
+    private static readonly string[] Seguranca =
+    {
+        "kaspersky", "avast", "avg ", "bitdefender", "mcafee", "norton", "eset",
+        "sophos", "malwarebytes", "trend micro", "f-secure", "panda security",
+        "crowdstrike", "sentinelone", "webroot", "carbon black"
+    };
+
+    /// <summary>
+    /// Bloatware conhecido (seção 5.3). Aparece com sugestão, **nunca**
+    /// pré-marcado: o que é bloat para um é ferramenta para outro.
+    /// </summary>
+    private static readonly string[] Bloatware =
+    {
+        "candy crush", "bubble witch", "march of empires", "royal revolt",
+        "microsoft solitaire", "3d viewer", "mixed reality portal",
+        "clipchamp", "linkedin", "booking.com", "disney", "netflix",
+        "spotify music", "tiktok", "instagram", "facebook", "twitter",
+        "feedback hub", "get help", "tips", "microsoft news", "microsoft to do",
+        "mcafee livesafe", "norton security scan", "wildtangent",
+        "hp wolf", "hp jumpstarts", "dell customer connect", "lenovo now",
+        "cortana", "power automate", "microsoft family", "skype", "onenote for windows",
+        "movie moments", "paint 3d", "print 3d", "your phone", "phone link"
+    };
+
+    /// <summary>
+    /// Pacotes da Store que o Windows marca como não removíveis, ou que
+    /// quebram a interface se saírem.
+    /// </summary>
+    private static readonly string[] PacotesDeSistema =
+    {
+        "microsoft.windows.shellexperiencehost", "microsoft.windows.startmenuexperiencehost",
+        "microsoft.windows.search", "microsoft.ui.xaml", "microsoft.vclibs",
+        "microsoft.net.native", "microsoft.windowsstore", "microsoft.desktopappinstaller",
+        "microsoft.windows.immersivecontrolpanel", "microsoft.accountscontrol",
+        "microsoft.windows.cloudexperiencehost", "microsoft.windows.contentdeliverymanager",
+        "microsoft.xboxgamecallableui", "microsoft.xboxidentityprovider",
+        "microsoft.gamingservices", "windows.immersivecontrolpanel",
+        "microsoft.sechealthui", "microsoft.windowsappruntime"
+    };
+
+    /// <summary>Marca o app como protegido ou sugerido. Roda uma vez por app na varredura.</summary>
+    public static void Avaliar(InstalledApp app)
+    {
+        var nome = app.Nome.ToLowerInvariant();
+        var publisher = (app.Publisher ?? string.Empty).ToLowerInvariant();
+        var pacote = (app.PacoteDaStore ?? string.Empty).ToLowerInvariant();
+
+        foreach (var (trecho, motivo) in Intocaveis)
+        {
+            if (nome.Contains(trecho, StringComparison.Ordinal))
+            {
+                app.Protegido = true;
+                app.MotivoDaProtecao = motivo;
+                return;
+            }
+        }
+
+        foreach (var av in Seguranca)
+        {
+            if (nome.Contains(av, StringComparison.Ordinal) || publisher.Contains(av, StringComparison.Ordinal))
+            {
+                app.Protegido = true;
+                app.MotivoDaProtecao = "É o seu antivírus. Remover daqui deixaria a máquina "
+                                     + "desprotegida; use a ferramenta do próprio fabricante.";
+                return;
+            }
+        }
+
+        if (app.Origem == AppOrigem.Store)
+        {
+            foreach (var sistema in PacotesDeSistema)
+            {
+                if (pacote.Contains(sistema, StringComparison.Ordinal))
+                {
+                    app.Protegido = true;
+                    app.MotivoDaProtecao = "Componente do Windows. Remover quebra partes da interface.";
+                    return;
+                }
+            }
+        }
+
+        // Sugerido não é o mesmo que marcado: o app entra na lista com a
+        // sugestão visível e a caixa vazia (regra 3).
+        app.Sugerido = Bloatware.Any(b => nome.Contains(b, StringComparison.Ordinal));
+    }
+
+    /// <summary>Para a documentação e os testes saberem o que está coberto.</summary>
+    public static IReadOnlyList<string> TrechosIntocaveis
+        => Intocaveis.Select(i => i.Trecho).ToList();
+
+    public static IReadOnlyList<string> TrechosDeBloatware => Bloatware;
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UpdateCatalog.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UpdateCatalog.cs
new file mode 100644
index 0000000..1321c76
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/UpdateCatalog.cs
@@ -0,0 +1,189 @@
+namespace GameBoost.Core.Modules.Uninstaller;
+
+/// <summary>
+/// Como cada atualização deve ser tratada (seção 5.3, aba "Atualizações").
+/// </summary>
+public enum ClasseDeAtualizacao
+{
+    /// <summary>Atualização comum: o winget baixa, instala e pronto.</summary>
+    Normal,
+
+    /// <summary>
+    /// O app tem atualizador próprio e se vira sozinho. Forçar pelo winget pode
+    /// brigar com o atualizador dele.
+    /// </summary>
+    AtualizaSozinho,
+
+    /// <summary>Runtime ou componente do qual outros programas dependem.</summary>
+    Runtime,
+
+    /// <summary>Driver. O GameBoost nunca instala driver.</summary>
+    Driver,
+
+    /// <summary>O winget não sabe a versão instalada e pode reinstalar à toa.</summary>
+    Incerta
+}
+
+/// <summary>
+/// Classificação das atualizações do winget.
+///
+/// A lista de "atualiza sozinho" é a parte que mais importa. Steam, Discord e
+/// navegador se atualizam em segundo plano e, se o winget instalar por cima, o
+/// resultado pode ser duas versões brigando ou uma instalação quebrada. O spec
+/// manda mostrá-los com a tag e explicar; aqui a tag também carrega o porquê.
+/// </summary>
+public static class UpdateCatalog
+{
+    /// <summary>
+    /// Ids do winget de apps com atualizador próprio. A comparação é por
+    /// prefixo do id, que é estável: "Valve.Steam", "Mozilla.Firefox".
+    /// </summary>
+    private static readonly string[] AtualizamSozinhos =
+    {
+        // Launchers de jogo
+        "Valve.Steam", "EpicGames.EpicGamesLauncher", "XP99VR1BPSBQJ2",
+        "Blizzard.BattleNet", "ElectronicArts.EADesktop", "Ubisoft.Connect",
+        "GOG.Galaxy", "RiotGames.", "Nvidia.GeForceExperience", "Nvidia.GeForceNow",
+        "Nvidia.NvidiaApp", "Amazon.Games", "Rockstar.RockstarGamesLauncher",
+
+        // Navegadores
+        "Google.Chrome", "Google.ChromeRemoteDesktopHost", "Mozilla.Firefox",
+        "Microsoft.Edge", "Opera.Opera", "Brave.Brave", "Vivaldi.Vivaldi",
+
+        // Comunicação e mídia
+        "Discord.Discord", "Spotify.Spotify", "Zoom.Zoom", "SlackTechnologies.Slack",
+        "Telegram.TelegramDesktop", "WhatsApp.WhatsApp",
+
+        // Ferramentas com auto-update agressivo
+        "Obsidian.Obsidian", "Docker.DockerDesktop", "Microsoft.VisualStudioCode",
+        "Google.Antigravity", "Anysphere.Cursor", "Notion.Notion", "Figma.Figma",
+        "Unity.UnityHub", "JetBrains.Toolbox", "Postman.Postman"
+    };
+
+    /// <summary>Runtimes e componentes dos quais outros programas dependem.</summary>
+    private static readonly string[] Runtimes =
+    {
+        "Microsoft.VCRedist", "Microsoft.DotNet", "Microsoft.WindowsDesktopRuntime",
+        "Microsoft.AspNetCore", "Oracle.JavaRuntimeEnvironment", "Oracle.JDK",
+        "EclipseAdoptium.Temurin", "Microsoft.OpenJDK", "Microsoft.DirectX",
+        "Microsoft.EdgeWebView", "Microsoft.AppInstaller", "Microsoft.WSL",
+        "Microsoft.VCLibs", "Python.Launcher"
+    };
+
+    private static readonly string[] Drivers =
+    {
+        "Nvidia.GeForceDriver", "AMD.", "Intel.", "Realtek.", "Nefarius.",
+        "Logitech.", "Razer.", "Corsair.", "SteelSeries."
+    };
+
+    /// <summary>
+    /// Apps cuja desatualização é problema de **segurança**, não de conforto.
+    /// São os que abrem arquivo vindo da internet: navegador, compactador,
+    /// leitor de PDF, runtime de Java.
+    ///
+    /// Esta lista vira o Finding do Diagnóstico ("N desatualizados, M de
+    /// segurança"), e é o motivo de a aba existir. O resto é higiene.
+    /// </summary>
+    private static readonly string[] Seguranca =
+    {
+        "Google.Chrome", "Mozilla.Firefox", "Microsoft.Edge", "Opera.Opera",
+        "Brave.Brave", "Vivaldi.Vivaldi",
+        "7zip.7zip", "RARLab.WinRAR", "PeaZip.PeaZip",
+        "Oracle.JavaRuntimeEnvironment", "Oracle.JDK", "EclipseAdoptium.Temurin",
+        "Adobe.Acrobat.Reader", "SumatraPDF.SumatraPDF", "Foxit.FoxitReader",
+        "VideoLAN.VLC", "OpenSSL.", "Git.Git", "OpenVPNTechnologies.OpenVPN",
+        "PuTTY.PuTTY", "WinSCP.WinSCP", "Mozilla.Thunderbird"
+    };
+
+    public static ClasseDeAtualizacao Classificar(AtualizacaoDisponivel a)
+    {
+        if (Bate(a.Id, Drivers))
+            return ClasseDeAtualizacao.Driver;
+
+        if (Bate(a.Id, Runtimes))
+            return ClasseDeAtualizacao.Runtime;
+
+        if (Bate(a.Id, AtualizamSozinhos))
+            return ClasseDeAtualizacao.AtualizaSozinho;
+
+        // A incerteza vem por último: um runtime com versão incerta continua
+        // sendo runtime, e é esse o aviso que importa.
+        return a.VersaoIncerta ? ClasseDeAtualizacao.Incerta : ClasseDeAtualizacao.Normal;
+    }
+
+    public static bool EhDeSeguranca(AtualizacaoDisponivel a) => Bate(a.Id, Seguranca);
+
+    /// <summary>
+    /// Casa o id do winget com um padrao da lista.
+    ///
+    /// Prefixo cru nao serve: "Google.Chrome" casaria com
+    /// "Google.ChromeRemoteDesktopHost", e o host de acesso remoto apareceria
+    /// classificado como navegador e como atualizacao de seguranca. O id do
+    /// winget e hierarquico e separado por ponto, entao o casamento exige
+    /// **fronteira**: ou o id e igual ao padrao, ou continua com um ponto.
+    ///
+    /// Padrao terminado em ponto ("AMD.", "Intel.", "RiotGames.") continua
+    /// sendo prefixo de familia inteira, e isso e proposital.
+    /// </summary>
+    private static bool Bate(string id, string[] lista)
+    {
+        foreach (var padrao in lista)
+        {
+            if (padrao.EndsWith('.'))
+            {
+                if (id.StartsWith(padrao, StringComparison.OrdinalIgnoreCase))
+                    return true;
+
+                continue;
+            }
+
+            if (id.Equals(padrao, StringComparison.OrdinalIgnoreCase))
+                return true;
+
+            if (id.Length > padrao.Length
+                && id[padrao.Length] == '.'
+                && id.StartsWith(padrao, StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static string Categoria(ClasseDeAtualizacao classe) => classe switch
+    {
+        ClasseDeAtualizacao.AtualizaSozinho => "Se atualizam sozinhos",
+        ClasseDeAtualizacao.Runtime => "Runtimes e componentes",
+        ClasseDeAtualizacao.Driver => "Drivers",
+        ClasseDeAtualizacao.Incerta => "O winget não sabe a versão instalada",
+        _ => "Atualizações"
+    };
+
+    /// <summary>Texto que explica, em cada caso, por que tratar diferente.</summary>
+    public static string Explicacao(ClasseDeAtualizacao classe) => classe switch
+    {
+        ClasseDeAtualizacao.AtualizaSozinho =>
+            "Este app se atualiza sozinho. Forçar pelo winget pode conflitar com o "
+          + "atualizador dele e, em alguns casos, instalar uma segunda cópia. O normal é "
+          + "deixar quieto: ele se resolve na próxima vez que abrir.",
+
+        ClasseDeAtualizacao.Runtime =>
+            "Componente do qual outros programas dependem. Atualizar costuma ser seguro, "
+          + "mas se algum programa seu depender da versão antiga, ele pode parar de abrir. "
+          + "Não marque junto com um lote grande: se der problema, você não vai saber qual "
+          + "foi.",
+
+        ClasseDeAtualizacao.Driver =>
+            "Isto é driver. O GameBoost não instala driver, nem pelo winget: driver errado "
+          + "deixa a máquina sem vídeo, sem som ou sem rede, e o desfazer é pelo Modo de "
+          + "Segurança. Baixe pela página do fabricante.",
+
+        ClasseDeAtualizacao.Incerta =>
+            "O winget não conseguiu ler a versão instalada, então ele não sabe se há mesmo "
+          + "atualização — só que a versão do repositório é diferente. Atualizar aqui pode "
+          + "significar reinstalar o que você já tem.",
+
+        _ => string.Empty
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Modules/Uninstaller/WingetService.cs b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/WingetService.cs
new file mode 100644
index 0000000..d5c91d3
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Modules/Uninstaller/WingetService.cs
@@ -0,0 +1,496 @@
+using System.Diagnostics;
+using System.Text;
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Modules.Uninstaller;
+
+/// <summary>Um app com versão nova disponível no winget.</summary>
+public sealed record AtualizacaoDisponivel
+{
+    public required string Nome { get; init; }
+    public required string Id { get; init; }
+    public required string VersaoAtual { get; init; }
+    public required string VersaoNova { get; init; }
+    public required string Fonte { get; init; }
+
+    /// <summary>
+    /// O winget não conseguiu ler a versão instalada. Aparece como "Unknown" ou
+    /// com "&lt;" antes do número: nesses casos ele **não sabe** se há mesmo
+    /// atualização, só que a versão do repositório é diferente.
+    /// </summary>
+    public bool VersaoIncerta { get; init; }
+
+    public bool DaStore => Fonte.Equals("msstore", StringComparison.OrdinalIgnoreCase);
+}
+
+/// <summary>Uma linha do updates-history.json.</summary>
+public sealed class RegistroDeAtualizacao
+{
+    public string Id { get; set; } = string.Empty;
+    public string Nome { get; set; } = string.Empty;
+    public string De { get; set; } = string.Empty;
+    public string Para { get; set; } = string.Empty;
+    public DateTimeOffset Quando { get; set; }
+    public bool Sucesso { get; set; }
+    public int CodigoDeSaida { get; set; }
+    public string? Erro { get; set; }
+}
+
+/// <summary>
+/// Aba "Atualizações" da seção 5.3, em cima do winget.
+///
+/// O winget é o gerenciador de pacotes que a própria Microsoft entrega com o
+/// Windows. Usar ele, em vez de baixar instalador por conta própria, é o que
+/// mantém o GameBoost longe de ser mais um programa que puxa executável da
+/// internet — quem baixa e verifica assinatura é a Microsoft.
+///
+/// **A saída do winget é uma tabela de texto, e isso é o problema desta
+/// classe.** Não há formato estruturado para `winget upgrade`: nem JSON, nem
+/// XML. O que existe é uma tabela de largura fixa cujos cabeçalhos são
+/// traduzidos para o idioma do Windows. Procurar a palavra "Available" quebraria
+/// em português, onde ela é "Disponível".
+///
+/// A saída é lida por **posição de coluna**, calculada a partir da linha de
+/// cabeçalho: onde cada coluna começa não depende de idioma nenhum.
+/// </summary>
+public sealed class WingetService
+{
+    /// <summary>
+    /// Uma listagem pode demorar: a primeira execução do dia baixa o índice das
+    /// fontes. Dois minutos é o suficiente e evita travar a tela para sempre.
+    /// </summary>
+    private static readonly TimeSpan LimiteDeListagem = TimeSpan.FromMinutes(2);
+
+    /// <summary>Uma instalação grande (SDK, runtime) passa fácil de 5 minutos.</summary>
+    private static readonly TimeSpan LimiteDeAtualizacao = TimeSpan.FromMinutes(15);
+
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _relogio;
+
+    public WingetService(AppPaths paths, IFileSystem fs, IGameBoostLogger log, IClock relogio)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+        _relogio = relogio;
+    }
+
+    public string HistoricoFile => Path.Combine(_paths.RootDirectory, "updates-history.json");
+
+    /// <summary>Versão do winget, ou null quando ele não está instalado.</summary>
+    public string? Versao { get; private set; }
+
+    public bool Disponivel => Versao is not null;
+
+    /// <summary>
+    /// Link que abre a Microsoft Store na página do App Installer, que é o
+    /// pacote que traz o winget.
+    /// </summary>
+    public const string LinkDaStore = "ms-windows-store://pdp/?ProductId=9NBLGGH4NNS1";
+
+    // ==================================================================
+    // Disponibilidade
+    // ==================================================================
+
+    public async Task<string?> DetectarAsync(CancellationToken ct)
+    {
+        var resultado = await RodarAsync("--version", TimeSpan.FromSeconds(20), ct);
+
+        if (resultado.CodigoDeSaida != 0 || resultado.Saida.Length == 0)
+        {
+            Versao = null;
+            _log.Info("winget", "Detectar", null, "winget não encontrado nesta máquina");
+            return null;
+        }
+
+        Versao = resultado.Saida.Trim().TrimStart('v');
+        _log.Info("winget", "Detectar", null, $"winget {Versao}");
+        return Versao;
+    }
+
+    // ==================================================================
+    // Listagem
+    // ==================================================================
+
+    public async Task<IReadOnlyList<AtualizacaoDisponivel>> ListarAsync(CancellationToken ct)
+    {
+        if (!Disponivel && await DetectarAsync(ct) is null)
+            return Array.Empty<AtualizacaoDisponivel>();
+
+        var resultado = await RodarAsync(
+            "upgrade --include-unknown --accept-source-agreements --disable-interactivity",
+            LimiteDeListagem, ct);
+
+        // Código diferente de zero aqui é comum e não significa falha: o winget
+        // devolve -1978335212 quando simplesmente não há nada a atualizar.
+        if (resultado.Saida.Length == 0)
+        {
+            _log.Warn("winget", "Listar", null,
+                $"saída vazia, código {resultado.CodigoDeSaida}: {resultado.Erro}");
+            return Array.Empty<AtualizacaoDisponivel>();
+        }
+
+        var lista = Interpretar(resultado.Saida);
+
+        _log.Info("winget", "Listar", null, $"{lista.Count} atualizações disponíveis");
+        return lista;
+    }
+
+    /// <summary>
+    /// Lê a tabela do winget por posição de coluna.
+    ///
+    /// O cabeçalho é a linha imediatamente anterior à régua de tracinhos. As
+    /// colunas começam onde há um caractere visível logo depois de um espaço —
+    /// e é só isso que precisa ser verdade, em qualquer idioma.
+    /// </summary>
+    internal static IReadOnlyList<AtualizacaoDisponivel> Interpretar(string saida)
+    {
+        var linhas = saida.Replace("\r", string.Empty).Split('\n');
+
+        var regua = -1;
+
+        for (var i = 1; i < linhas.Length; i++)
+        {
+            var limpa = Limpar(linhas[i]);
+
+            // A régua tem só tracinhos, e é longa: uma linha com três traços no
+            // meio de um nome de pacote não conta.
+            if (limpa.Length >= 10 && limpa.All(c => c == '-'))
+            {
+                regua = i;
+                break;
+            }
+        }
+
+        if (regua <= 0)
+            return Array.Empty<AtualizacaoDisponivel>();
+
+        var colunas = Colunas(Limpar(linhas[regua - 1]));
+
+        // Cinco colunas: nome, id, versão, disponível, fonte. Menos que isso
+        // significa que a tabela não é a que esperamos.
+        if (colunas.Count < 5)
+            return Array.Empty<AtualizacaoDisponivel>();
+
+        var itens = new List<AtualizacaoDisponivel>();
+
+        for (var i = regua + 1; i < linhas.Length; i++)
+        {
+            var linha = Limpar(linhas[i]);
+
+            if (linha.Trim().Length == 0)
+                continue;
+
+            // O rodapé ("35 upgrades available.") não é uma linha de tabela: ele
+            // não alcança a coluna do id.
+            if (linha.Length < colunas[1] + 1)
+                continue;
+
+            var nome = Fatiar(linha, colunas[0], colunas[1]);
+            var id = Fatiar(linha, colunas[1], colunas[2]);
+            var atual = Fatiar(linha, colunas[2], colunas[3]);
+            var nova = Fatiar(linha, colunas[3], colunas[4]);
+            var fonte = Fatiar(linha, colunas[4], linha.Length);
+
+            if (nome.Length == 0 || id.Length == 0 || nova.Length == 0)
+                continue;
+
+            // Id com espaço no meio é sinal de que a fatia caiu no lugar errado.
+            if (id.Contains(' '))
+                continue;
+
+            itens.Add(new AtualizacaoDisponivel
+            {
+                Nome = nome,
+                Id = id,
+                VersaoAtual = atual,
+                VersaoNova = nova,
+                Fonte = fonte.Length == 0 ? "winget" : fonte,
+                VersaoIncerta = atual.StartsWith('<')
+                                || atual.Equals("Unknown", StringComparison.OrdinalIgnoreCase)
+                                || atual.Equals("Desconhecido", StringComparison.OrdinalIgnoreCase)
+            });
+        }
+
+        return itens;
+    }
+
+    /// <summary>Índices onde cada coluna começa.</summary>
+    private static List<int> Colunas(string cabecalho)
+    {
+        var inicios = new List<int>();
+
+        for (var i = 0; i < cabecalho.Length; i++)
+        {
+            if (cabecalho[i] == ' ')
+                continue;
+
+            if (i == 0 || cabecalho[i - 1] == ' ')
+                inicios.Add(i);
+        }
+
+        return inicios;
+    }
+
+    private static string Fatiar(string linha, int inicio, int fim)
+    {
+        if (inicio >= linha.Length)
+            return string.Empty;
+
+        var real = Math.Min(fim, linha.Length);
+        return linha[inicio..real].Trim();
+    }
+
+    /// <summary>
+    /// Tira o lixo de terminal da linha. O winget desenha barra de progresso com
+    /// backspace e sequências ANSI mesmo com a saída redirecionada, e esses
+    /// bytes deslocariam todas as colunas.
+    /// </summary>
+    private static string Limpar(string linha)
+    {
+        var sb = new StringBuilder(linha.Length);
+
+        for (var i = 0; i < linha.Length; i++)
+        {
+            var c = linha[i];
+
+            if (c == '')
+            {
+                // Sequência ANSI: pula até a letra que a encerra.
+                while (i < linha.Length && !char.IsLetter(linha[i]))
+                    i++;
+
+                continue;
+            }
+
+            if (c is '\b' or '')
+                continue;
+
+            sb.Append(c);
+        }
+
+        return sb.ToString();
+    }
+
+    // ==================================================================
+    // Atualização
+    // ==================================================================
+
+    public async Task<RegistroDeAtualizacao> AtualizarAsync(
+        AtualizacaoDisponivel alvo, bool dryRun, CancellationToken ct)
+    {
+        var registro = new RegistroDeAtualizacao
+        {
+            Id = alvo.Id,
+            Nome = alvo.Nome,
+            De = alvo.VersaoAtual,
+            Para = alvo.VersaoNova,
+            Quando = _relogio.Now
+        };
+
+        if (dryRun)
+        {
+            registro.Sucesso = true;
+            registro.Erro = "Simulação: nada foi instalado.";
+            return registro;
+        }
+
+        // `--id` com `--exact` evita o winget escolher outro pacote de nome
+        // parecido. Sem isso, um id curto pode casar com mais de um e ele
+        // instala o errado ou pede escolha, que numa sessão sem terminal
+        // significa travar.
+        var argumentos =
+            $"upgrade --id {alvo.Id} --exact --silent "
+          + "--accept-package-agreements --accept-source-agreements --disable-interactivity";
+
+        if (alvo.VersaoIncerta)
+            argumentos += " --include-unknown";
+
+        var resultado = await RodarAsync(argumentos, LimiteDeAtualizacao, ct);
+
+        registro.CodigoDeSaida = resultado.CodigoDeSaida;
+        registro.Sucesso = resultado.CodigoDeSaida == 0;
+
+        if (!registro.Sucesso)
+            registro.Erro = Explicar(resultado.CodigoDeSaida, resultado.Erro, resultado.Saida);
+
+        _log.Log(registro.Sucesso ? LogLevel.Info : LogLevel.Warn,
+            "winget", "Atualizar", alvo.Id,
+            registro.Sucesso ? $"{alvo.VersaoAtual} -> {alvo.VersaoNova}" : registro.Erro ?? "falhou");
+
+        Registrar(registro);
+        return registro;
+    }
+
+    /// <summary>
+    /// Traduz o código de saída do winget. Os números dele são inteiros
+    /// negativos enormes e não dizem nada a ninguém; o que o usuário precisa
+    /// saber é se pode tentar de novo.
+    /// </summary>
+    internal static string Explicar(int codigo, string erro, string saida)
+    {
+        var texto = codigo switch
+        {
+            unchecked((int)0x8A150011) => "O pacote já está na versão mais nova.",
+            unchecked((int)0x8A150014) => "Nenhum pacote com esse id foi encontrado na fonte.",
+            unchecked((int)0x8A15002B) => "Este pacote não tem instalador compatível com esta máquina.",
+            unchecked((int)0x8A150045) => "O winget não conseguiu baixar o instalador. Pode ser a rede.",
+            unchecked((int)0x8A15010D) => "A atualização precisa de privilégios de administrador.",
+            unchecked((int)0x8A150056) => "O aplicativo está aberto. Feche e tente de novo.",
+            1602 => "A instalação foi cancelada.",
+            1603 => "O instalador do próprio app falhou.",
+            1618 => "Outra instalação está em andamento. Espere terminar.",
+            _ => $"O winget terminou com o código {codigo}."
+        };
+
+        var detalhe = erro.Trim();
+
+        if (detalhe.Length == 0)
+            detalhe = saida.Trim().Split('\n').LastOrDefault(l => l.Trim().Length > 0)?.Trim() ?? string.Empty;
+
+        return detalhe.Length > 0 && detalhe.Length < 300
+            ? $"{texto} ({detalhe})"
+            : texto;
+    }
+
+    /// <summary>
+    /// Pasta onde o winget grava o log detalhado de cada instalação. É para
+    /// onde apontar quando um update falha por motivo que o código de saída não
+    /// explica.
+    /// </summary>
+    public static string PastaDeLogs()
+    {
+        var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        var pacotes = Path.Combine(local, "Packages");
+
+        if (!Directory.Exists(pacotes))
+            return pacotes;
+
+        try
+        {
+            var pasta = Directory.EnumerateDirectories(pacotes, "Microsoft.DesktopAppInstaller_*")
+                .FirstOrDefault();
+
+            return pasta is null
+                ? pacotes
+                : Path.Combine(pasta, "LocalState", "DiagOutputDir");
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            return pacotes;
+        }
+    }
+
+    // ==================================================================
+    // Histórico
+    // ==================================================================
+
+    public IReadOnlyList<RegistroDeAtualizacao> Historico()
+    {
+        try
+        {
+            if (!_fs.FileExists(HistoricoFile))
+                return Array.Empty<RegistroDeAtualizacao>();
+
+            var json = _fs.ReadAllText(HistoricoFile);
+
+            return JsonSerializer.Deserialize<List<RegistroDeAtualizacao>>(json)
+                   ?? new List<RegistroDeAtualizacao>();
+        }
+        catch (Exception ex) when (ex is JsonException or IOException or UnauthorizedAccessException)
+        {
+            _log.Warn("winget", "Historico", null, ex.Message);
+            return Array.Empty<RegistroDeAtualizacao>();
+        }
+    }
+
+    private void Registrar(RegistroDeAtualizacao registro)
+    {
+        try
+        {
+            var todos = Historico().ToList();
+            todos.Add(registro);
+
+            // Duzentas linhas dão vários meses de histórico e mantêm o arquivo
+            // pequeno o bastante para ser lido de uma vez.
+            if (todos.Count > 200)
+                todos = todos.Skip(todos.Count - 200).ToList();
+
+            _fs.WriteAllText(HistoricoFile,
+                JsonSerializer.Serialize(todos, new JsonSerializerOptions { WriteIndented = true }));
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
+        {
+            _log.Warn("winget", "Registrar", registro.Id, ex.Message);
+        }
+    }
+
+    // ==================================================================
+    // Execução
+    // ==================================================================
+
+    private sealed record ResultadoDoProcesso(int CodigoDeSaida, string Saida, string Erro);
+
+    private async Task<ResultadoDoProcesso> RodarAsync(string argumentos, TimeSpan limite, CancellationToken ct)
+    {
+        try
+        {
+            using var processo = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "winget.exe",
+                    Arguments = argumentos,
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+
+                    // O winget escreve em UTF-8. Sem isto, nome de pacote com
+                    // acento chega quebrado e, pior, com número de bytes
+                    // diferente do de caracteres — o que desalinha as colunas.
+                    StandardOutputEncoding = Encoding.UTF8,
+                    StandardErrorEncoding = Encoding.UTF8
+                }
+            };
+
+            if (!processo.Start())
+                return new ResultadoDoProcesso(-1, string.Empty, "Não foi possível iniciar o winget.");
+
+            // As duas saídas precisam ser lidas em paralelo: se só uma for lida,
+            // o buffer da outra enche e o processo trava esperando alguém ler.
+            // Foi exatamente esse erro que fez o Get-AppxPackage devolver zero
+            // na Fase 4.
+            var lendoSaida = processo.StandardOutput.ReadToEndAsync(ct);
+            var lendoErro = processo.StandardError.ReadToEndAsync(ct);
+
+            using var limiteCt = CancellationTokenSource.CreateLinkedTokenSource(ct);
+            limiteCt.CancelAfter(limite);
+
+            try
+            {
+                await processo.WaitForExitAsync(limiteCt.Token);
+            }
+            catch (OperationCanceledException) when (!ct.IsCancellationRequested)
+            {
+                try { processo.Kill(entireProcessTree: true); } catch { /* já morreu */ }
+
+                return new ResultadoDoProcesso(-1, string.Empty,
+                    $"O winget passou de {limite.TotalMinutes:0} minutos e foi encerrado.");
+            }
+
+            return new ResultadoDoProcesso(processo.ExitCode, await lendoSaida, await lendoErro);
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            // Win32Exception aqui quase sempre é "arquivo não encontrado": o
+            // winget não está instalado.
+            return new ResultadoDoProcesso(-1, string.Empty, ex.Message);
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/Authenticode.cs b/GameBoost/src/GameBoost.Core/Native/Authenticode.cs
new file mode 100644
index 0000000..1d69f15
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/Authenticode.cs
@@ -0,0 +1,136 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Verifica a assinatura digital de um executável com WinVerifyTrust.
+///
+/// É o que o Windows usa para decidir se confia num binário. Melhor que só
+/// extrair o certificado: aqui a assinatura é de fato **validada** — certificado
+/// expirado, revogado ou arquivo adulterado reprovam.
+///
+/// (`X509Certificate.CreateFromSignedFile` faria o trabalho mais curto, mas
+/// está obsoleto desde o .NET 9.)
+/// </summary>
+public static class Authenticode
+{
+    private static readonly Guid WINTRUST_ACTION_GENERIC_VERIFY_V2 =
+        new("00AAC56B-CD44-11d0-8CC2-00C04FC295EE");
+
+    private const uint WTD_UI_NONE = 2;
+    private const uint WTD_REVOKE_NONE = 0;
+    private const uint WTD_CHOICE_FILE = 1;
+    private const uint WTD_STATEACTION_VERIFY = 1;
+    private const uint WTD_STATEACTION_CLOSE = 2;
+    private const uint WTD_SAFER_FLAG = 0x100;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WINTRUST_FILE_INFO
+    {
+        public uint cbStruct;
+        [MarshalAs(UnmanagedType.LPWStr)] public string pcwszFilePath;
+        public IntPtr hFile;
+        public IntPtr pgKnownSubject;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WINTRUST_DATA
+    {
+        public uint cbStruct;
+        public IntPtr pPolicyCallbackData;
+        public IntPtr pSIPClientData;
+        public uint dwUIChoice;
+        public uint fdwRevocationChecks;
+        public uint dwUnionChoice;
+        public IntPtr pFile;
+        public uint dwStateAction;
+        public IntPtr hWVTStateData;
+        [MarshalAs(UnmanagedType.LPWStr)] public string? pwszURLReference;
+        public uint dwProvFlags;
+        public uint dwUIContext;
+        public IntPtr pSignatureSettings;
+    }
+
+    [DllImport("wintrust.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern int WinVerifyTrust(IntPtr hwnd, [MarshalAs(UnmanagedType.LPStruct)] Guid actionId, IntPtr pWVTData);
+
+    /// <summary>
+    /// True quando o arquivo tem assinatura Authenticode válida. Falso não
+    /// significa suspeito: muito programa legítimo simplesmente não assina.
+    /// </summary>
+    public static bool Assinado(string? caminho)
+    {
+        if (string.IsNullOrWhiteSpace(caminho) || !File.Exists(caminho))
+            return false;
+
+        var arquivo = new WINTRUST_FILE_INFO
+        {
+            cbStruct = (uint)Marshal.SizeOf<WINTRUST_FILE_INFO>(),
+            pcwszFilePath = caminho,
+            hFile = IntPtr.Zero,
+            pgKnownSubject = IntPtr.Zero
+        };
+
+        var ponteiroArquivo = Marshal.AllocHGlobal(Marshal.SizeOf<WINTRUST_FILE_INFO>());
+        var ponteiroDados = IntPtr.Zero;
+
+        try
+        {
+            Marshal.StructureToPtr(arquivo, ponteiroArquivo, false);
+
+            var dados = new WINTRUST_DATA
+            {
+                cbStruct = (uint)Marshal.SizeOf<WINTRUST_DATA>(),
+                dwUIChoice = WTD_UI_NONE,
+                // Sem checar revogação: exigiria rede, e numa lista de dezenas
+                // de executáveis isso travaria a varredura.
+                fdwRevocationChecks = WTD_REVOKE_NONE,
+                dwUnionChoice = WTD_CHOICE_FILE,
+                pFile = ponteiroArquivo,
+                dwStateAction = WTD_STATEACTION_VERIFY,
+                dwProvFlags = WTD_SAFER_FLAG
+            };
+
+            ponteiroDados = Marshal.AllocHGlobal(Marshal.SizeOf<WINTRUST_DATA>());
+            Marshal.StructureToPtr(dados, ponteiroDados, false);
+
+            var resultado = WinVerifyTrust(IntPtr.Zero, WINTRUST_ACTION_GENERIC_VERIFY_V2, ponteiroDados);
+
+            // O estado precisa ser fechado, senão vaza handle a cada arquivo.
+            var paraFechar = Marshal.PtrToStructure<WINTRUST_DATA>(ponteiroDados);
+            paraFechar.dwStateAction = WTD_STATEACTION_CLOSE;
+            Marshal.StructureToPtr(paraFechar, ponteiroDados, false);
+            WinVerifyTrust(IntPtr.Zero, WINTRUST_ACTION_GENERIC_VERIFY_V2, ponteiroDados);
+
+            return resultado == 0;
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException)
+        {
+            return false;
+        }
+        finally
+        {
+            if (ponteiroDados != IntPtr.Zero)
+                Marshal.FreeHGlobal(ponteiroDados);
+
+            Marshal.FreeHGlobal(ponteiroArquivo);
+        }
+    }
+
+    /// <summary>Nome da empresa declarado no executável, para exibição.</summary>
+    public static string? Fabricante(string? caminho)
+    {
+        if (string.IsNullOrWhiteSpace(caminho) || !File.Exists(caminho))
+            return null;
+
+        try
+        {
+            var info = System.Diagnostics.FileVersionInfo.GetVersionInfo(caminho);
+            return string.IsNullOrWhiteSpace(info.CompanyName) ? null : info.CompanyName.Trim();
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException)
+        {
+            return null;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/FastFind.cs b/GameBoost/src/GameBoost.Core/Native/FastFind.cs
new file mode 100644
index 0000000..18aa0c5
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/FastFind.cs
@@ -0,0 +1,150 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>Um item devolvido pela enumeração: nome, tamanho e se é pasta.</summary>
+public readonly record struct FoundEntry(string Nome, long Tamanho, bool EhPasta, DateTime Modificado);
+
+/// <summary>
+/// Enumeração de diretório com FindFirstFileEx e FIND_FIRST_EX_LARGE_FETCH.
+///
+/// O flag de busca grande faz o Windows trazer vários registros por chamada ao
+/// kernel em vez de um por vez, e o tamanho já vem no próprio resultado — sem
+/// isso seria preciso um GetFileAttributes por arquivo, que é o que torna
+/// DirectoryInfo lento em disco cheio.
+/// </summary>
+public static class FastFind
+{
+    private const int MAX_PATH = 260;
+    private const int FILE_ATTRIBUTE_DIRECTORY = 0x10;
+    private const int FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
+    private const int FIND_FIRST_EX_LARGE_FETCH = 0x02;
+    private const int FindExInfoBasic = 1;
+    private const int FindExSearchNameMatch = 0;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct WIN32_FIND_DATAW
+    {
+        public uint dwFileAttributes;
+        public System.Runtime.InteropServices.ComTypes.FILETIME ftCreationTime;
+        public System.Runtime.InteropServices.ComTypes.FILETIME ftLastAccessTime;
+        public System.Runtime.InteropServices.ComTypes.FILETIME ftLastWriteTime;
+        public uint nFileSizeHigh;
+        public uint nFileSizeLow;
+        public uint dwReserved0;
+        public uint dwReserved1;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)] public string cFileName;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] public string cAlternateFileName;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern IntPtr FindFirstFileExW(
+        string fileName, int infoLevelId, out WIN32_FIND_DATAW findData,
+        int searchOp, IntPtr searchFilter, int additionalFlags);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool FindNextFileW(IntPtr findFile, out WIN32_FIND_DATAW findData);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool FindClose(IntPtr findFile);
+
+    private static readonly IntPtr InvalidHandle = new(-1);
+
+    /// <summary>
+    /// Lista o conteúdo direto de uma pasta. Não lança: pasta sem permissão
+    /// devolve lista vazia, porque numa varredura de disco inteiro sempre
+    /// haverá pastas de sistema fechadas, e parar em cada uma inviabilizaria
+    /// a leitura.
+    /// </summary>
+    public static List<FoundEntry> Listar(string pasta) => Listar(pasta, out _);
+
+    /// <param name="acessoNegado">
+    /// True so quando o Windows recusou a leitura. Pasta vazia devolve lista
+    /// vazia com false: contar pasta vazia como "sem acesso" daria um numero
+    /// inventado no relatorio (regra 4).
+    /// </param>
+    public static List<FoundEntry> Listar(string pasta, out bool acessoNegado)
+    {
+        acessoNegado = false;
+        var resultado = new List<FoundEntry>();
+
+        // O prefixo \\?\ tira o limite de 260 caracteres, que estoura em
+        // node_modules e em pastas de build.
+        var padrao = PrefixoLongo(pasta) + "\\*";
+
+        var handle = FindFirstFileExW(
+            padrao, FindExInfoBasic, out var dados,
+            FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH);
+
+        if (handle == InvalidHandle)
+        {
+            const int ERROR_FILE_NOT_FOUND = 2;
+            const int ERROR_PATH_NOT_FOUND = 3;
+            const int ERROR_NO_MORE_FILES = 18;
+
+            var erro = Marshal.GetLastWin32Error();
+
+            // Pasta que sumiu ou ficou vazia entre a descoberta e a leitura nao
+            // e problema de permissao.
+            acessoNegado = erro is not (ERROR_FILE_NOT_FOUND or ERROR_PATH_NOT_FOUND or ERROR_NO_MORE_FILES);
+            return resultado;
+        }
+
+        try
+        {
+            do
+            {
+                var nome = dados.cFileName;
+
+                if (nome is "." or "..")
+                    continue;
+
+                var ehPasta = (dados.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+                // Junção e link simbólico apontam para outro lugar: seguir
+                // contaria o mesmo espaço duas vezes e pode virar laço infinito.
+                if ((dados.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0)
+                    continue;
+
+                var tamanho = ehPasta
+                    ? 0
+                    : ((long)dados.nFileSizeHigh << 32) | dados.nFileSizeLow;
+
+                resultado.Add(new FoundEntry(nome, tamanho, ehPasta, ParaData(dados.ftLastWriteTime)));
+            }
+            while (FindNextFileW(handle, out dados));
+        }
+        finally
+        {
+            FindClose(handle);
+        }
+
+        return resultado;
+    }
+
+    private static string PrefixoLongo(string caminho)
+    {
+        if (caminho.StartsWith(@"\\?\", StringComparison.Ordinal))
+            return caminho;
+
+        // Caminho de rede usa outra forma do prefixo.
+        return caminho.StartsWith(@"\\", StringComparison.Ordinal)
+            ? @"\\?\UNC" + caminho[1..]
+            : @"\\?\" + caminho;
+    }
+
+    private static DateTime ParaData(System.Runtime.InteropServices.ComTypes.FILETIME ft)
+    {
+        try
+        {
+            var valor = ((long)ft.dwHighDateTime << 32) | (uint)ft.dwLowDateTime;
+            return valor <= 0 ? DateTime.MinValue : DateTime.FromFileTimeUtc(valor);
+        }
+        catch (ArgumentOutOfRangeException)
+        {
+            return DateTime.MinValue;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/NativeMethods.cs b/GameBoost/src/GameBoost.Core/Native/NativeMethods.cs
new file mode 100644
index 0000000..e53084e
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/NativeMethods.cs
@@ -0,0 +1,259 @@
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Regra 9: sem PowerShell quando houver API. Todo P/Invoke do GameBoost mora aqui.
+/// </summary>
+internal static class NativeMethods
+{
+    // ---------------- Kernel32 ----------------
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    internal static extern IntPtr OpenProcess(uint desiredAccess, bool inheritHandle, int processId);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool CloseHandle(IntPtr handle);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    internal static extern uint WTSGetActiveConsoleSessionId();
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool ProcessIdToSessionId(int processId, out int sessionId);
+
+    internal const uint PROCESS_QUERY_INFORMATION = 0x0400;
+    internal const uint PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
+    internal const uint PROCESS_SET_QUOTA = 0x0100;
+    internal const uint PROCESS_VM_READ = 0x0010;
+
+    // ---------------- Psapi: limpeza de RAM ----------------
+
+    /// <summary>
+    /// Tira as paginas do working set do processo. O Windows traz de volta o que
+    /// for realmente necessario; o resto vira RAM livre.
+    /// </summary>
+    [DllImport("psapi.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool EmptyWorkingSet(IntPtr hProcess);
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct PROCESS_MEMORY_COUNTERS
+    {
+        public uint cb;
+        public uint PageFaultCount;
+        public UIntPtr PeakWorkingSetSize;
+        public UIntPtr WorkingSetSize;
+        public UIntPtr QuotaPeakPagedPoolUsage;
+        public UIntPtr QuotaPagedPoolUsage;
+        public UIntPtr QuotaPeakNonPagedPoolUsage;
+        public UIntPtr QuotaNonPagedPoolUsage;
+        public UIntPtr PagefileUsage;
+        public UIntPtr PeakPagefileUsage;
+    }
+
+    [DllImport("psapi.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool GetProcessMemoryInfo(IntPtr hProcess, out PROCESS_MEMORY_COUNTERS counters, uint size);
+
+    // ---------------- NtDll: Standby List e timer ----------------
+
+    internal const int SystemMemoryListInformation = 80;
+    internal const int MemoryPurgeStandbyList = 4;
+
+    [DllImport("ntdll.dll")]
+    internal static extern int NtSetSystemInformation(int infoClass, IntPtr info, int length);
+
+    /// <summary>Resolucao do timer do sistema. Usada pelo Modo Game; revertida ao sair.</summary>
+    [DllImport("ntdll.dll", SetLastError = true)]
+    internal static extern int NtSetTimerResolution(uint desiredResolution, bool setResolution, out uint currentResolution);
+
+    [DllImport("ntdll.dll", SetLastError = true)]
+    internal static extern int NtQueryTimerResolution(out uint minimum, out uint maximum, out uint current);
+
+    // ---------------- Advapi32: privilegios ----------------
+
+    internal const string SE_PROFILE_SINGLE_PROCESS_NAME = "SeProfileSingleProcessPrivilege";
+    internal const string SE_INCREASE_QUOTA_NAME = "SeIncreaseQuotaPrivilege";
+    internal const string SE_DEBUG_NAME = "SeDebugPrivilege";
+
+    internal const uint TOKEN_ADJUST_PRIVILEGES = 0x0020;
+    internal const uint TOKEN_QUERY = 0x0008;
+    internal const uint SE_PRIVILEGE_ENABLED = 0x0002;
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct LUID
+    {
+        public uint LowPart;
+        public int HighPart;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct LUID_AND_ATTRIBUTES
+    {
+        public LUID Luid;
+        public uint Attributes;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct TOKEN_PRIVILEGES
+    {
+        public uint PrivilegeCount;
+        public LUID_AND_ATTRIBUTES Privilege;
+    }
+
+    [DllImport("advapi32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool OpenProcessToken(IntPtr processHandle, uint desiredAccess, out IntPtr tokenHandle);
+
+    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool LookupPrivilegeValue(string? systemName, string name, out LUID luid);
+
+    [DllImport("advapi32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool AdjustTokenPrivileges(
+        IntPtr tokenHandle,
+        [MarshalAs(UnmanagedType.Bool)] bool disableAllPrivileges,
+        ref TOKEN_PRIVILEGES newState,
+        uint bufferLength,
+        IntPtr previousState,
+        IntPtr returnLength);
+
+    // ---------------- PowrProf: planos de energia ----------------
+
+    [DllImport("powrprof.dll", SetLastError = true)]
+    internal static extern uint PowerGetActiveScheme(IntPtr userRootPowerKey, out IntPtr activePolicyGuid);
+
+    [DllImport("powrprof.dll", SetLastError = true)]
+    internal static extern uint PowerSetActiveScheme(IntPtr userRootPowerKey, ref Guid schemeGuid);
+
+    [DllImport("powrprof.dll", SetLastError = true)]
+    internal static extern uint PowerEnumerate(
+        IntPtr rootPowerKey,
+        IntPtr schemeGuid,
+        IntPtr subGroupOfPowerSettingsGuid,
+        uint accessFlags,
+        uint index,
+        byte[]? buffer,
+        ref uint bufferSize);
+
+    [DllImport("powrprof.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    internal static extern uint PowerReadFriendlyName(
+        IntPtr rootPowerKey,
+        ref Guid schemeGuid,
+        IntPtr subGroupOfPowerSettingsGuid,
+        IntPtr powerSettingGuid,
+        byte[]? buffer,
+        ref uint bufferSize);
+
+    internal const uint ACCESS_SCHEME = 16;
+
+    [DllImport("kernel32.dll")]
+    internal static extern IntPtr LocalFree(IntPtr hMem);
+
+    // ---------------- User32: fechamento gracioso ----------------
+
+    internal const uint WM_CLOSE = 0x0010;
+    internal const uint WM_QUERYENDSESSION = 0x0011;
+
+    internal delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool EnumWindows(EnumWindowsProc callback, IntPtr lParam);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    internal static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int processId);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    internal static extern int GetWindowTextW(IntPtr hWnd, StringBuilder text, int maxCount);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    internal static extern IntPtr PostMessageW(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
+
+    // ---------------- GlobalMemoryStatusEx ----------------
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
+    internal class MEMORYSTATUSEX
+    {
+        public uint dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX));
+        public uint dwMemoryLoad;
+        public ulong ullTotalPhys;
+        public ulong ullAvailPhys;
+        public ulong ullTotalPageFile;
+        public ulong ullAvailPageFile;
+        public ulong ullTotalVirtual;
+        public ulong ullAvailVirtual;
+        public ulong ullAvailExtendedVirtual;
+    }
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool GlobalMemoryStatusEx([In, Out] MEMORYSTATUSEX buffer);
+
+    // ---------------- Tempo de CPU da thread atual ----------------
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern IntPtr GetCurrentThread();
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GetThreadTimes(
+        IntPtr thread, out long creation, out long exit, out long kernel, out long user);
+
+    /// <summary>
+    /// Tempo de CPU realmente gasto pela thread atual. Stopwatch mede tempo de
+    /// parede: um ciclo que passa 300 ms esperando WMI parece caro sem ter
+    /// custado CPU nenhuma. Medir errado o proprio custo seria justamente o
+    /// tipo de numero inventado que a regra 4 proibe.
+    /// </summary>
+    internal static TimeSpan TempoDeCpuDaThreadAtual()
+    {
+        if (!GetThreadTimes(GetCurrentThread(), out _, out _, out var kernel, out var user))
+            return TimeSpan.Zero;
+
+        return TimeSpan.FromTicks(kernel + user);
+    }
+
+    // ---------------- Privilegio: helper ----------------
+
+    /// <summary>
+    /// Habilita um privilegio no token do processo atual. Sem SeProfileSingleProcess
+    /// a purga da Standby List falha silenciosamente.
+    /// </summary>
+    internal static bool EnablePrivilege(string privilegeName)
+    {
+        var processo = System.Diagnostics.Process.GetCurrentProcess().Handle;
+        if (!OpenProcessToken(processo, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, out var token))
+            return false;
+
+        try
+        {
+            if (!LookupPrivilegeValue(null, privilegeName, out var luid))
+                return false;
+
+            var privilegios = new TOKEN_PRIVILEGES
+            {
+                PrivilegeCount = 1,
+                Privilege = new LUID_AND_ATTRIBUTES { Luid = luid, Attributes = SE_PRIVILEGE_ENABLED }
+            };
+
+            if (!AdjustTokenPrivileges(token, false, ref privilegios, 0, IntPtr.Zero, IntPtr.Zero))
+                return false;
+
+            // AdjustTokenPrivileges devolve true mesmo quando nao concede tudo.
+            return Marshal.GetLastWin32Error() == 0;
+        }
+        finally
+        {
+            CloseHandle(token);
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/NativeMethodsBridge.cs b/GameBoost/src/GameBoost.Core/Native/NativeMethodsBridge.cs
new file mode 100644
index 0000000..8074d9e
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/NativeMethodsBridge.cs
@@ -0,0 +1,24 @@
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Ponte publica para os poucos P/Invoke que a composicao precisa enxergar.
+/// NativeMethods segue interno para o resto do mundo.
+/// </summary>
+public static class NativeMethodsBridge
+{
+    public static bool TryGetSessionId(int processId, out int sessionId)
+        => NativeMethods.ProcessIdToSessionId(processId, out sessionId);
+
+    /// <summary>Resolucao do timer em unidades de 100 ns. 5000 = 0,5 ms.</summary>
+    public static bool SetTimerResolution(uint cemNanosegundos, out uint atual)
+        => NativeMethods.NtSetTimerResolution(cemNanosegundos, true, out atual) == 0;
+
+    public static bool RestoreTimerResolution(uint cemNanosegundos, out uint atual)
+        => NativeMethods.NtSetTimerResolution(cemNanosegundos, false, out atual) == 0;
+
+    public static bool TryQueryTimerResolution(out uint minimo, out uint maximo, out uint atual)
+        => NativeMethods.NtQueryTimerResolution(out minimo, out maximo, out atual) == 0;
+
+    /// <summary>Tempo de CPU da thread atual, para medir o custo da propria coleta.</summary>
+    public static TimeSpan TempoDeCpuDaThreadAtual() => NativeMethods.TempoDeCpuDaThreadAtual();
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/PdhQuery.cs b/GameBoost/src/GameBoost.Core/Native/PdhQuery.cs
new file mode 100644
index 0000000..4b2c18a
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/PdhQuery.cs
@@ -0,0 +1,136 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Consulta PDH com curinga: um unico contador do tipo
+/// "\GPU Engine(*engtype_3D)\Utilization Percentage" resolve todas as
+/// instancias de uma vez.
+///
+/// Substitui dezenas de objetos PerformanceCounter, um por instancia, que
+/// custavam mais de 1 segundo por ciclo numa maquina com jogo e navegadores
+/// abertos: cada NextValue() e uma consulta separada ao subsistema.
+///
+/// Usa PdhAddEnglishCounter de proposito. O nome em ingles vale em qualquer
+/// idioma do Windows, enquanto PerformanceCounter exige o nome traduzido e
+/// quebraria neste Windows pt-BR.
+/// </summary>
+internal sealed class PdhQuery : IDisposable
+{
+    private const uint PDH_FMT_DOUBLE = 0x00000200;
+    private const uint PDH_MORE_DATA = 0x800007D2;
+    private const int TamanhoDoItem = 24; // x64: LPWSTR + DWORD + padding + double
+
+    [DllImport("pdh.dll")]
+    private static extern uint PdhOpenQueryW(string? dataSource, IntPtr userData, out IntPtr query);
+
+    [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
+    private static extern uint PdhAddEnglishCounterW(IntPtr query, string counterPath, IntPtr userData, out IntPtr counter);
+
+    [DllImport("pdh.dll")]
+    private static extern uint PdhCollectQueryData(IntPtr query);
+
+    [DllImport("pdh.dll", CharSet = CharSet.Unicode)]
+    private static extern uint PdhGetFormattedCounterArrayW(
+        IntPtr counter, uint format, ref uint bufferSize, out uint itemCount, IntPtr buffer);
+
+    [DllImport("pdh.dll")]
+    private static extern uint PdhCloseQuery(IntPtr query);
+
+    private IntPtr _query;
+    private IntPtr _contador;
+    private uint _tamanhoDoBuffer;
+    private IntPtr _buffer;
+    private bool _descartado;
+
+    public bool Valido => _query != IntPtr.Zero && _contador != IntPtr.Zero;
+
+    private PdhQuery(IntPtr query, IntPtr contador)
+    {
+        _query = query;
+        _contador = contador;
+    }
+
+    /// <summary>Abre a consulta. Devolve null se o contador nao existir nesta maquina.</summary>
+    public static PdhQuery? Abrir(string caminhoDoContador)
+    {
+        if (PdhOpenQueryW(null, IntPtr.Zero, out var query) != 0)
+            return null;
+
+        if (PdhAddEnglishCounterW(query, caminhoDoContador, IntPtr.Zero, out var contador) != 0)
+        {
+            PdhCloseQuery(query);
+            return null;
+        }
+
+        // A primeira coleta so estabelece a linha de base dos contadores de taxa.
+        PdhCollectQueryData(query);
+
+        return new PdhQuery(query, contador);
+    }
+
+    /// <summary>
+    /// Valores atuais de todas as instancias. Lista vazia significa que nao ha
+    /// instancia ativa no momento, o que e normal para engines de GPU ociosas.
+    /// </summary>
+    public IReadOnlyList<double> Coletar()
+    {
+        if (!Valido || _descartado)
+            return Array.Empty<double>();
+
+        if (PdhCollectQueryData(_query) != 0)
+            return Array.Empty<double>();
+
+        var tamanho = _tamanhoDoBuffer;
+        var status = PdhGetFormattedCounterArrayW(_contador, PDH_FMT_DOUBLE, ref tamanho, out var quantidade, _buffer);
+
+        if (status == PDH_MORE_DATA)
+        {
+            // Realoca so quando o numero de instancias cresce, nao a cada ciclo.
+            if (_buffer != IntPtr.Zero)
+                Marshal.FreeHGlobal(_buffer);
+
+            _tamanhoDoBuffer = tamanho;
+            _buffer = Marshal.AllocHGlobal((int)tamanho);
+
+            status = PdhGetFormattedCounterArrayW(_contador, PDH_FMT_DOUBLE, ref tamanho, out quantidade, _buffer);
+        }
+
+        if (status != 0 || quantidade == 0 || _buffer == IntPtr.Zero)
+            return Array.Empty<double>();
+
+        var valores = new List<double>((int)quantidade);
+        for (var i = 0; i < quantidade; i++)
+        {
+            // Dentro de PDH_FMT_COUNTERVALUE_ITEM: nome (8) + CStatus (4) + padding (4).
+            var valor = Marshal.PtrToStructure<double>(_buffer + i * TamanhoDoItem + 16);
+
+            if (!double.IsNaN(valor) && !double.IsInfinity(valor))
+                valores.Add(valor);
+        }
+
+        return valores;
+    }
+
+    public void Dispose()
+    {
+        if (_descartado)
+            return;
+
+        _descartado = true;
+
+        if (_buffer != IntPtr.Zero)
+        {
+            Marshal.FreeHGlobal(_buffer);
+            _buffer = IntPtr.Zero;
+        }
+
+        if (_query != IntPtr.Zero)
+        {
+            PdhCloseQuery(_query);
+            _query = IntPtr.Zero;
+        }
+
+        _contador = IntPtr.Zero;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/ProcessInformation.cs b/GameBoost/src/GameBoost.Core/Native/ProcessInformation.cs
new file mode 100644
index 0000000..533a9f8
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/ProcessInformation.cs
@@ -0,0 +1,150 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>Dados brutos de um processo, como o kernel devolve.</summary>
+internal readonly record struct RawProcess(
+    int Pid,
+    string Nome,
+    long TempoDeCpu100ns,
+    long WorkingSetBytes,
+    int SessionId,
+    int Threads);
+
+/// <summary>
+/// Lista todos os processos numa unica chamada
+/// (NtQuerySystemInformation / SystemProcessInformation).
+///
+/// Existe por causa do orcamento de CPU da secao 5.5: Process.GetProcesses()
+/// seguido de TotalProcessorTime e WorkingSet64 abre um handle por processo e
+/// custou 6% de CPU medidos numa maquina com ~400 processos, contra o limite de
+/// 1,5%. Esta chamada devolve tudo de uma vez, sem abrir handle nenhum.
+///
+/// O layout de SYSTEM_PROCESS_INFORMATION e estavel desde o Windows Vista.
+/// Ainda assim, nada aqui confia cegamente no buffer: cada avanco e validado
+/// antes de ler, e qualquer inconsistencia encerra a leitura em vez de andar
+/// para fora da regiao alocada.
+/// </summary>
+internal static class ProcessInformation
+{
+    private const int SystemProcessInformation = 5;
+    private const int STATUS_INFO_LENGTH_MISMATCH = unchecked((int)0xC0000004);
+
+    [DllImport("ntdll.dll")]
+    private static extern int NtQuerySystemInformation(
+        int systemInformationClass,
+        IntPtr systemInformation,
+        int systemInformationLength,
+        out int returnLength);
+
+    // Deslocamentos dentro de SYSTEM_PROCESS_INFORMATION em x64.
+    private const int OffsetNextEntry = 0x00;   // ULONG
+    private const int OffsetThreads = 0x04;     // ULONG
+    private const int OffsetUserTime = 0x28;    // LARGE_INTEGER
+    private const int OffsetKernelTime = 0x30;  // LARGE_INTEGER
+    private const int OffsetImageName = 0x38;   // UNICODE_STRING
+    private const int OffsetPid = 0x50;         // HANDLE
+    private const int OffsetSessionId = 0x64;   // ULONG
+    private const int OffsetWorkingSet = 0x90;  // SIZE_T
+    private const int TamanhoMinimoDaEntrada = 0x98;
+
+    internal static IReadOnlyList<RawProcess> Listar()
+    {
+        if (!Environment.Is64BitProcess)
+            return Array.Empty<RawProcess>();
+
+        var tamanho = 512 * 1024;
+
+        for (var tentativa = 0; tentativa < 6; tentativa++)
+        {
+            var buffer = Marshal.AllocHGlobal(tamanho);
+
+            try
+            {
+                var status = NtQuerySystemInformation(
+                    SystemProcessInformation, buffer, tamanho, out var necessario);
+
+                if (status == STATUS_INFO_LENGTH_MISMATCH)
+                {
+                    // A lista cresceu entre a consulta e a alocacao: refaz com folga.
+                    tamanho = Math.Max(necessario, tamanho * 2) + 64 * 1024;
+                    continue;
+                }
+
+                if (status != 0)
+                    return Array.Empty<RawProcess>();
+
+                return Percorrer(buffer, tamanho);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(buffer);
+            }
+        }
+
+        return Array.Empty<RawProcess>();
+    }
+
+    private static List<RawProcess> Percorrer(IntPtr buffer, int tamanhoDoBuffer)
+    {
+        var resultado = new List<RawProcess>(512);
+        var deslocamento = 0;
+
+        while (true)
+        {
+            // A entrada inteira precisa caber no que foi alocado.
+            if (deslocamento < 0 || deslocamento + TamanhoMinimoDaEntrada > tamanhoDoBuffer)
+                break;
+
+            var entrada = buffer + deslocamento;
+
+            var pid = (int)Marshal.ReadIntPtr(entrada, OffsetPid);
+            var user = Marshal.ReadInt64(entrada, OffsetUserTime);
+            var kernel = Marshal.ReadInt64(entrada, OffsetKernelTime);
+            var workingSet = Marshal.ReadInt64(entrada, OffsetWorkingSet);
+            var sessao = Marshal.ReadInt32(entrada, OffsetSessionId);
+            var threads = Marshal.ReadInt32(entrada, OffsetThreads);
+
+            var nome = LerNome(entrada, pid);
+
+            if (pid >= 0)
+            {
+                resultado.Add(new RawProcess(
+                    Pid: pid,
+                    Nome: nome,
+                    TempoDeCpu100ns: user + kernel,
+                    WorkingSetBytes: workingSet,
+                    SessionId: sessao,
+                    Threads: threads));
+            }
+
+            var proximo = Marshal.ReadInt32(entrada, OffsetNextEntry);
+            if (proximo <= 0)
+                break;
+
+            deslocamento += proximo;
+        }
+
+        return resultado;
+    }
+
+    /// <summary>ImageName e um UNICODE_STRING; o processo ocioso vem com Buffer nulo.</summary>
+    private static string LerNome(IntPtr entrada, int pid)
+    {
+        var comprimentoEmBytes = (ushort)Marshal.ReadInt16(entrada, OffsetImageName);
+        var ponteiro = Marshal.ReadIntPtr(entrada, OffsetImageName + 8);
+
+        if (ponteiro == IntPtr.Zero || comprimentoEmBytes == 0)
+            return pid == 0 ? "Idle" : "System";
+
+        // Limite de sanidade: nome de imagem nao passa de MAX_PATH.
+        if (comprimentoEmBytes > 520)
+            return "?";
+
+        var nome = Marshal.PtrToStringUni(ponteiro, comprimentoEmBytes / 2) ?? string.Empty;
+
+        return nome.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
+            ? nome[..^4]
+            : nome;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/RecycleBin.cs b/GameBoost/src/GameBoost.Core/Native/RecycleBin.cs
new file mode 100644
index 0000000..3458ae6
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/RecycleBin.cs
@@ -0,0 +1,114 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Envia arquivos para a Lixeira (regra 2: conteúdo do usuário nunca é apagado
+/// direto). Usa SHFileOperation com FOF_ALLOWUNDO, que é o que o Explorer faz.
+/// </summary>
+internal static class RecycleBin
+{
+    private const uint FO_DELETE = 0x0003;
+    private const ushort FOF_SILENT = 0x0004;
+    private const ushort FOF_NOCONFIRMATION = 0x0010;
+    private const ushort FOF_ALLOWUNDO = 0x0040;
+    private const ushort FOF_NOERRORUI = 0x0400;
+    private const ushort FOF_WANTNUKEWARNING = 0x4000;
+
+    /// <summary>
+    /// **Sem `Pack`.** O alinhamento tem que ser o natural da plataforma.
+    ///
+    /// Com `Pack = 1` o .NET tira o preenchimento entre os campos, e em x64 o
+    /// `pFrom` sai no deslocamento 12 em vez de 16. O shell32 continua lendo do
+    /// 16, pega metade de um ponteiro colada na metade de outro, e usa aquilo
+    /// como endereço: violação de acesso (0xc0000005) e o processo morre sem
+    /// exceção gerenciada, sem log e sem caixa de erro.
+    ///
+    /// O defeito derrubava o aplicativo em **todo** envio para a Lixeira —
+    /// Limpeza, Espaço e Restos usam esta mesma função.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct SHFILEOPSTRUCT
+    {
+        public IntPtr hwnd;
+        public uint wFunc;
+        [MarshalAs(UnmanagedType.LPWStr)] public string pFrom;
+        [MarshalAs(UnmanagedType.LPWStr)] public string? pTo;
+        public ushort fFlags;
+        [MarshalAs(UnmanagedType.Bool)] public bool fAnyOperationsAborted;
+        public IntPtr hNameMappings;
+        [MarshalAs(UnmanagedType.LPWStr)] public string? lpszProgressTitle;
+    }
+
+    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+    private static extern int SHFileOperationW(ref SHFILEOPSTRUCT op);
+
+    /// <summary>
+    /// Manda tudo de uma vez: uma chamada por arquivo seria lenta e encheria a
+    /// Lixeira de operações separadas. A lista precisa terminar em dois nulos.
+    /// </summary>
+    internal static bool ParaLixeira(IReadOnlyList<string> caminhos)
+    {
+        if (caminhos.Count == 0)
+            return true;
+
+        var lista = string.Join('\0', caminhos) + "\0\0";
+
+        var operacao = new SHFILEOPSTRUCT
+        {
+            hwnd = IntPtr.Zero,
+            wFunc = FO_DELETE,
+            pFrom = lista,
+            pTo = null,
+            // WANTNUKEWARNING garante que, se algo nao couber na Lixeira, o
+            // Windows avise em vez de apagar de vez sem perguntar.
+            fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI | FOF_WANTNUKEWARNING
+        };
+
+        var resultado = SHFileOperationW(ref operacao);
+        return resultado == 0 && !operacao.fAnyOperationsAborted;
+    }
+
+    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+    private static extern int SHEmptyRecycleBinW(IntPtr hwnd, string? rootPath, uint flags);
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct SHQUERYRBINFO
+    {
+        public int cbSize;
+        public long i64Size;
+        public long i64NumItems;
+    }
+
+    [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+    private static extern int SHQueryRecycleBinW(string? rootPath, ref SHQUERYRBINFO info);
+
+    internal static (long Bytes, long Itens) ConsultarLixeira()
+    {
+        var info = new SHQUERYRBINFO { cbSize = Marshal.SizeOf<SHQUERYRBINFO>() };
+
+        return SHQueryRecycleBinW(null, ref info) == 0
+            ? (info.i64Size, info.i64NumItems)
+            : (0, 0);
+    }
+
+    internal static bool EsvaziarLixeira()
+    {
+        const uint SHERB_NOCONFIRMATION = 0x01;
+        const uint SHERB_NOPROGRESSUI = 0x02;
+        const uint SHERB_NOSOUND = 0x04;
+
+        return SHEmptyRecycleBinW(IntPtr.Zero, null,
+            SHERB_NOCONFIRMATION | SHERB_NOPROGRESSUI | SHERB_NOSOUND) == 0;
+    }
+}
+
+/// <summary>Ponte pública para a Lixeira.</summary>
+public static class RecycleBinBridge
+{
+    public static bool ParaLixeira(IReadOnlyList<string> caminhos) => RecycleBin.ParaLixeira(caminhos);
+
+    public static (long Bytes, long Itens) Consultar() => RecycleBin.ConsultarLixeira();
+
+    public static bool Esvaziar() => RecycleBin.EsvaziarLixeira();
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/SystemInformation.cs b/GameBoost/src/GameBoost.Core/Native/SystemInformation.cs
new file mode 100644
index 0000000..daab441
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/SystemInformation.cs
@@ -0,0 +1,117 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// NtQuerySystemInformation e IP Helper.
+///
+/// Por que nao PerformanceCounter: os nomes de contador do Windows sao
+/// traduzidos. Num Windows pt-BR, "\Processor Information(_Total)" simplesmente
+/// nao existe -- e "\Informacoes do Processador(_Total)". Estas APIs devolvem
+/// numeros, nao texto, entao funcionam em qualquer idioma.
+/// </summary>
+internal static class SystemInformation
+{
+    private const int SystemProcessorPerformanceInformation = 8;
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
+    {
+        public long IdleTime;
+        public long KernelTime;   // inclui IdleTime
+        public long UserTime;
+        public long DpcTime;
+        public long InterruptTime;
+        public uint InterruptCount;
+    }
+
+    [DllImport("ntdll.dll")]
+    private static extern int NtQuerySystemInformation(
+        int systemInformationClass,
+        IntPtr systemInformation,
+        int systemInformationLength,
+        out int returnLength);
+
+    /// <summary>Tempos acumulados por nucleo logico. Retorna vazio se a chamada falhar.</summary>
+    internal static SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[] LerTemposDeProcessador(int nucleos)
+    {
+        var tamanho = Marshal.SizeOf<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION>();
+        var buffer = Marshal.AllocHGlobal(tamanho * nucleos);
+
+        try
+        {
+            var status = NtQuerySystemInformation(
+                SystemProcessorPerformanceInformation, buffer, tamanho * nucleos, out _);
+
+            if (status != 0)
+                return Array.Empty<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION>();
+
+            var resultado = new SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION[nucleos];
+            for (var i = 0; i < nucleos; i++)
+            {
+                resultado[i] = Marshal.PtrToStructure<SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION>(
+                    buffer + i * tamanho);
+            }
+
+            return resultado;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+
+    // ---------------- Memoria de sistema: Standby List ----------------
+
+    private const int SystemMemoryListInformation = 80;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct SYSTEM_MEMORY_LIST_INFORMATION
+    {
+        public UIntPtr ZeroPageCount;
+        public UIntPtr FreePageCount;
+        public UIntPtr ModifiedPageCount;
+        public UIntPtr ModifiedNoWritePageCount;
+        public UIntPtr BadPageCount;
+        // Seguem 8 contadores de prioridade da Standby List.
+    }
+
+    /// <summary>
+    /// Tamanho da Standby List em bytes. Le os 8 contadores por prioridade que
+    /// vem logo depois da estrutura fixa. Retorna null se nao conseguir.
+    /// </summary>
+    internal static long? LerStandbyList()
+    {
+        const int prioridades = 8;
+        var fixo = Marshal.SizeOf<SYSTEM_MEMORY_LIST_INFORMATION>();
+        var tamanho = fixo + prioridades * IntPtr.Size;
+        var buffer = Marshal.AllocHGlobal(tamanho);
+
+        try
+        {
+            if (NtQuerySystemInformation(SystemMemoryListInformation, buffer, tamanho, out _) != 0)
+                return null;
+
+            long paginas = 0;
+            for (var i = 0; i < prioridades; i++)
+            {
+                var valor = IntPtr.Size == 8
+                    ? Marshal.ReadInt64(buffer, fixo + i * 8)
+                    : Marshal.ReadInt32(buffer, fixo + i * 4);
+
+                if (valor > 0)
+                    paginas += valor;
+            }
+
+            return paginas * Environment.SystemPageSize;
+        }
+        catch (AccessViolationException)
+        {
+            return null;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/TcpTable.cs b/GameBoost/src/GameBoost.Core/Native/TcpTable.cs
new file mode 100644
index 0000000..47b3944
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/TcpTable.cs
@@ -0,0 +1,116 @@
+using System.Net;
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+public sealed record ConexaoTcp(int ProcessId, IPAddress Local, int PortaLocal, IPAddress Remoto, int PortaRemota, string Estado);
+
+/// <summary>
+/// Lê a tabela de conexões TCP com o PID de cada dono, via
+/// <c>GetExtendedTcpTable</c>.
+///
+/// Uma ressalva que a UI precisa repetir: isto mostra **conexões**, não banda.
+/// Medir quantos bytes por segundo cada processo usa exigiria ETW, que é um
+/// consumidor de eventos rodando o tempo todo, e a regra 9 do spec põe teto de
+/// 1,5% de CPU na coleta. Contar conexão custa uma chamada e responde à
+/// pergunta que o usuário realmente faz: "quem está falando com a internet
+/// agora?".
+/// </summary>
+public static class TcpTable
+{
+    private const int AF_INET = 2;
+
+    /// <summary>TCP_TABLE_OWNER_PID_ALL.</summary>
+    private const int TableClass = 5;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MIB_TCPROW_OWNER_PID
+    {
+        public uint state;
+        public uint localAddr;
+        public uint localPort;
+        public uint remoteAddr;
+        public uint remotePort;
+        public uint owningPid;
+    }
+
+    [DllImport("iphlpapi.dll", SetLastError = true)]
+    private static extern uint GetExtendedTcpTable(
+        IntPtr pTcpTable, ref int pdwSize, bool bOrder, int ulAf, int TableClass, int Reserved);
+
+    public static IReadOnlyList<ConexaoTcp> Listar()
+    {
+        var tamanho = 0;
+        var buffer = IntPtr.Zero;
+
+        try
+        {
+            // Primeira chamada só para descobrir o tamanho. Entre ela e a
+            // segunda a tabela pode crescer, e é por isso que o laço existe.
+            for (var tentativa = 0; tentativa < 5; tentativa++)
+            {
+                var resultado = GetExtendedTcpTable(buffer, ref tamanho, false, AF_INET, TableClass, 0);
+
+                if (resultado == 0)
+                    break;
+
+                // ERROR_INSUFFICIENT_BUFFER: aloca e tenta de novo.
+                if (resultado != 122)
+                    return Array.Empty<ConexaoTcp>();
+
+                if (buffer != IntPtr.Zero)
+                    Marshal.FreeHGlobal(buffer);
+
+                buffer = Marshal.AllocHGlobal(tamanho);
+            }
+
+            if (buffer == IntPtr.Zero)
+                return Array.Empty<ConexaoTcp>();
+
+            var quantidade = Marshal.ReadInt32(buffer);
+            var linhas = new List<ConexaoTcp>(quantidade);
+            var tamanhoLinha = Marshal.SizeOf<MIB_TCPROW_OWNER_PID>();
+
+            for (var i = 0; i < quantidade; i++)
+            {
+                var endereco = IntPtr.Add(buffer, 4 + i * tamanhoLinha);
+                var linha = Marshal.PtrToStructure<MIB_TCPROW_OWNER_PID>(endereco);
+
+                linhas.Add(new ConexaoTcp(
+                    (int)linha.owningPid,
+                    new IPAddress(linha.localAddr),
+                    Porta(linha.localPort),
+                    new IPAddress(linha.remoteAddr),
+                    Porta(linha.remotePort),
+                    Estado(linha.state)));
+            }
+
+            return linhas;
+        }
+        finally
+        {
+            if (buffer != IntPtr.Zero)
+                Marshal.FreeHGlobal(buffer);
+        }
+    }
+
+    /// <summary>A porta vem em ordem de rede nos dois bytes baixos.</summary>
+    private static int Porta(uint valor) => ((int)(valor & 0xFF) << 8) | (int)((valor >> 8) & 0xFF);
+
+    private static string Estado(uint estado) => estado switch
+    {
+        1 => "fechada",
+        2 => "escutando",
+        3 => "SYN enviado",
+        4 => "SYN recebido",
+        5 => "conectada",
+        6 => "encerrando",
+        7 => "aguardando",
+        8 => "fechando",
+        9 => "fechada (espera)",
+        10 => "último ACK",
+        11 => "espera final",
+        12 => "excluída",
+        _ => "desconhecida"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/ToolsNative.cs b/GameBoost/src/GameBoost.Core/Native/ToolsNative.cs
new file mode 100644
index 0000000..1f0518f
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/ToolsNative.cs
@@ -0,0 +1,119 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// P/Invoke das ferramentas rápidas. Regra 9: onde há API, nada de chamar
+/// executável. `ipconfig /flushdns` vira DnsFlushResolverCache, que é o que o
+/// próprio ipconfig faz por dentro.
+/// </summary>
+public static class ToolsNative
+{
+    // ---------------- DNS ----------------
+
+    [DllImport("dnsapi.dll", EntryPoint = "DnsFlushResolverCache", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool DnsFlushResolverCache();
+
+    /// <summary>Limpa o cache de DNS do sistema. É o que `ipconfig /flushdns` faz.</summary>
+    public static bool LimparCacheDeDns()
+    {
+        try
+        {
+            return DnsFlushResolverCache();
+        }
+        catch (Exception ex) when (ex is EntryPointNotFoundException or DllNotFoundException)
+        {
+            return false;
+        }
+    }
+
+    // ---------------- Reiniciar o driver de vídeo ----------------
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct INPUT
+    {
+        public uint type;
+        public InputUnion u;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    private struct InputUnion
+    {
+        [FieldOffset(0)] public KEYBDINPUT ki;
+        [FieldOffset(0)] public MOUSEINPUT mi;
+        [FieldOffset(0)] public HARDWAREINPUT hi;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct KEYBDINPUT
+    {
+        public ushort wVk;
+        public ushort wScan;
+        public uint dwFlags;
+        public uint time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MOUSEINPUT
+    {
+        public int dx, dy;
+        public uint mouseData, dwFlags, time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct HARDWAREINPUT
+    {
+        public uint uMsg;
+        public ushort wParamL, wParamH;
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern uint SendInput(uint numberOfInputs, INPUT[] inputs, int sizeOfInput);
+
+    private const uint INPUT_KEYBOARD = 1;
+    private const uint KEYEVENTF_KEYUP = 0x0002;
+    private const ushort VK_LWIN = 0x5B;
+    private const ushort VK_CONTROL = 0x11;
+    private const ushort VK_SHIFT = 0x10;
+    private const ushort VK_B = 0x42;
+
+    /// <summary>
+    /// Envia Win+Ctrl+Shift+B, o atalho que o Windows reserva para recarregar o
+    /// driver de vídeo. Não existe API pública para isso: simular o atalho é o
+    /// caminho oficial.
+    /// </summary>
+    public static bool ReiniciarDriverDeVideo()
+    {
+        var teclas = new ushort[] { VK_LWIN, VK_CONTROL, VK_SHIFT, VK_B };
+        var entradas = new List<INPUT>();
+
+        foreach (var tecla in teclas)
+            entradas.Add(Tecla(tecla, pressionar: true));
+
+        // Solta na ordem inversa, como um teclado de verdade.
+        for (var i = teclas.Length - 1; i >= 0; i--)
+            entradas.Add(Tecla(teclas[i], pressionar: false));
+
+        var vetor = entradas.ToArray();
+        var enviadas = SendInput((uint)vetor.Length, vetor, Marshal.SizeOf<INPUT>());
+
+        return enviadas == vetor.Length;
+    }
+
+    private static INPUT Tecla(ushort codigo, bool pressionar) => new()
+    {
+        type = INPUT_KEYBOARD,
+        u = new InputUnion
+        {
+            ki = new KEYBDINPUT
+            {
+                wVk = codigo,
+                dwFlags = pressionar ? 0 : KEYEVENTF_KEYUP,
+                dwExtraInfo = IntPtr.Zero
+            }
+        }
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/WindowInfo.cs b/GameBoost/src/GameBoost.Core/Native/WindowInfo.cs
new file mode 100644
index 0000000..f17c4e2
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/WindowInfo.cs
@@ -0,0 +1,131 @@
+using System.Runtime.InteropServices;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Descobre se um processo tem janela ocupando o monitor inteiro.
+///
+/// É o terceiro critério de detecção de jogo da seção 5.1. Não distingue tela
+/// cheia exclusiva de borderless, e nem precisa: as duas dizem a mesma coisa
+/// para o que interessa aqui — alguém está usando o monitor todo para uma coisa
+/// só, e essa coisa merece a máquina.
+/// </summary>
+public static class WindowInfo
+{
+    private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct RECT
+    {
+        public int Left, Top, Right, Bottom;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MONITORINFO
+    {
+        public int cbSize;
+        public RECT rcMonitor;
+        public RECT rcWork;
+        public uint dwFlags;
+    }
+
+    private const uint MONITOR_DEFAULTTONEAREST = 2;
+
+    [DllImport("user32.dll")]
+    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+
+    [DllImport("user32.dll")]
+    private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+
+    [DllImport("user32.dll")]
+    private static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+    [DllImport("user32.dll")]
+    private static extern IntPtr MonitorFromWindow(IntPtr hwnd, uint dwFlags);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    private static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);
+
+    [DllImport("user32.dll")]
+    private static extern IntPtr GetForegroundWindow();
+
+    /// <summary>
+    /// True quando o processo tem alguma janela visível do tamanho do monitor
+    /// em que ela está.
+    /// </summary>
+    public static bool EstaEmTelaCheia(int pid)
+    {
+        var achou = false;
+
+        try
+        {
+            EnumWindows((hWnd, _) =>
+            {
+                if (!IsWindowVisible(hWnd))
+                    return true;
+
+                GetWindowThreadProcessId(hWnd, out var dono);
+
+                if (dono != (uint)pid)
+                    return true;
+
+                if (!GetWindowRect(hWnd, out var janela))
+                    return true;
+
+                var monitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
+
+                if (monitor == IntPtr.Zero)
+                    return true;
+
+                var info = new MONITORINFO { cbSize = Marshal.SizeOf<MONITORINFO>() };
+
+                if (!GetMonitorInfo(monitor, ref info))
+                    return true;
+
+                // Margem de um pixel: borderless às vezes fica um pixel maior
+                // que o monitor, e tela cheia exclusiva às vezes um menor.
+                var larguraJanela = janela.Right - janela.Left;
+                var alturaJanela = janela.Bottom - janela.Top;
+                var larguraMonitor = info.rcMonitor.Right - info.rcMonitor.Left;
+                var alturaMonitor = info.rcMonitor.Bottom - info.rcMonitor.Top;
+
+                if (Math.Abs(larguraJanela - larguraMonitor) <= 1
+                    && Math.Abs(alturaJanela - alturaMonitor) <= 1)
+                {
+                    achou = true;
+                    return false;
+                }
+
+                return true;
+            }, IntPtr.Zero);
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException)
+        {
+            return false;
+        }
+
+        return achou;
+    }
+
+    /// <summary>Pid do processo dono da janela em primeiro plano, ou zero.</summary>
+    public static int PidEmPrimeiroPlano()
+    {
+        try
+        {
+            var janela = GetForegroundWindow();
+
+            if (janela == IntPtr.Zero)
+                return 0;
+
+            GetWindowThreadProcessId(janela, out var pid);
+            return (int)pid;
+        }
+        catch (Exception ex) when (ex is DllNotFoundException or EntryPointNotFoundException)
+        {
+            return 0;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Native/WlanInfo.cs b/GameBoost/src/GameBoost.Core/Native/WlanInfo.cs
new file mode 100644
index 0000000..f5deb78
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Native/WlanInfo.cs
@@ -0,0 +1,205 @@
+using System.Runtime.InteropServices;
+using System.Text;
+using GameBoost.Core.Modules.Network;
+
+namespace GameBoost.Core.Native;
+
+/// <summary>
+/// Lê SSID, sinal, canal e banda do Wi-Fi conectado pela API nativa do WLAN.
+///
+/// A alternativa óbvia seria rodar `netsh wlan show interfaces` e ler a saída,
+/// e é o que quase toda ferramenta faz. Só que essa saída é **traduzida**: num
+/// Windows em português os rótulos são "Sinal" e "Canal", em inglês são "Signal"
+/// e "Channel", e o parser quebra ao trocar de idioma. A API devolve números.
+/// </summary>
+public static class WlanInfo
+{
+    private const uint ClientVersion = 2;
+
+    private enum WLAN_INTF_OPCODE : uint
+    {
+        wlan_intf_opcode_current_connection = 7
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WLAN_INTERFACE_INFO
+    {
+        public Guid InterfaceGuid;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string strInterfaceDescription;
+        public uint isState;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WLAN_INTERFACE_INFO_LIST_HEADER
+    {
+        public uint dwNumberOfItems;
+        public uint dwIndex;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct DOT11_SSID
+    {
+        public uint uSSIDLength;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
+        public byte[] ucSSID;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WLAN_ASSOCIATION_ATTRIBUTES
+    {
+        public DOT11_SSID dot11Ssid;
+        public uint dot11BssType;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
+        public byte[] dot11Bssid;
+        public uint dot11PhyType;
+        public uint uDot11PhyIndex;
+        public uint wlanSignalQuality;
+        public uint ulRxRate;
+        public uint ulTxRate;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WLAN_CONNECTION_ATTRIBUTES
+    {
+        public uint isState;
+        public uint wlanConnectionMode;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+        public string strProfileName;
+        public WLAN_ASSOCIATION_ATTRIBUTES wlanAssociationAttributes;
+    }
+
+    [DllImport("wlanapi.dll")]
+    private static extern uint WlanOpenHandle(uint dwClientVersion, IntPtr pReserved,
+        out uint pdwNegotiatedVersion, out IntPtr phClientHandle);
+
+    [DllImport("wlanapi.dll")]
+    private static extern uint WlanCloseHandle(IntPtr hClientHandle, IntPtr pReserved);
+
+    [DllImport("wlanapi.dll")]
+    private static extern uint WlanEnumInterfaces(IntPtr hClientHandle, IntPtr pReserved, out IntPtr ppInterfaceList);
+
+    [DllImport("wlanapi.dll")]
+    private static extern uint WlanQueryInterface(IntPtr hClientHandle, ref Guid pInterfaceGuid,
+        WLAN_INTF_OPCODE OpCode, IntPtr pReserved, out uint pdwDataSize,
+        out IntPtr ppData, IntPtr pWlanOpcodeValueType);
+
+    [DllImport("wlanapi.dll")]
+    private static extern void WlanFreeMemory(IntPtr pMemory);
+
+    /// <summary>
+    /// <paramref name="idDoAdaptador"/> é o Id do NetworkInterface, que no
+    /// Windows é o GUID da interface entre chaves.
+    /// </summary>
+    public static EstadoWifi? Ler(string idDoAdaptador)
+    {
+        if (!Guid.TryParse(idDoAdaptador.Trim('{', '}'), out var alvo))
+            return null;
+
+        var handle = IntPtr.Zero;
+        var lista = IntPtr.Zero;
+
+        try
+        {
+            if (WlanOpenHandle(ClientVersion, IntPtr.Zero, out _, out handle) != 0)
+                return null;
+
+            if (WlanEnumInterfaces(handle, IntPtr.Zero, out lista) != 0)
+                return null;
+
+            var cabecalho = Marshal.PtrToStructure<WLAN_INTERFACE_INFO_LIST_HEADER>(lista);
+            var tamanhoItem = Marshal.SizeOf<WLAN_INTERFACE_INFO>();
+
+            for (var i = 0; i < cabecalho.dwNumberOfItems; i++)
+            {
+                var endereco = IntPtr.Add(lista, 8 + i * tamanhoItem);
+                var info = Marshal.PtrToStructure<WLAN_INTERFACE_INFO>(endereco);
+
+                if (info.InterfaceGuid != alvo)
+                    continue;
+
+                return Consultar(handle, info.InterfaceGuid);
+            }
+
+            return null;
+        }
+        finally
+        {
+            if (lista != IntPtr.Zero)
+                WlanFreeMemory(lista);
+
+            if (handle != IntPtr.Zero)
+                WlanCloseHandle(handle, IntPtr.Zero);
+        }
+    }
+
+    private static EstadoWifi? Consultar(IntPtr handle, Guid interfaceGuid)
+    {
+        var dados = IntPtr.Zero;
+
+        try
+        {
+            var guid = interfaceGuid;
+
+            if (WlanQueryInterface(handle, ref guid, WLAN_INTF_OPCODE.wlan_intf_opcode_current_connection,
+                    IntPtr.Zero, out _, out dados, IntPtr.Zero) != 0)
+            {
+                return null;
+            }
+
+            var conexao = Marshal.PtrToStructure<WLAN_CONNECTION_ATTRIBUTES>(dados);
+            var assoc = conexao.wlanAssociationAttributes;
+
+            var ssid = Encoding.UTF8.GetString(assoc.dot11Ssid.ucSSID, 0,
+                (int)Math.Min(assoc.dot11Ssid.uSSIDLength, 32));
+
+            var (banda, canal) = BandaECanal(assoc.dot11PhyType, assoc.ulRxRate);
+
+            return new EstadoWifi(
+                string.IsNullOrWhiteSpace(ssid) ? "rede sem nome" : ssid,
+                (int)assoc.wlanSignalQuality,
+                banda,
+                canal,
+                Padrao(assoc.dot11PhyType));
+        }
+        finally
+        {
+            if (dados != IntPtr.Zero)
+                WlanFreeMemory(dados);
+        }
+    }
+
+    /// <summary>
+    /// A API de conexão atual não devolve o canal diretamente — ele está na
+    /// lista de BSS, que é outra chamada e outra permissão. O que dá para
+    /// afirmar sem inventar é o padrão de rádio, e é isso que sai daqui.
+    /// </summary>
+    private static (string Banda, int Canal) BandaECanal(uint phyType, uint taxaKbps)
+    {
+        // 802.11a e ac só existem em 5 GHz; b e g só em 2,4. n e ax vivem nas
+        // duas, e aí a taxa é a única pista honesta que sobra.
+        var banda = phyType switch
+        {
+            2 or 8 => "5 GHz",                 // dot11_phy_type_ofdm, vht
+            4 or 5 => "2,4 GHz",               // hrdsss, erp
+            1 => "2,4 GHz",                    // fhss
+            _ => taxaKbps > 300_000 ? "5 GHz ou 6 GHz" : "banda não identificada"
+        };
+
+        return (banda, 0);
+    }
+
+    private static string Padrao(uint phyType) => phyType switch
+    {
+        1 => "802.11 (FHSS)",
+        2 => "802.11a",
+        4 => "802.11b",
+        5 => "802.11g",
+        7 => "802.11n",
+        8 => "802.11ac",
+        9 => "802.11ad",
+        10 => "802.11ax (Wi-Fi 6)",
+        11 => "802.11be (Wi-Fi 7)",
+        _ => "padrão não identificado"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/AntivirusDetector.cs b/GameBoost/src/GameBoost.Core/Safety/AntivirusDetector.cs
new file mode 100644
index 0000000..2f5a118
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/AntivirusDetector.cs
@@ -0,0 +1,56 @@
+using System.Management;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Safety;
+
+/// <summary>
+/// Descobre o antivirus ativo pelo SecurityCenter2 e converte o caminho do
+/// executavel em nomes de processo protegidos. A lista estatica de
+/// ProtectedProcesses.Seguranca cobre o que o WMI nao reportar.
+/// </summary>
+public sealed class AntivirusDetector
+{
+    private readonly IGameBoostLogger _log;
+
+    public AntivirusDetector(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public IReadOnlySet<string> Detectar()
+    {
+        var nomes = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var classe in new[] { "AntiVirusProduct", "AntiSpywareProduct", "FirewallProduct" })
+        {
+            try
+            {
+                using var consulta = new ManagementObjectSearcher(
+                    @"root\SecurityCenter2", $"SELECT displayName, pathToSignedProductExe FROM {classe}");
+
+                foreach (var item in consulta.Get())
+                {
+                    using var mo = (ManagementObject)item;
+                    var caminho = mo["pathToSignedProductExe"] as string;
+                    if (string.IsNullOrWhiteSpace(caminho))
+                        continue;
+
+                    var nome = Path.GetFileNameWithoutExtension(caminho);
+                    if (!string.IsNullOrWhiteSpace(nome))
+                        nomes.Add(nome);
+                }
+            }
+            catch (ManagementException ex)
+            {
+                _log.Warn("Safety", "DetectarAntivirus", classe,
+                    $"WMI indisponivel, usando apenas a lista estatica: {ex.Message}");
+            }
+            catch (UnauthorizedAccessException)
+            {
+                _log.Warn("Safety", "DetectarAntivirus", classe, "sem permissao para consultar o SecurityCenter2");
+            }
+        }
+
+        return nomes;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/ISafetyGuard.cs b/GameBoost/src/GameBoost.Core/Safety/ISafetyGuard.cs
new file mode 100644
index 0000000..8d53303
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/ISafetyGuard.cs
@@ -0,0 +1,34 @@
+namespace GameBoost.Core.Safety;
+
+public enum ProtectionReason
+{
+    None,
+    ProcessoCritico,
+    AntiCheat,
+    Seguranca,
+    DentroDoWindows,
+    OutraSessao,
+    ProprioApp,
+    ServicoProtegido,
+    CaminhoDeSistema,
+    CaminhoDoUsuario,
+    SegmentoProibido,
+    ListaDoUsuario
+}
+
+public sealed record ProtectionVerdict(bool Protegido, ProtectionReason Motivo, string Explicacao)
+{
+    public static ProtectionVerdict Livre { get; } = new(false, ProtectionReason.None, string.Empty);
+}
+
+/// <summary>
+/// Regra 6: a blindagem e aplicada por todos os modulos, nao so pelo Modo Game.
+/// Todo modulo consulta este guarda antes de tocar em qualquer coisa.
+/// </summary>
+public interface ISafetyGuard
+{
+    ProtectionVerdict CheckProcess(Abstractions.ProcessInfo process);
+    ProtectionVerdict CheckService(string serviceName, bool apenasPausar);
+    ProtectionVerdict CheckPath(string path, IReadOnlyList<string> whitelist);
+    bool PodePreMarcar(Abstractions.ProcessInfo process);
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/ProtectedPaths.cs b/GameBoost/src/GameBoost.Core/Safety/ProtectedPaths.cs
new file mode 100644
index 0000000..dcd5601
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/ProtectedPaths.cs
@@ -0,0 +1,36 @@
+namespace GameBoost.Core.Safety;
+
+/// <summary>Caminhos que nenhum modulo pode apagar ou mover (secao 9 do spec).</summary>
+public static class ProtectedPaths
+{
+    /// <summary>Pastas pessoais: conteudo do usuario nunca e alvo automatico.</summary>
+    public static IReadOnlyList<string> PastasDoUsuario() => new[]
+    {
+        Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
+        Environment.GetFolderPath(Environment.SpecialFolder.MyPictures),
+        Environment.GetFolderPath(Environment.SpecialFolder.MyVideos),
+        Environment.GetFolderPath(Environment.SpecialFolder.MyMusic),
+        Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
+        Environment.GetFolderPath(Environment.SpecialFolder.Favorites)
+    }.Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();
+
+    /// <summary>Pastas de sistema: so alcancaveis pela whitelist explicita de cada modulo.</summary>
+    public static IReadOnlyList<string> PastasDeSistema() => new[]
+    {
+        Environment.GetFolderPath(Environment.SpecialFolder.Windows),
+        Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
+        Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86),
+        Environment.GetFolderPath(Environment.SpecialFolder.System),
+        Environment.GetFolderPath(Environment.SpecialFolder.SystemX86)
+    }.Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();
+
+    /// <summary>
+    /// Segmentos que, aparecendo em qualquer nivel do caminho, tornam a pasta intocavel.
+    /// Protege saves, sincronizacao de nuvem e repositorios de codigo.
+    /// </summary>
+    public static readonly IReadOnlyList<string> SegmentosProibidos = new[]
+    {
+        ".git", "onedrive", "dropbox", "google drive", "icloud",
+        "saves", "savegames", "saved games", "savedgames", "my games"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/ProtectedProcesses.cs b/GameBoost/src/GameBoost.Core/Safety/ProtectedProcesses.cs
new file mode 100644
index 0000000..b527499
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/ProtectedProcesses.cs
@@ -0,0 +1,124 @@
+namespace GameBoost.Core.Safety;
+
+/// <summary>
+/// Listas de processos. Documentadas em docs/PROTECAO.md.
+/// Nomes sempre sem extensao e comparados sem diferenciar maiusculas.
+/// </summary>
+public static class ProtectedProcesses
+{
+    /// <summary>Nucleo do Windows. Encerrar qualquer um destes derruba a sessao ou o sistema.</summary>
+    public static readonly IReadOnlySet<string> Criticos = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "system", "idle", "registry", "memory compression", "secure system",
+        "smss", "csrss", "wininit", "winlogon", "services", "lsass", "lsaiso",
+        "svchost", "spoolsv", "dwm", "explorer", "fontdrvhost", "sihost",
+        "taskhostw", "ctfmon", "runtimebroker", "shellexperiencehost",
+        "startmenuexperiencehost", "searchhost", "searchindexer", "audiodg",
+        "conhost", "dllhost", "wudfhost", "wmiprvse", "trustedinstaller",
+        "tiworker", "logonui", "userinit", "dashost", "applicationframehost",
+        "textinputhost", "systemsettings", "backgroundtaskhost"
+    };
+
+    /// <summary>
+    /// Anti-cheats. Fechar qualquer um destes derruba o jogo ou gera ban.
+    /// Regra dura: nunca aparecem sequer selecionaveis.
+    /// </summary>
+    public static readonly IReadOnlySet<string> AntiCheats = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "easyanticheat", "easyanticheat_eos", "easyanticheat_setup",
+        "beservice", "bedaisy",
+        "vgc", "vgtray", "vgk",
+        "faceitservice", "faceit",
+        "pnkbstra", "pnkbstrb", "pnkbstrk",
+        "xigncode", "xhunter1",
+        "gameguard", "gamemon", "npggnt",
+        "nprotect", "ricochet", "eaanticheat", "eaantichea",
+        "battleye", "steamservice", "anticheatexpert", "ace-base", "ace-guard",
+        "mhyprot", "sgguard"
+    };
+
+    /// <summary>
+    /// Antivirus e EDR conhecidos. A deteccao real e por WMI (SecurityCenter2),
+    /// esta lista e a rede de seguranca para quando o WMI falhar.
+    /// </summary>
+    public static readonly IReadOnlySet<string> Seguranca = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "msmpeng", "nissrv", "securityhealthservice", "securityhealthsystray",
+        "mpdefendercoreservice", "smartscreen",
+        "avp", "avpui", "kavfs", "ksde", "ksdeui", "kpm", "klnagent", "avpsus",
+        "avastsvc", "avastui", "avgsvc", "avgui",
+        "bdagent", "vsserv", "bdservicehost",
+        "mcshield", "mfemms", "mfevtps",
+        "ns", "nortonsecurity", "nsservice",
+        "ekrn", "egui",
+        "sophosui", "savservice", "sedservice",
+        "cbservice", "csfalconservice", "csfalconcontainer",
+        "sentinelagent", "sentinelctl", "sentinelstaticengine",
+        "cylancesvc", "tmbmsrv", "tmccsf", "coreserviceshell",
+        "wrsa", "webroot", "malwarebytes", "mbamservice", "mbamtray"
+    };
+
+    /// <summary>
+    /// Launchers e ferramentas que o usuario pode querer fechar, mas que nunca
+    /// vem pre-marcadas (regra 3). Aparecem na lista, desmarcadas.
+    /// </summary>
+    public static readonly IReadOnlySet<string> NuncaPreMarcados = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "steam", "steamwebhelper", "epicgameslauncher", "epicwebhelper",
+        "battle.net", "agent", "riotclientservices", "riotclientux",
+        "galaxyclient", "galaxyclienthelper", "gog galaxy",
+        "eadesktop", "eabackgroundservice", "origin",
+        "ubisoftconnect", "upc", "uplay",
+        "xboxapp", "gamingservices", "xbox",
+        "rtss", "rivatuner", "msiafterburner",
+        "obs64", "obs32", "obs", "streamlabs obs", "xsplit.core",
+        "nvidia share", "nvcontainer", "radeonsoftware", "amddvr",
+        // IDEs, editores e assistentes de desenvolvimento. Costumam ter trabalho
+        // nao salvo aberto, entao nunca vem marcados (regra 3).
+        "devenv", "code", "code - insiders", "vscodium", "cursor", "windsurf",
+        "antigravity", "claude", "chatgpt", "zed", "sublime_text", "notepad++",
+        "rider64", "idea64", "pycharm64", "webstorm64", "clion64", "goland64",
+        "phpstorm64", "datagrip64", "android studio", "studio64", "eclipse",
+        "atom", "brackets", "godot", "unity", "unityhub", "ue4editor", "ue5editor",
+        "blender", "obsidian", "notion", "figma",
+        "photoshop", "illustrator", "premiere pro", "afterfx",
+        "excel", "winword", "powerpnt", "outlook",
+        "vmware", "vmware-vmx", "virtualbox", "vboxheadless", "docker desktop",
+
+        // Sincronizacao de nuvem: encerrar no meio de um envio deixa arquivo
+        // pela metade na nuvem. O spec (secao 5.6) manda avisar, nunca marcar.
+        "onedrive", "onedrive.sync.service", "filecoauth", "dropbox",
+        "googledrivefs", "megasync", "syncthing", "nextcloud"
+    };
+
+    /// <summary>
+    /// Instaladores e atualizadores em execucao. Encerrar um destes no meio do
+    /// trabalho pode deixar a instalacao corrompida, entao nunca vem marcado.
+    /// Detectado por padrao de nome, nao por lista: instalador novo aparece
+    /// toda semana.
+    /// </summary>
+    public static bool ParecerInstalador(string processName)
+    {
+        var nome = Normalizar(processName);
+
+        string[] marcadores =
+        {
+            "setup", "install", "updater", "update", "upgrade",
+            "patch", "msiexec", "redist", "unins"
+        };
+
+        if (marcadores.Any(m => nome.Contains(m, StringComparison.OrdinalIgnoreCase)))
+            return true;
+
+        // Instalador extraido para a pasta temporaria mantem o .tmp no nome.
+        return nome.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase);
+    }
+
+    public static string Normalizar(string processName)
+    {
+        var nome = processName.Trim();
+        if (nome.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+            nome = nome[..^4];
+        return nome;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/ProtectedServices.cs b/GameBoost/src/GameBoost.Core/Safety/ProtectedServices.cs
new file mode 100644
index 0000000..a45a912
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/ProtectedServices.cs
@@ -0,0 +1,26 @@
+namespace GameBoost.Core.Safety;
+
+/// <summary>Servicos que nenhum modulo pode parar ou desabilitar (secao 9 do spec).</summary>
+public static class ProtectedServices
+{
+    public static readonly IReadOnlySet<string> Intocaveis = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        // Nucleo
+        "DcomLaunch", "RpcSs", "RpcEptMapper", "Winmgmt", "EventLog", "Schedule",
+        "TrustedInstaller", "CryptSvc", "PlugPlay", "Power", "ProfSvc", "SamSs",
+        "LSM", "Themes", "UserManager", "gpsvc", "BrokerInfrastructure", "SystemEventsBroker",
+        // Rede
+        "Dhcp", "Dnscache", "nsi", "NlaSvc", "netprofm", "WlanSvc", "LanmanWorkstation",
+        // Audio
+        "Audiosrv", "AudioEndpointBuilder",
+        // Seguranca
+        "WinDefend", "SecurityHealthService", "wscsvc", "Sense", "mpssvc", "BFE",
+        "wuauserv" // so pausa temporaria dentro do Modo Game, nunca desabilitar
+    };
+
+    /// <summary>wuauserv pode ser pausado pelo Modo Game, mas nunca ter o StartType alterado.</summary>
+    public static readonly IReadOnlySet<string> PausaveisTemporariamente = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "wuauserv", "UsoSvc", "DoSvc", "BITS"
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Safety/SafetyGuard.cs b/GameBoost/src/GameBoost.Core/Safety/SafetyGuard.cs
new file mode 100644
index 0000000..521fa72
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Safety/SafetyGuard.cs
@@ -0,0 +1,177 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.Safety;
+
+public sealed class SafetyGuard : ISafetyGuard
+{
+    private readonly AppSettings _settings;
+    private readonly int _sessaoAtual;
+    private readonly int _pidProprio;
+    private readonly string _windowsDir;
+    private readonly IReadOnlySet<string> _antivirusDetectados;
+
+    public SafetyGuard(
+        AppSettings settings,
+        int sessaoAtual,
+        int pidProprio,
+        IReadOnlySet<string>? antivirusDetectados = null,
+        string? windowsDir = null)
+    {
+        _settings = settings;
+        _sessaoAtual = sessaoAtual;
+        _pidProprio = pidProprio;
+        _antivirusDetectados = antivirusDetectados ?? new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        _windowsDir = windowsDir ?? Environment.GetFolderPath(Environment.SpecialFolder.Windows);
+    }
+
+    public ProtectionVerdict CheckProcess(ProcessInfo process)
+    {
+        var nome = ProtectedProcesses.Normalizar(process.Name);
+
+        if (process.Pid == _pidProprio || nome.Equals("GameBoost", StringComparison.OrdinalIgnoreCase))
+            return new ProtectionVerdict(true, ProtectionReason.ProprioApp,
+                "O GameBoost nao encerra a si mesmo.");
+
+        if (process.Pid <= 4)
+            return new ProtectionVerdict(true, ProtectionReason.ProcessoCritico,
+                "Processo do nucleo do Windows.");
+
+        if (ProtectedProcesses.Criticos.Contains(nome))
+            return new ProtectionVerdict(true, ProtectionReason.ProcessoCritico,
+                $"{nome} faz parte do nucleo do Windows. Encerrar derruba a sessao.");
+
+        if (ProtectedProcesses.AntiCheats.Contains(nome))
+            return new ProtectionVerdict(true, ProtectionReason.AntiCheat,
+                $"{nome} e um anti-cheat. Fechar derruba o jogo e pode gerar banimento.");
+
+        if (ProtectedProcesses.Seguranca.Contains(nome) || _antivirusDetectados.Contains(nome))
+            return new ProtectionVerdict(true, ProtectionReason.Seguranca,
+                $"{nome} pertence ao antivirus ou a protecao do sistema.");
+
+        if (process.SessionId != _sessaoAtual)
+            return new ProtectionVerdict(true, ProtectionReason.OutraSessao,
+                "Processo de outro usuario conectado na maquina.");
+
+        if (!string.IsNullOrEmpty(process.ExecutablePath) && EstaDentroDe(process.ExecutablePath, _windowsDir))
+            return new ProtectionVerdict(true, ProtectionReason.DentroDoWindows,
+                "Executavel dentro de C:\\Windows.");
+
+        if (_settings.NuncaEncerrar.Any(n => ProtectedProcesses.Normalizar(n).Equals(nome, StringComparison.OrdinalIgnoreCase)))
+            return new ProtectionVerdict(true, ProtectionReason.ListaDoUsuario,
+                "Voce marcou este app na lista de nunca encerrar.");
+
+        return ProtectionVerdict.Livre;
+    }
+
+    /// <summary>
+    /// Regra 3: nada que possa causar perda vem marcado. Jogos, launchers, IDEs,
+    /// gravadores e o que o proprio usuario protegeu ficam desmarcados.
+    /// </summary>
+    public bool PodePreMarcar(ProcessInfo process)
+    {
+        if (CheckProcess(process).Protegido)
+            return false;
+
+        var nome = ProtectedProcesses.Normalizar(process.Name);
+
+        if (_settings.SempreEncerrar.Any(n => ProtectedProcesses.Normalizar(n).Equals(nome, StringComparison.OrdinalIgnoreCase)))
+            return true;
+
+        if (ProtectedProcesses.NuncaPreMarcados.Contains(nome))
+            return false;
+
+        if (ProtectedProcesses.ParecerInstalador(nome))
+            return false;
+
+        if (!string.IsNullOrEmpty(process.ExecutablePath) && ParecerJogo(process.ExecutablePath))
+            return false;
+
+        return true;
+    }
+
+    public ProtectionVerdict CheckService(string serviceName, bool apenasPausar)
+    {
+        if (apenasPausar && ProtectedServices.PausaveisTemporariamente.Contains(serviceName))
+            return ProtectionVerdict.Livre;
+
+        if (ProtectedServices.Intocaveis.Contains(serviceName))
+            return new ProtectionVerdict(true, ProtectionReason.ServicoProtegido,
+                $"O servico {serviceName} e essencial para o Windows, a rede, o audio ou a seguranca.");
+
+        return ProtectionVerdict.Livre;
+    }
+
+    /// <summary>
+    /// Um caminho so e liberado se estiver dentro de algum item da whitelist do modulo
+    /// e nao cair em nenhuma das listas proibidas. Whitelist vazia nao libera nada.
+    /// </summary>
+    public ProtectionVerdict CheckPath(string path, IReadOnlyList<string> whitelist)
+    {
+        string completo;
+        try
+        {
+            completo = Path.GetFullPath(path);
+        }
+        catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
+        {
+            return new ProtectionVerdict(true, ProtectionReason.SegmentoProibido, "Caminho invalido.");
+        }
+
+        var segmentos = completo.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        foreach (var proibido in ProtectedPaths.SegmentosProibidos)
+        {
+            if (segmentos.Any(s => s.Equals(proibido, StringComparison.OrdinalIgnoreCase)))
+                return new ProtectionVerdict(true, ProtectionReason.SegmentoProibido,
+                    $"Caminho contem o segmento {proibido}: pode guardar saves, codigo ou arquivos sincronizados.");
+        }
+
+        var naWhitelist = whitelist.Any(raiz => !string.IsNullOrWhiteSpace(raiz) && EstaDentroDe(completo, raiz));
+        if (!naWhitelist)
+            return new ProtectionVerdict(true, ProtectionReason.CaminhoDeSistema,
+                "Caminho fora da whitelist do modulo.");
+
+        foreach (var pessoal in ProtectedPaths.PastasDoUsuario())
+        {
+            if (EstaDentroDe(completo, pessoal) && !whitelist.Any(w => EstaDentroDe(w, pessoal)))
+                return new ProtectionVerdict(true, ProtectionReason.CaminhoDoUsuario,
+                    "Caminho dentro de uma pasta pessoal do usuario.");
+        }
+
+        return ProtectionVerdict.Livre;
+    }
+
+    private static bool ParecerJogo(string executablePath)
+    {
+        var p = executablePath.Replace('/', '\\');
+        string[] marcadores =
+        {
+            @"\steamapps\common\", @"\epic games\", @"\riot games\",
+            @"\battle.net\", @"\gog galaxy\games\", @"\gog games\",
+            @"\xboxgames\", @"\ea games\", @"\origin games\", @"\ubisoft\"
+        };
+        return marcadores.Any(m => p.Contains(m, StringComparison.OrdinalIgnoreCase));
+    }
+
+    /// <summary>Comparacao por segmento: C:\WindowsApps nao pode contar como dentro de C:\Windows.</summary>
+    private static bool EstaDentroDe(string caminho, string raiz)
+    {
+        if (string.IsNullOrWhiteSpace(raiz))
+            return false;
+
+        try
+        {
+            var c = Path.GetFullPath(caminho).TrimEnd(Path.DirectorySeparatorChar);
+            var r = Path.GetFullPath(raiz).TrimEnd(Path.DirectorySeparatorChar);
+
+            if (c.Equals(r, StringComparison.OrdinalIgnoreCase))
+                return true;
+
+            return c.StartsWith(r + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
+        }
+        catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException)
+        {
+            return false;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsFileSystem.cs b/GameBoost/src/GameBoost.Core/Services/WindowsFileSystem.cs
new file mode 100644
index 0000000..2dd6070
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Services/WindowsFileSystem.cs
@@ -0,0 +1,58 @@
+using GameBoost.Core.Abstractions;
+
+namespace GameBoost.Core.Services;
+
+public sealed class WindowsFileSystem : IFileSystem
+{
+    public bool FileExists(string path) => File.Exists(path);
+
+    public bool DirectoryExists(string path) => Directory.Exists(path);
+
+    public string ReadAllText(string path) => File.ReadAllText(path);
+
+    /// <summary>
+    /// Escrita atomica: grava .tmp e troca. O antivirus desta maquina costuma
+    /// segurar o .tmp por alguns milissegundos, entao a troca tem retry.
+    /// </summary>
+    public void WriteAllText(string path, string content)
+    {
+        var diretorio = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(diretorio))
+            Directory.CreateDirectory(diretorio);
+
+        var temporario = path + ".tmp";
+        File.WriteAllText(temporario, content);
+
+        for (var tentativa = 0; ; tentativa++)
+        {
+            try
+            {
+                File.Move(temporario, path, overwrite: true);
+                return;
+            }
+            catch (IOException) when (tentativa < 4)
+            {
+                Thread.Sleep(50 * (tentativa + 1));
+            }
+            catch (UnauthorizedAccessException) when (tentativa < 4)
+            {
+                Thread.Sleep(50 * (tentativa + 1));
+            }
+        }
+    }
+
+    public void CreateDirectory(string path) => Directory.CreateDirectory(path);
+
+    public void DeleteFile(string path) => File.Delete(path);
+
+    public void MoveFile(string source, string destination, bool overwrite)
+        => File.Move(source, destination, overwrite);
+
+    public long GetFileSize(string path) => new FileInfo(path).Length;
+
+    public IEnumerable<string> EnumerateFiles(string path, string pattern, SearchOption option)
+        => Directory.EnumerateFiles(path, pattern, option);
+
+    public IEnumerable<string> EnumerateDirectories(string path)
+        => Directory.EnumerateDirectories(path);
+}
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsMemoryService.cs b/GameBoost/src/GameBoost.Core/Services/WindowsMemoryService.cs
new file mode 100644
index 0000000..9dafe29
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Services/WindowsMemoryService.cs
@@ -0,0 +1,69 @@
+using System.Runtime.InteropServices;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Services;
+
+public sealed class WindowsMemoryService : IMemoryService
+{
+    private readonly IGameBoostLogger _log;
+    private bool _privilegioHabilitado;
+
+    public WindowsMemoryService(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public MemorySnapshot GetSnapshot()
+    {
+        var status = new NativeMethods.MEMORYSTATUSEX();
+        if (!NativeMethods.GlobalMemoryStatusEx(status))
+            return new MemorySnapshot(0, 0, 0);
+
+        return new MemorySnapshot(
+            TotalBytes: (long)status.ullTotalPhys,
+            AvailableBytes: (long)status.ullAvailPhys,
+            StandbyBytes: 0);
+    }
+
+    /// <summary>
+    /// Purga a Standby List: a memoria que o Windows guarda por precaucao com
+    /// dados ja usados. Ajuda quando falta RAM; nao aumenta FPS por si so.
+    /// </summary>
+    public bool PurgeStandbyList()
+    {
+        if (!_privilegioHabilitado)
+        {
+            _privilegioHabilitado = NativeMethods.EnablePrivilege(NativeMethods.SE_PROFILE_SINGLE_PROCESS_NAME);
+            if (!_privilegioHabilitado)
+            {
+                _log.Warn("Memory", "PurgeStandbyList", null,
+                    "sem SeProfileSingleProcessPrivilege: rode como administrador");
+                return false;
+            }
+        }
+
+        var comando = NativeMethods.MemoryPurgeStandbyList;
+        var buffer = Marshal.AllocHGlobal(sizeof(int));
+
+        try
+        {
+            Marshal.WriteInt32(buffer, comando);
+            var status = NativeMethods.NtSetSystemInformation(
+                NativeMethods.SystemMemoryListInformation, buffer, sizeof(int));
+
+            if (status != 0)
+            {
+                _log.Warn("Memory", "PurgeStandbyList", null, $"NtSetSystemInformation retornou 0x{status:X8}");
+                return false;
+            }
+
+            return true;
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(buffer);
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsPowerService.cs b/GameBoost/src/GameBoost.Core/Services/WindowsPowerService.cs
new file mode 100644
index 0000000..a57c126
Binary files /dev/null and b/GameBoost/src/GameBoost.Core/Services/WindowsPowerService.cs differ
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsProcessService.cs b/GameBoost/src/GameBoost.Core/Services/WindowsProcessService.cs
new file mode 100644
index 0000000..1f62c85
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Services/WindowsProcessService.cs
@@ -0,0 +1,403 @@
+using System.Diagnostics;
+using System.Management;
+using System.Runtime.InteropServices;
+using System.Text;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Native;
+
+namespace GameBoost.Core.Services;
+
+public sealed class WindowsProcessService : IProcessService
+{
+    private readonly IGameBoostLogger _log;
+
+    public WindowsProcessService(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public IReadOnlyList<ProcessInfo> GetProcesses()
+    {
+        var titulos = MapearTitulosDeJanela();
+        var linhasDeComando = MapearLinhasDeComando();
+        var resultado = new List<ProcessInfo>(256);
+
+        foreach (var p in Process.GetProcesses())
+        {
+            try
+            {
+                resultado.Add(Montar(p, titulos, linhasDeComando));
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception or ArgumentException)
+            {
+                // Processo morreu entre a listagem e a leitura. Normal, ignora.
+            }
+            finally
+            {
+                p.Dispose();
+            }
+        }
+
+        return resultado;
+    }
+
+    public ProcessInfo? GetProcess(int pid)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            return Montar(p, MapearTitulosDeJanela(), MapearLinhasDeComando());
+        }
+        catch (ArgumentException)
+        {
+            return null;
+        }
+    }
+
+    private static ProcessInfo Montar(
+        Process p,
+        IReadOnlyDictionary<int, string> titulos,
+        IReadOnlyDictionary<int, (string? CommandLine, string? Path)> detalhes)
+    {
+        detalhes.TryGetValue(p.Id, out var extra);
+        titulos.TryGetValue(p.Id, out var titulo);
+
+        NativeMethods.ProcessIdToSessionId(p.Id, out var sessionId);
+
+        return new ProcessInfo(
+            Pid: p.Id,
+            Name: p.ProcessName,
+            ExecutablePath: extra.Path ?? CaminhoSeguro(p),
+            CommandLine: extra.CommandLine,
+            WorkingSetBytes: SafeWorkingSet(p),
+            WindowTitle: string.IsNullOrWhiteSpace(titulo) ? null : titulo,
+            Company: null,
+            SessionId: sessionId);
+    }
+
+    private static long SafeWorkingSet(Process p)
+    {
+        try
+        {
+            return p.WorkingSet64;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            return 0;
+        }
+    }
+
+    private static string? CaminhoSeguro(Process p)
+    {
+        try
+        {
+            return p.MainModule?.FileName;
+        }
+        catch (Exception)
+        {
+            // Processo de outra sessao, protegido ou de bitness diferente.
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Uma unica consulta WMI traz caminho e linha de comando de todos os processos.
+    /// Consultar um a um custaria dezenas de segundos numa maquina cheia.
+    /// </summary>
+    private static Dictionary<int, (string? CommandLine, string? Path)> MapearLinhasDeComando()
+    {
+        var mapa = new Dictionary<int, (string?, string?)>();
+        try
+        {
+            using var consulta = new ManagementObjectSearcher(
+                "SELECT ProcessId, ExecutablePath, CommandLine FROM Win32_Process");
+
+            foreach (var item in consulta.Get())
+            {
+                using var mo = (ManagementObject)item;
+                var pid = Convert.ToInt32(mo["ProcessId"]);
+                mapa[pid] = (mo["CommandLine"] as string, mo["ExecutablePath"] as string);
+            }
+        }
+        catch (ManagementException)
+        {
+            // WMI indisponivel: segue sem linha de comando. A reabertura de essenciais
+            // fica sem argumentos, mas nada quebra.
+        }
+
+        return mapa;
+    }
+
+    private static Dictionary<int, string> MapearTitulosDeJanela()
+    {
+        var mapa = new Dictionary<int, string>();
+        var buffer = new StringBuilder(512);
+
+        NativeMethods.EnumWindows((hWnd, _) =>
+        {
+            if (!NativeMethods.IsWindowVisible(hWnd))
+                return true;
+
+            var tamanho = NativeMethods.GetWindowTextW(hWnd, buffer, buffer.Capacity);
+            if (tamanho == 0)
+                return true;
+
+            NativeMethods.GetWindowThreadProcessId(hWnd, out var pid);
+            if (pid != 0 && !mapa.ContainsKey(pid))
+                mapa[pid] = buffer.ToString();
+
+            return true;
+        }, IntPtr.Zero);
+
+        return mapa;
+    }
+
+    /// <summary>
+    /// Pede o fechamento normal primeiro. Apps com trabalho aberto mostram o
+    /// proprio dialogo de salvar e o usuario decide -- e por isso que o Kill so
+    /// vem depois (secao 1 do spec).
+    /// </summary>
+    public bool TryCloseGracefully(int pid, TimeSpan timeout)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            if (p.HasExited)
+                return true;
+
+            var pediu = false;
+            if (p.MainWindowHandle != IntPtr.Zero)
+                pediu = p.CloseMainWindow();
+
+            if (!pediu)
+                pediu = PostarWmCloseEmTodasAsJanelas(pid);
+
+            if (!pediu)
+                return false;
+
+            return p.WaitForExit((int)timeout.TotalMilliseconds);
+        }
+        catch (ArgumentException)
+        {
+            return true; // ja nao existe
+        }
+        catch (InvalidOperationException)
+        {
+            return true;
+        }
+    }
+
+    private static bool PostarWmCloseEmTodasAsJanelas(int pid)
+    {
+        var enviou = false;
+        NativeMethods.EnumWindows((hWnd, _) =>
+        {
+            NativeMethods.GetWindowThreadProcessId(hWnd, out var donoPid);
+            if (donoPid == pid && NativeMethods.IsWindowVisible(hWnd))
+            {
+                NativeMethods.PostMessageW(hWnd, NativeMethods.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
+                enviou = true;
+            }
+
+            return true;
+        }, IntPtr.Zero);
+
+        return enviou;
+    }
+
+    public bool Kill(int pid)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            p.Kill(entireProcessTree: true);
+            return p.WaitForExit(5000);
+        }
+        catch (ArgumentException)
+        {
+            return true;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception)
+        {
+            _log.Warn("Process", "Kill", pid.ToString(), $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public bool SetPriority(int pid, ProcessPriority priority)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            p.PriorityClass = Converter(priority);
+            return true;
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or System.ComponentModel.Win32Exception)
+        {
+            _log.Warn("Process", "SetPriority", pid.ToString(), $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public bool SetAffinity(int pid, IReadOnlyList<int> nucleos)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+
+            // Lista vazia = devolver a maquina inteira. E assim que o perfil
+            // reverte a afinidade ao fim do jogo.
+            if (nucleos.Count == 0)
+            {
+                p.ProcessorAffinity = (IntPtr)MascaraCompleta();
+                return true;
+            }
+
+            var total = Environment.ProcessorCount;
+
+            // Indice fora da maquina atual derrubaria o processo. Um perfil
+            // gravado num PC de 16 nucleos vai parar num de 4 mais cedo ou
+            // mais tarde.
+            if (nucleos.Any(n => n < 0 || n >= total))
+            {
+                _log.Warn("Process", "SetAffinity", pid.ToString(),
+                    $"perfil pede nucleo fora dos {total} desta maquina");
+                return false;
+            }
+
+            long mascara = 0;
+
+            foreach (var n in nucleos)
+                mascara |= 1L << n;
+
+            p.ProcessorAffinity = (IntPtr)mascara;
+            return true;
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or System.ComponentModel.Win32Exception)
+        {
+            _log.Warn("Process", "SetAffinity", pid.ToString(), $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public IReadOnlyList<int> GetAffinity(int pid)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            var mascara = (long)p.ProcessorAffinity;
+            var nucleos = new List<int>();
+
+            for (var i = 0; i < Environment.ProcessorCount; i++)
+            {
+                if ((mascara & (1L << i)) != 0)
+                    nucleos.Add(i);
+            }
+
+            return nucleos;
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or System.ComponentModel.Win32Exception)
+        {
+            return Array.Empty<int>();
+        }
+    }
+
+    private static long MascaraCompleta()
+    {
+        long mascara = 0;
+
+        for (var i = 0; i < Environment.ProcessorCount; i++)
+            mascara |= 1L << i;
+
+        return mascara;
+    }
+
+    public ProcessPriority? GetPriority(int pid)
+    {
+        try
+        {
+            using var p = Process.GetProcessById(pid);
+            return Converter(p.PriorityClass);
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidOperationException or System.ComponentModel.Win32Exception)
+        {
+            return null;
+        }
+    }
+
+    public bool Start(string executablePath, string? arguments, string? workingDirectory)
+    {
+        try
+        {
+            var info = new ProcessStartInfo
+            {
+                FileName = executablePath,
+                UseShellExecute = true,
+                WorkingDirectory = workingDirectory ?? Path.GetDirectoryName(executablePath) ?? string.Empty
+            };
+
+            if (!string.IsNullOrWhiteSpace(arguments))
+                info.Arguments = arguments;
+
+            using var iniciado = Process.Start(info);
+            return iniciado is not null;
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException or FileNotFoundException)
+        {
+            _log.Warn("Process", "Start", executablePath, $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public long TrimWorkingSet(int pid)
+    {
+        var handle = NativeMethods.OpenProcess(
+            NativeMethods.PROCESS_QUERY_LIMITED_INFORMATION | NativeMethods.PROCESS_SET_QUOTA,
+            false, pid);
+
+        if (handle == IntPtr.Zero)
+            return 0;
+
+        try
+        {
+            var tamanho = (uint)Marshal.SizeOf<NativeMethods.PROCESS_MEMORY_COUNTERS>();
+
+            if (!NativeMethods.GetProcessMemoryInfo(handle, out var antes, tamanho))
+                return 0;
+
+            if (!NativeMethods.EmptyWorkingSet(handle))
+                return 0;
+
+            if (!NativeMethods.GetProcessMemoryInfo(handle, out var depois, tamanho))
+                return 0;
+
+            var liberado = (long)antes.WorkingSetSize.ToUInt64() - (long)depois.WorkingSetSize.ToUInt64();
+            return liberado > 0 ? liberado : 0;
+        }
+        finally
+        {
+            NativeMethods.CloseHandle(handle);
+        }
+    }
+
+    private static ProcessPriorityClass Converter(ProcessPriority p) => p switch
+    {
+        ProcessPriority.Idle => ProcessPriorityClass.Idle,
+        ProcessPriority.BelowNormal => ProcessPriorityClass.BelowNormal,
+        ProcessPriority.Normal => ProcessPriorityClass.Normal,
+        ProcessPriority.AboveNormal => ProcessPriorityClass.AboveNormal,
+        ProcessPriority.High => ProcessPriorityClass.High,
+        _ => ProcessPriorityClass.Normal
+    };
+
+    private static ProcessPriority Converter(ProcessPriorityClass p) => p switch
+    {
+        ProcessPriorityClass.Idle => ProcessPriority.Idle,
+        ProcessPriorityClass.BelowNormal => ProcessPriority.BelowNormal,
+        ProcessPriorityClass.AboveNormal => ProcessPriority.AboveNormal,
+        ProcessPriorityClass.High => ProcessPriority.High,
+        ProcessPriorityClass.RealTime => ProcessPriority.High,
+        _ => ProcessPriority.Normal
+    };
+}
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsRegistryService.cs b/GameBoost/src/GameBoost.Core/Services/WindowsRegistryService.cs
new file mode 100644
index 0000000..109e5cf
Binary files /dev/null and b/GameBoost/src/GameBoost.Core/Services/WindowsRegistryService.cs differ
diff --git a/GameBoost/src/GameBoost.Core/Services/WindowsServiceControllerService.cs b/GameBoost/src/GameBoost.Core/Services/WindowsServiceControllerService.cs
new file mode 100644
index 0000000..56aabac
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Services/WindowsServiceControllerService.cs
@@ -0,0 +1,177 @@
+using System.Management;
+using System.ServiceProcess;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+// O enum do Core e o do System.ServiceProcess tem o mesmo nome: o alias fixa qual vale aqui.
+using ServiceStartMode = GameBoost.Core.Abstractions.ServiceStartMode;
+
+namespace GameBoost.Core.Services;
+
+public sealed class WindowsServiceControllerService : IServiceControllerService
+{
+    private readonly IGameBoostLogger _log;
+
+    public WindowsServiceControllerService(IGameBoostLogger log)
+    {
+        _log = log;
+    }
+
+    public ServiceInfo? GetService(string name)
+    {
+        try
+        {
+            using var sc = new ServiceController(name);
+            return new ServiceInfo(
+                sc.ServiceName,
+                sc.DisplayName,
+                sc.Status is ServiceControllerStatus.Running or ServiceControllerStatus.StartPending,
+                LerStartMode(name));
+        }
+        catch (InvalidOperationException)
+        {
+            return null;
+        }
+    }
+
+    public IReadOnlyList<ServiceInfo> GetServices()
+    {
+        var modos = LerTodosOsStartModes();
+        var lista = new List<ServiceInfo>();
+
+        foreach (var sc in ServiceController.GetServices())
+        {
+            try
+            {
+                lista.Add(new ServiceInfo(
+                    sc.ServiceName,
+                    sc.DisplayName,
+                    sc.Status is ServiceControllerStatus.Running or ServiceControllerStatus.StartPending,
+                    modos.TryGetValue(sc.ServiceName, out var modo) ? modo : ServiceStartMode.Manual));
+            }
+            catch (InvalidOperationException)
+            {
+            }
+            finally
+            {
+                sc.Dispose();
+            }
+        }
+
+        return lista;
+    }
+
+    public bool Stop(string name, TimeSpan timeout)
+    {
+        try
+        {
+            using var sc = new ServiceController(name);
+            if (sc.Status == ServiceControllerStatus.Stopped)
+                return true;
+
+            if (!sc.CanStop)
+            {
+                _log.Warn("Services", "Stop", name, "servico nao aceita parada");
+                return false;
+            }
+
+            sc.Stop();
+            sc.WaitForStatus(ServiceControllerStatus.Stopped, timeout);
+            return sc.Status == ServiceControllerStatus.Stopped;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or System.ServiceProcess.TimeoutException)
+        {
+            _log.Warn("Services", "Stop", name, $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public bool Start(string name, TimeSpan timeout)
+    {
+        try
+        {
+            using var sc = new ServiceController(name);
+            if (sc.Status == ServiceControllerStatus.Running)
+                return true;
+
+            sc.Start();
+            sc.WaitForStatus(ServiceControllerStatus.Running, timeout);
+            return sc.Status == ServiceControllerStatus.Running;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or System.ServiceProcess.TimeoutException)
+        {
+            _log.Warn("Services", "Start", name, $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    public bool SetStartMode(string name, ServiceStartMode mode)
+    {
+        try
+        {
+            using var servico = new ManagementObject($"Win32_Service.Name='{name}'");
+            var resultado = servico.InvokeMethod("ChangeStartMode", new object[] { Traduzir(mode) });
+            var codigo = Convert.ToUInt32(resultado);
+
+            if (codigo != 0)
+                _log.Warn("Services", "SetStartMode", name, $"ChangeStartMode retornou {codigo}");
+
+            return codigo == 0;
+        }
+        catch (ManagementException ex)
+        {
+            _log.Warn("Services", "SetStartMode", name, $"falhou: {ex.Message}");
+            return false;
+        }
+    }
+
+    private static string Traduzir(ServiceStartMode mode) => mode switch
+    {
+        ServiceStartMode.Boot => "Boot",
+        ServiceStartMode.System => "System",
+        ServiceStartMode.Automatic => "Automatic",
+        ServiceStartMode.Manual => "Manual",
+        ServiceStartMode.Disabled => "Disabled",
+        _ => "Manual"
+    };
+
+    private static ServiceStartMode LerStartMode(string name)
+    {
+        var modos = LerTodosOsStartModes();
+        return modos.TryGetValue(name, out var modo) ? modo : ServiceStartMode.Manual;
+    }
+
+    /// <summary>Uma consulta WMI so: ler servico a servico custaria segundos.</summary>
+    private static Dictionary<string, ServiceStartMode> LerTodosOsStartModes()
+    {
+        var mapa = new Dictionary<string, ServiceStartMode>(StringComparer.OrdinalIgnoreCase);
+
+        try
+        {
+            using var consulta = new ManagementObjectSearcher("SELECT Name, StartMode FROM Win32_Service");
+            foreach (var item in consulta.Get())
+            {
+                using var mo = (ManagementObject)item;
+                var nome = mo["Name"] as string;
+                var modo = mo["StartMode"] as string;
+                if (nome is null || modo is null)
+                    continue;
+
+                mapa[nome] = modo switch
+                {
+                    "Boot" => ServiceStartMode.Boot,
+                    "System" => ServiceStartMode.System,
+                    "Auto" => ServiceStartMode.Automatic,
+                    "Manual" => ServiceStartMode.Manual,
+                    "Disabled" => ServiceStartMode.Disabled,
+                    _ => ServiceStartMode.Manual
+                };
+            }
+        }
+        catch (ManagementException)
+        {
+        }
+
+        return mapa;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Settings/AppPaths.cs b/GameBoost/src/GameBoost.Core/Settings/AppPaths.cs
new file mode 100644
index 0000000..07e3042
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Settings/AppPaths.cs
@@ -0,0 +1,55 @@
+
+namespace GameBoost.Core.Settings;
+
+/// <summary>
+/// Resolve onde os dados vivem. Se existir portable.txt ao lado do exe, usa .\data\
+/// em vez de %LOCALAPPDATA%\GameBoost (secao 7 do spec).
+/// </summary>
+public sealed class AppPaths
+{
+    public AppPaths(string rootDirectory, bool portatil)
+    {
+        RootDirectory = rootDirectory;
+        Portatil = portatil;
+    }
+
+    public string RootDirectory { get; }
+    public bool Portatil { get; }
+
+    public string SettingsFile => Path.Combine(RootDirectory, "settings.json");
+    public string SessionFile => Path.Combine(RootDirectory, "session.json");
+    public string StateBackupFile => Path.Combine(RootDirectory, "state-backup.json");
+    public string LogFile => Path.Combine(RootDirectory, "gameboost.log");
+    public string CleanupHistoryFile => Path.Combine(RootDirectory, "cleanup-history.json");
+    public string ProfilesDirectory => Path.Combine(RootDirectory, "profiles");
+    public string HistoryDirectory => Path.Combine(RootDirectory, "history");
+    public string CacheDirectory => Path.Combine(RootDirectory, "cache");
+    public string BackupsDirectory => Path.Combine(RootDirectory, "backups");
+
+    public static AppPaths Resolve()
+    {
+        // Assembly.Location devolve string VAZIA num publish single-file, e ??
+        // nao trata vazio: o fallback quebraria justamente no formato em que o
+        // app e distribuido, que e onde o modo portatil importa.
+        // Environment.ProcessPath funciona em single-file.
+        var exeDir = Path.GetDirectoryName(Environment.ProcessPath) is { Length: > 0 } dir
+            ? dir
+            : AppContext.BaseDirectory;
+
+        var marcador = Path.Combine(exeDir, "portable.txt");
+        if (File.Exists(marcador))
+            return new AppPaths(Path.Combine(exeDir, "data"), portatil: true);
+
+        var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        return new AppPaths(Path.Combine(local, "GameBoost"), portatil: false);
+    }
+
+    public void EnsureDirectories()
+    {
+        Directory.CreateDirectory(RootDirectory);
+        Directory.CreateDirectory(ProfilesDirectory);
+        Directory.CreateDirectory(HistoryDirectory);
+        Directory.CreateDirectory(CacheDirectory);
+        Directory.CreateDirectory(BackupsDirectory);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Settings/AppSettings.cs b/GameBoost/src/GameBoost.Core/Settings/AppSettings.cs
new file mode 100644
index 0000000..8eb08fe
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Settings/AppSettings.cs
@@ -0,0 +1,86 @@
+using System.Text.Json.Serialization;
+
+namespace GameBoost.Core.Settings;
+
+/// <summary>App que o usuario marcou com estrela para reabrir sozinho ao sair do Modo Game.</summary>
+public sealed class EssentialApp
+{
+    public string Nome { get; set; } = string.Empty;
+    public string ExecutablePath { get; set; } = string.Empty;
+    public string? Argumentos { get; set; }
+    public string? WorkingDirectory { get; set; }
+}
+
+public sealed class AppSettings
+{
+    /// <summary>Incrementar sempre que o formato mudar e escrever o migrador correspondente.</summary>
+    public const int VersaoAtual = 2;
+
+    /// <summary>
+    /// Comeca em 0 de proposito: um settings.json da v1, que nao gravava este
+    /// campo, precisa desserializar como 0 para cair no migrador. Com o padrao
+    /// em VersaoAtual o arquivo antigo se disfarçaria de atual. Quem grava
+    /// carimba a versao corrente no Save.
+    /// </summary>
+    [JsonPropertyName("schemaVersion")]
+    public int SchemaVersion { get; set; }
+
+    public string Tema { get; set; } = "Dark";
+
+    /// <summary>Processos que o usuario nunca quer que apareçam pre-marcados.</summary>
+    public List<string> NuncaEncerrar { get; set; } = new();
+
+    /// <summary>Processos que o usuario sempre quer encerrar, mesmo sem pre-marcacao padrao.</summary>
+    public List<string> SempreEncerrar { get; set; } = new();
+
+    public List<EssentialApp> Essenciais { get; set; } = new();
+
+    public bool PausarWindowsUpdate { get; set; } = true;
+    public bool SilenciarNotificacoes { get; set; } = true;
+    public bool DesativarGameDvr { get; set; } = true;
+    public bool AplicarPlanoEnergia { get; set; } = true;
+    public bool SubirPrioridadeDoJogo { get; set; } = true;
+    public bool LimparRam { get; set; } = true;
+    public bool PurgarStandbyList { get; set; } = true;
+
+    /// <summary>Modo "so o essencial": so lista processos acima destes limites.</summary>
+    public bool SoOEssencial { get; set; }
+    public double LimiteCpuPercent { get; set; } = 2.0;
+    public long LimiteRamMegabytes { get; set; } = 300;
+
+    /// <summary>
+    /// Build do Windows na ultima execucao. E o que permite detectar que uma
+    /// atualizacao grande desfez os ajustes do usuario (secao 3.4).
+    /// </summary>
+    public string? UltimaBuildDoWindows { get; set; }
+
+    public bool IniciarComWindows { get; set; }
+    public bool IniciarMinimizado { get; set; }
+    public bool VerificarAtualizacoes { get; set; } = true;
+
+    /// <summary>
+    /// Autoriza o app a falar com a internet: teste de velocidade, consulta
+    /// STUN para descobrir o tipo de NAT e comparacao de DNS.
+    ///
+    /// **Desligado por padrao.** Regra 8 do spec: sem telemetria e sem chamada
+    /// externa que o usuario nao tenha pedido. Nada aqui manda dado nenhum
+    /// sobre a maquina; ainda assim, sair para a rede e uma escolha dele.
+    /// </summary>
+    public bool PermitirAcessoARede { get; set; }
+
+    /// <summary>Icone na bandeja com o menu da secao 6.</summary>
+    public bool MostrarNaBandeja { get; set; } = true;
+
+    /// <summary>
+    /// Vigiar os processos e avisar quando um jogo abrir (secao 5.1).
+    ///
+    /// Ligado por padrao: e a funcao que o usuario espera de um booster, e o
+    /// custo e um polling de 2 s numa thread de prioridade baixa. Mesmo ligado,
+    /// ele **pergunta** antes de ativar qualquer coisa, a nao ser que o perfil
+    /// daquele jogo diga o contrario.
+    /// </summary>
+    public bool DetectarJogosAutomaticamente { get; set; } = true;
+
+    /// <summary>As tres telas da primeira abertura ja foram vistas.</summary>
+    public bool OnboardingConcluido { get; set; }
+}
diff --git a/GameBoost/src/GameBoost.Core/Settings/SettingsMigrator.cs b/GameBoost/src/GameBoost.Core/Settings/SettingsMigrator.cs
new file mode 100644
index 0000000..be8b2c5
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Settings/SettingsMigrator.cs
@@ -0,0 +1,50 @@
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Settings;
+
+/// <summary>
+/// Migradores em sequencia, um por versao. A v1 do GameBoost nao gravava
+/// schemaVersion: um settings.json sem o campo desserializa como 0 e cai no
+/// migrador 0 -> 1.
+/// </summary>
+public static class SettingsMigrator
+{
+    public static AppSettings Migrar(AppSettings settings, IGameBoostLogger log)
+    {
+        while (settings.SchemaVersion < AppSettings.VersaoAtual)
+        {
+            var de = settings.SchemaVersion;
+            settings = de switch
+            {
+                0 => De0Para1(settings),
+                1 => De1Para2(settings),
+                _ => Encerrar(settings)
+            };
+            log.Info("Settings", "Migrar", $"v{de}", $"migrado para v{settings.SchemaVersion}");
+        }
+
+        return settings;
+    }
+
+    /// <summary>v1 do GameBoost: arquivo sem schemaVersion. So carimba a versao.</summary>
+    private static AppSettings De0Para1(AppSettings s)
+    {
+        s.SchemaVersion = 1;
+        return s;
+    }
+
+    /// <summary>v2: campos novos do modo "so o essencial" e de atualizacao.</summary>
+    private static AppSettings De1Para2(AppSettings s)
+    {
+        if (s.LimiteCpuPercent <= 0) s.LimiteCpuPercent = 2.0;
+        if (s.LimiteRamMegabytes <= 0) s.LimiteRamMegabytes = 300;
+        s.SchemaVersion = 2;
+        return s;
+    }
+
+    private static AppSettings Encerrar(AppSettings s)
+    {
+        s.SchemaVersion = AppSettings.VersaoAtual;
+        return s;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Settings/SettingsStore.cs b/GameBoost/src/GameBoost.Core/Settings/SettingsStore.cs
new file mode 100644
index 0000000..c841d06
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Settings/SettingsStore.cs
@@ -0,0 +1,76 @@
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.Settings;
+
+public interface ISettingsStore
+{
+    AppSettings Load();
+    void Save(AppSettings settings);
+}
+
+/// <summary>
+/// Le e grava settings.json. Na leitura roda os migradores em sequencia se o
+/// schemaVersion estiver atrasado; o arquivo antigo vira .bak, nunca e apagado (secao 7).
+/// </summary>
+public sealed class SettingsStore : ISettingsStore
+{
+    private static readonly JsonSerializerOptions Json = new()
+    {
+        WriteIndented = true,
+        PropertyNameCaseInsensitive = true
+    };
+
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+
+    public SettingsStore(AppPaths paths, IFileSystem fs, IGameBoostLogger log)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+    }
+
+    public AppSettings Load()
+    {
+        if (!_fs.FileExists(_paths.SettingsFile))
+        {
+            var novo = new AppSettings();
+            Save(novo);
+            return novo;
+        }
+
+        try
+        {
+            var texto = _fs.ReadAllText(_paths.SettingsFile);
+            var settings = JsonSerializer.Deserialize<AppSettings>(texto, Json) ?? new AppSettings();
+
+            if (settings.SchemaVersion < AppSettings.VersaoAtual)
+            {
+                _fs.WriteAllText(_paths.SettingsFile + ".bak", texto);
+                settings = SettingsMigrator.Migrar(settings, _log);
+                Save(settings);
+            }
+
+            return settings;
+        }
+        catch (JsonException ex)
+        {
+            _log.Error("Settings", "Load", _paths.SettingsFile, "JSON invalido, recriando com padroes", ex);
+            var texto = _fs.ReadAllText(_paths.SettingsFile);
+            _fs.WriteAllText(_paths.SettingsFile + ".bak", texto);
+            var novo = new AppSettings();
+            Save(novo);
+            return novo;
+        }
+    }
+
+    public void Save(AppSettings settings)
+    {
+        settings.SchemaVersion = AppSettings.VersaoAtual;
+        _fs.CreateDirectory(_paths.RootDirectory);
+        _fs.WriteAllText(_paths.SettingsFile, JsonSerializer.Serialize(settings, Json));
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/State/ChangeRecord.cs b/GameBoost/src/GameBoost.Core/State/ChangeRecord.cs
new file mode 100644
index 0000000..302cb55
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/State/ChangeRecord.cs
@@ -0,0 +1,47 @@
+using System.Text.Json.Serialization;
+
+namespace GameBoost.Core.State;
+
+public enum ChangeType
+{
+    Registry,
+    Service,
+    Power,
+    File,
+    Startup,
+    Process,
+    TimerResolution
+}
+
+/// <summary>
+/// Regra 1: toda alteracao de sistema grava o valor anterior aqui antes de ser
+/// aplicada. Sem ChangeRecord, a alteracao nao acontece.
+/// </summary>
+public sealed class ChangeRecord
+{
+    public string Id { get; set; } = Guid.NewGuid().ToString("N");
+    public string Modulo { get; set; } = string.Empty;
+    public ChangeType Tipo { get; set; }
+
+    /// <summary>Identificador do alvo: caminho da chave, nome do servico, GUID do plano.</summary>
+    public string Alvo { get; set; } = string.Empty;
+
+    /// <summary>Detalhe dentro do alvo: nome do valor no registro, por exemplo.</summary>
+    public string? SubAlvo { get; set; }
+
+    public string? ValorAnterior { get; set; }
+    public string? ValorNovo { get; set; }
+
+    /// <summary>Quando o valor anterior nao existia, reverter significa apagar, nao regravar.</summary>
+    public bool ValorAnteriorExistia { get; set; } = true;
+
+    /// <summary>Metadados livres do modulo (ex.: RegistryRoot e tipo do valor).</summary>
+    public Dictionary<string, string> Extras { get; set; } = new();
+
+    public DateTimeOffset Data { get; set; }
+    public bool Revertido { get; set; }
+    public DateTimeOffset? DataReversao { get; set; }
+
+    [JsonIgnore]
+    public bool Pendente => !Revertido;
+}
diff --git a/GameBoost/src/GameBoost.Core/State/RollbackEngine.cs b/GameBoost/src/GameBoost.Core/State/RollbackEngine.cs
new file mode 100644
index 0000000..5f43e2c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/State/RollbackEngine.cs
@@ -0,0 +1,254 @@
+using System.Globalization;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Core.State;
+
+public sealed record RollbackOutcome(string ChangeId, bool Sucesso, string Detalhe);
+
+public interface IRollbackEngine
+{
+    /// <summary>Reverte os ChangeRecord indicados. Lista vazia reverte tudo que estiver pendente.</summary>
+    IReadOnlyList<RollbackOutcome> Reverter(IReadOnlyList<string> changeIds, bool dryRun);
+
+    IReadOnlyList<RollbackOutcome> ReverterTudo(bool dryRun);
+}
+
+/// <summary>
+/// Desfaz na ordem inversa da aplicacao: o ultimo ChangeRecord gravado e o
+/// primeiro revertido. Um item que falha nao interrompe os demais -- deixar
+/// metade do sistema alterado seria pior que a falha isolada.
+/// </summary>
+public sealed class RollbackEngine : IRollbackEngine
+{
+    private readonly IStateBackup _backup;
+    private readonly IRegistryService _registry;
+    private readonly IServiceControllerService _services;
+    private readonly IPowerService _power;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _clock;
+
+    public RollbackEngine(
+        IStateBackup backup,
+        IRegistryService registry,
+        IServiceControllerService services,
+        IPowerService power,
+        IGameBoostLogger log,
+        IClock clock)
+    {
+        _backup = backup;
+        _registry = registry;
+        _services = services;
+        _power = power;
+        _log = log;
+        _clock = clock;
+    }
+
+    public IReadOnlyList<RollbackOutcome> ReverterTudo(bool dryRun) => Reverter(Array.Empty<string>(), dryRun);
+
+    public IReadOnlyList<RollbackOutcome> Reverter(IReadOnlyList<string> changeIds, bool dryRun)
+    {
+        var pendentes = _backup.Pendentes;
+        var alvos = changeIds.Count == 0
+            ? pendentes.ToList()
+            : pendentes.Where(r => changeIds.Contains(r.Id)).ToList();
+
+        // Ordem inversa: desfaz da alteracao mais recente para a mais antiga.
+        alvos.Reverse();
+
+        var resultados = new List<RollbackOutcome>(alvos.Count);
+        foreach (var record in alvos)
+        {
+            var resultado = ReverterUm(record, dryRun);
+            resultados.Add(resultado);
+
+            if (resultado.Sucesso && !dryRun)
+                _backup.MarcarRevertido(record.Id, _clock.Now);
+
+            _log.Log(resultado.Sucesso ? LogLevel.Info : LogLevel.Warn,
+                record.Modulo, dryRun ? "Reverter (dry-run)" : "Reverter",
+                record.Alvo, resultado.Detalhe);
+        }
+
+        return resultados;
+    }
+
+    private RollbackOutcome ReverterUm(ChangeRecord r, bool dryRun)
+    {
+        try
+        {
+            return r.Tipo switch
+            {
+                ChangeType.Registry => ReverterRegistro(r, dryRun),
+                ChangeType.Service => ReverterServico(r, dryRun),
+                ChangeType.Power => ReverterEnergia(r, dryRun),
+                ChangeType.TimerResolution => new RollbackOutcome(r.Id, true,
+                    "Resolucao de timer volta sozinha quando o processo libera o pedido."),
+                ChangeType.Process => new RollbackOutcome(r.Id, true,
+                    "Processos encerrados sao reabertos pela sessao do Modo Game, nao pelo rollback."),
+                ChangeType.File => new RollbackOutcome(r.Id, false,
+                    "Arquivos removidos so voltam pela Lixeira do Windows."),
+                ChangeType.Startup => ReverterRegistro(r, dryRun),
+                _ => new RollbackOutcome(r.Id, false, $"Tipo {r.Tipo} sem reversao implementada.")
+            };
+        }
+        catch (Exception ex) when (ex is UnauthorizedAccessException or IOException or InvalidOperationException)
+        {
+            return new RollbackOutcome(r.Id, false, $"Falhou: {ex.Message}");
+        }
+    }
+
+    private RollbackOutcome ReverterRegistro(ChangeRecord r, bool dryRun)
+    {
+        if (!r.Extras.TryGetValue("root", out var rootTexto) || !Enum.TryParse<RegistryRoot>(rootTexto, out var root))
+            return new RollbackOutcome(r.Id, false, "ChangeRecord sem a raiz do registro.");
+
+        var valueName = r.SubAlvo ?? string.Empty;
+
+        if (!r.ValorAnteriorExistia)
+        {
+            if (dryRun)
+                return new RollbackOutcome(r.Id, true, $"Apagaria {root}\\{r.Alvo}\\{valueName} (nao existia antes).");
+
+            _registry.DeleteValue(root, r.Alvo, valueName);
+            return new RollbackOutcome(r.Id, true, $"Valor {valueName} apagado: nao existia antes.");
+        }
+
+        if (!r.Extras.TryGetValue("kind", out var kindTexto) || !Enum.TryParse<RegistryValueKindLite>(kindTexto, out var kind))
+            kind = RegistryValueKindLite.String;
+
+        var valor = ConverterValor(r.ValorAnterior, kind);
+        if (valor is null)
+            return new RollbackOutcome(r.Id, false, "Valor anterior nao pode ser reconstruido.");
+
+        if (dryRun)
+            return new RollbackOutcome(r.Id, true, $"Restauraria {root}\\{r.Alvo}\\{valueName} = {r.ValorAnterior}.");
+
+        _registry.SetValue(root, r.Alvo, valueName, valor, kind);
+        return new RollbackOutcome(r.Id, true, $"Valor {valueName} restaurado para {r.ValorAnterior}.");
+    }
+
+    private RollbackOutcome ReverterServico(ChangeRecord r, bool dryRun)
+    {
+        var deveEstarRodando = r.Extras.TryGetValue("estavaRodando", out var rodando)
+            && bool.TryParse(rodando, out var b) && b;
+
+        var temStartMode = Enum.TryParse<ServiceStartMode>(r.ValorAnterior, out var modoAnterior);
+
+        if (dryRun)
+        {
+            var plano = temStartMode ? $"StartMode={modoAnterior}" : "StartMode inalterado";
+            return new RollbackOutcome(r.Id, true,
+                $"Restauraria {r.Alvo}: {plano}, rodando={deveEstarRodando}.");
+        }
+
+        var ok = true;
+        var detalhes = new List<string>();
+
+        if (temStartMode)
+        {
+            ok &= _services.SetStartMode(r.Alvo, modoAnterior);
+            detalhes.Add($"StartMode={modoAnterior}");
+        }
+
+        var atual = _services.GetService(r.Alvo);
+        if (atual is not null && deveEstarRodando && !atual.IsRunning)
+        {
+            ok &= _services.Start(r.Alvo, TimeSpan.FromSeconds(30));
+            detalhes.Add("reiniciado");
+        }
+        else if (atual is not null && !deveEstarRodando && atual.IsRunning)
+        {
+            ok &= _services.Stop(r.Alvo, TimeSpan.FromSeconds(30));
+            detalhes.Add("parado");
+        }
+
+        return new RollbackOutcome(r.Id, ok,
+            detalhes.Count == 0 ? "Servico ja estava no estado original." : string.Join(", ", detalhes));
+    }
+
+    private RollbackOutcome ReverterEnergia(ChangeRecord r, bool dryRun)
+    {
+        // A hibernacao tambem e energia, mas nao e um plano: e um comando do
+        // powercfg, e o que se guarda e se ela estava ligada antes.
+        if (r.Extras.TryGetValue("powercfg", out var comando))
+            return ReverterPowercfg(r, comando, dryRun);
+
+        if (!Guid.TryParse(r.ValorAnterior, out var plano))
+            return new RollbackOutcome(r.Id, false, "GUID do plano anterior invalido.");
+
+        if (dryRun)
+            return new RollbackOutcome(r.Id, true, $"Voltaria ao plano de energia {plano}.");
+
+        var ok = _power.SetActivePlan(plano);
+        return new RollbackOutcome(r.Id, ok,
+            ok ? "Plano de energia anterior restaurado." : "Nao foi possivel restaurar o plano de energia.");
+    }
+
+    /// <summary>
+    /// Desfaz um `powercfg` rodando o comando inverso, que vem gravado no
+    /// proprio ChangeRecord. Nao ha estado a reconstruir: ligar hibernacao e
+    /// exatamente o oposto de desligar.
+    /// </summary>
+    private RollbackOutcome ReverterPowercfg(ChangeRecord r, string comando, bool dryRun)
+    {
+        if (dryRun)
+            return new RollbackOutcome(r.Id, true, $"Rodaria powercfg {comando}.");
+
+        try
+        {
+            using var processo = System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "powercfg.exe",
+                Arguments = comando,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            });
+
+            if (processo is null)
+                return new RollbackOutcome(r.Id, false, "Nao foi possivel iniciar o powercfg.");
+
+            processo.WaitForExit(30_000);
+
+            return processo.ExitCode == 0
+                ? new RollbackOutcome(r.Id, true, $"powercfg {comando} executado.")
+                : new RollbackOutcome(r.Id, false, $"powercfg {comando} saiu com codigo {processo.ExitCode}.");
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException)
+        {
+            return new RollbackOutcome(r.Id, false, $"powercfg falhou: {ex.Message}");
+        }
+    }
+
+    private static object? ConverterValor(string? texto, RegistryValueKindLite kind)
+    {
+        if (texto is null)
+            return null;
+
+        return kind switch
+        {
+            RegistryValueKindLite.DWord => int.TryParse(texto, NumberStyles.Integer, CultureInfo.InvariantCulture, out var i) ? i : null,
+            RegistryValueKindLite.QWord => long.TryParse(texto, NumberStyles.Integer, CultureInfo.InvariantCulture, out var l) ? l : null,
+            RegistryValueKindLite.Binary => ConverterHex(texto),
+            RegistryValueKindLite.MultiString => texto.Split('', StringSplitOptions.RemoveEmptyEntries),
+            _ => texto
+        };
+    }
+
+    private static byte[]? ConverterHex(string texto)
+    {
+        if (texto.Length % 2 != 0)
+            return null;
+
+        try
+        {
+            return Convert.FromHexString(texto);
+        }
+        catch (FormatException)
+        {
+            return null;
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/State/StateBackup.cs b/GameBoost/src/GameBoost.Core/State/StateBackup.cs
new file mode 100644
index 0000000..943a0b9
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/State/StateBackup.cs
@@ -0,0 +1,137 @@
+using System.Text.Json;
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+
+namespace GameBoost.Core.State;
+
+public interface IStateBackup
+{
+    IReadOnlyList<ChangeRecord> Pendentes { get; }
+    IReadOnlyList<ChangeRecord> Todos { get; }
+    bool TemPendencias { get; }
+
+    ChangeRecord Registrar(ChangeRecord record);
+    void MarcarRevertido(string changeId, DateTimeOffset quando);
+    void Recarregar();
+    void Persistir();
+}
+
+/// <summary>
+/// Pilha de ChangeRecord em state-backup.json. Grava a cada alteracao: se o app
+/// travar ou o PC reiniciar com o Modo Game ativo, a proxima abertura le este
+/// arquivo e oferece a restauracao.
+/// </summary>
+public sealed class StateBackup : IStateBackup
+{
+    private static readonly JsonSerializerOptions Json = new()
+    {
+        WriteIndented = true,
+        PropertyNameCaseInsensitive = true
+    };
+
+    private readonly AppPaths _paths;
+    private readonly IFileSystem _fs;
+    private readonly IGameBoostLogger _log;
+    private readonly IClock _clock;
+    private readonly object _gate = new();
+    private List<ChangeRecord> _records = new();
+
+    public StateBackup(AppPaths paths, IFileSystem fs, IGameBoostLogger log, IClock clock)
+    {
+        _paths = paths;
+        _fs = fs;
+        _log = log;
+        _clock = clock;
+        Recarregar();
+    }
+
+    public IReadOnlyList<ChangeRecord> Pendentes
+    {
+        get { lock (_gate) return _records.Where(r => r.Pendente).ToList(); }
+    }
+
+    public IReadOnlyList<ChangeRecord> Todos
+    {
+        get { lock (_gate) return _records.ToList(); }
+    }
+
+    public bool TemPendencias
+    {
+        get { lock (_gate) return _records.Any(r => r.Pendente); }
+    }
+
+    public ChangeRecord Registrar(ChangeRecord record)
+    {
+        lock (_gate)
+        {
+            if (record.Data == default)
+                record.Data = _clock.Now;
+
+            _records.Add(record);
+            PersistirInterno();
+        }
+
+        _log.Info(record.Modulo, "Snapshot", record.Alvo,
+            $"anterior={record.ValorAnterior ?? "(inexistente)"} novo={record.ValorNovo ?? "-"}");
+        return record;
+    }
+
+    public void MarcarRevertido(string changeId, DateTimeOffset quando)
+    {
+        lock (_gate)
+        {
+            var alvo = _records.FirstOrDefault(r => r.Id == changeId);
+            if (alvo is null)
+                return;
+
+            alvo.Revertido = true;
+            alvo.DataReversao = quando;
+            PersistirInterno();
+        }
+    }
+
+    public void Recarregar()
+    {
+        lock (_gate)
+        {
+            if (!_fs.FileExists(_paths.StateBackupFile))
+            {
+                _records = new List<ChangeRecord>();
+                return;
+            }
+
+            try
+            {
+                var texto = _fs.ReadAllText(_paths.StateBackupFile);
+                _records = JsonSerializer.Deserialize<List<ChangeRecord>>(texto, Json) ?? new List<ChangeRecord>();
+            }
+            catch (JsonException ex)
+            {
+                // Perder o backup e pior que manter um arquivo ilegivel: preserva copia.
+                _log.Error("State", "Recarregar", _paths.StateBackupFile,
+                    "state-backup.json ilegivel, preservado como .corrompido", ex);
+                try
+                {
+                    _fs.WriteAllText(_paths.StateBackupFile + ".corrompido", _fs.ReadAllText(_paths.StateBackupFile));
+                }
+                catch (IOException)
+                {
+                }
+
+                _records = new List<ChangeRecord>();
+            }
+        }
+    }
+
+    public void Persistir()
+    {
+        lock (_gate) PersistirInterno();
+    }
+
+    private void PersistirInterno()
+    {
+        _fs.CreateDirectory(_paths.RootDirectory);
+        _fs.WriteAllText(_paths.StateBackupFile, JsonSerializer.Serialize(_records, Json));
+    }
+}
diff --git a/GameBoost/src/GameBoost.Core/Updates/UpdateService.cs b/GameBoost/src/GameBoost.Core/Updates/UpdateService.cs
new file mode 100644
index 0000000..2c262ed
--- /dev/null
+++ b/GameBoost/src/GameBoost.Core/Updates/UpdateService.cs
@@ -0,0 +1,211 @@
+using GameBoost.Core.Logging;
+using GameBoost.Core.Settings;
+using Velopack;
+using Velopack.Sources;
+
+namespace GameBoost.Core.Updates;
+
+/// <summary>Estado da checagem de atualização, para a tela mostrar.</summary>
+public enum EstadoDaAtualizacao
+{
+    NaoVerificado,
+    Verificando,
+    EmDia,
+    Disponivel,
+    Baixando,
+    ProntaParaInstalar,
+    Indisponivel
+}
+
+/// <summary>
+/// Atualização do próprio GameBoost, em cima do Velopack (seção 10).
+///
+/// Três coisas que ele **não** faz, e cada uma é uma decisão:
+///
+/// - **Não atualiza sozinho sem avisar.** A checagem na abertura é silenciosa, o
+///   download é em segundo plano, mas a troca de versão só acontece no próximo
+///   início e o usuário vê que ela está pendente.
+/// - **Não sai para a rede sem permissão.** A mesma chave que libera o teste de
+///   velocidade vale aqui. Desligada, o botão "Verificar" explica o que falta em
+///   vez de falhar calado.
+/// - **Não funciona no modo portátil, e diz isso.** O Velopack atualiza uma
+///   instalação que ele mesmo montou; um exe solto numa pasta não tem o que
+///   atualizar. Fingir que verificou seria pior que a mensagem honesta.
+/// </summary>
+public sealed class UpdateService
+{
+    /// <summary>Repositório das releases. É público e não exige token.</summary>
+    private const string Repositorio = "https://github.com/jvaz-DEVENG/showcase";
+
+    private readonly ISettingsStore _configuracoes;
+    private readonly AppPaths _paths;
+    private readonly IGameBoostLogger _log;
+
+    private UpdateManager? _gerente;
+    private UpdateInfo? _pendente;
+
+    public UpdateService(ISettingsStore configuracoes, AppPaths paths, IGameBoostLogger log)
+    {
+        _configuracoes = configuracoes;
+        _paths = paths;
+        _log = log;
+    }
+
+    public EstadoDaAtualizacao Estado { get; private set; } = EstadoDaAtualizacao.NaoVerificado;
+
+    public string? VersaoDisponivel { get; private set; }
+
+    public string? Motivo { get; private set; }
+
+    /// <summary>Versão em execução agora.</summary>
+    public string VersaoAtual =>
+        typeof(UpdateService).Assembly.GetName().Version?.ToString(3) ?? "desconhecida";
+
+    /// <summary>
+    /// Só há o que atualizar quando o Velopack instalou o app. No modo portátil
+    /// e durante o desenvolvimento não há pacote nenhum.
+    /// </summary>
+    public bool Suportado
+    {
+        get
+        {
+            if (_paths.Portatil)
+                return false;
+
+            try
+            {
+                return Gerente().IsInstalled;
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or IOException)
+            {
+                return false;
+            }
+        }
+    }
+
+    private UpdateManager Gerente()
+        => _gerente ??= new UpdateManager(new GithubSource(Repositorio, null, prerelease: false));
+
+    // ==================================================================
+
+    /// <summary>
+    /// Checagem silenciosa da abertura. Nunca mostra erro: se não deu, não deu,
+    /// e o usuário descobre quando clicar em Verificar.
+    /// </summary>
+    public async Task VerificarNaAberturaAsync(CancellationToken ct)
+    {
+        var settings = _configuracoes.Load();
+
+        if (!settings.VerificarAtualizacoes || !settings.PermitirAcessoARede || !Suportado)
+            return;
+
+        try
+        {
+            await VerificarAsync(ct);
+
+            if (Estado == EstadoDaAtualizacao.Disponivel)
+                await BaixarAsync(ct);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or IOException or InvalidOperationException)
+        {
+            _log.Info("update", "Abertura", null, $"checagem silenciosa falhou: {ex.Message}");
+        }
+    }
+
+    public async Task<EstadoDaAtualizacao> VerificarAsync(CancellationToken ct)
+    {
+        if (_paths.Portatil)
+        {
+            Estado = EstadoDaAtualizacao.Indisponivel;
+            Motivo = "No modo portátil não há instalação para atualizar. "
+                   + "Baixe a versão nova pela página de releases quando quiser trocar.";
+            return Estado;
+        }
+
+        if (!_configuracoes.Load().PermitirAcessoARede)
+        {
+            Estado = EstadoDaAtualizacao.Indisponivel;
+            Motivo = "Verificar atualizações precisa de acesso à internet, e essa permissão "
+                   + "está desligada. Ligue em Configurações, se quiser.";
+            return Estado;
+        }
+
+        if (!Suportado)
+        {
+            Estado = EstadoDaAtualizacao.Indisponivel;
+            Motivo = "Esta cópia não foi instalada pelo instalador do GameBoost, então não há "
+                   + "o que atualizar por aqui.";
+            return Estado;
+        }
+
+        Estado = EstadoDaAtualizacao.Verificando;
+        Motivo = null;
+
+        try
+        {
+            _pendente = await Gerente().CheckForUpdatesAsync().WaitAsync(ct);
+
+            if (_pendente is null)
+            {
+                Estado = EstadoDaAtualizacao.EmDia;
+                Motivo = $"Você está na versão {VersaoAtual}, que é a mais recente.";
+                _log.Info("update", "Verificar", null, "em dia");
+                return Estado;
+            }
+
+            VersaoDisponivel = _pendente.TargetFullRelease.Version.ToString();
+            Estado = EstadoDaAtualizacao.Disponivel;
+            Motivo = $"Versão {VersaoDisponivel} disponível. A sua é a {VersaoAtual}.";
+
+            _log.Info("update", "Verificar", null, $"{VersaoAtual} -> {VersaoDisponivel}");
+            return Estado;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or IOException or InvalidOperationException or TaskCanceledException)
+        {
+            Estado = EstadoDaAtualizacao.Indisponivel;
+            Motivo = $"Não foi possível verificar: {ex.Message}";
+            _log.Warn("update", "Verificar", null, ex.Message);
+            return Estado;
+        }
+    }
+
+    public async Task<EstadoDaAtualizacao> BaixarAsync(CancellationToken ct)
+    {
+        if (_pendente is null)
+            return Estado;
+
+        Estado = EstadoDaAtualizacao.Baixando;
+
+        try
+        {
+            await Gerente().DownloadUpdatesAsync(_pendente).WaitAsync(ct);
+
+            Estado = EstadoDaAtualizacao.ProntaParaInstalar;
+            Motivo = $"Versão {VersaoDisponivel} baixada. Ela entra no próximo início do GameBoost.";
+
+            _log.Info("update", "Baixar", VersaoDisponivel, "pronta para instalar");
+            return Estado;
+        }
+        catch (Exception ex) when (ex is HttpRequestException or IOException or InvalidOperationException or TaskCanceledException)
+        {
+            Estado = EstadoDaAtualizacao.Disponivel;
+            Motivo = $"O download falhou: {ex.Message}";
+            _log.Warn("update", "Baixar", VersaoDisponivel, ex.Message);
+            return Estado;
+        }
+    }
+
+    /// <summary>
+    /// Aplica a atualização e reinicia. Só deve ser chamado por um botão que o
+    /// usuário clicou: trocar a versão embaixo de alguém que está no meio de uma
+    /// operação é exatamente o que dá errado.
+    /// </summary>
+    public void InstalarEReiniciar()
+    {
+        if (_pendente is null || Estado != EstadoDaAtualizacao.ProntaParaInstalar)
+            return;
+
+        _log.Info("update", "Instalar", VersaoDisponivel, "aplicando e reiniciando");
+        Gerente().ApplyUpdatesAndRestart(_pendente);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/BottleneckTests.cs b/GameBoost/src/GameBoost.Tests/BottleneckTests.cs
new file mode 100644
index 0000000..79e27ea
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/BottleneckTests.cs
@@ -0,0 +1,351 @@
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.HealthReport;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+public sealed class MetricsBufferTests
+{
+    private static readonly DateTimeOffset T0 = new(2026, 9, 13, 20, 0, 0, TimeSpan.FromHours(-3));
+
+    private static MetricsSnapshot Amostra(int segundos, double cpu = 0)
+        => new() { Momento = T0.AddSeconds(segundos), CpuPercent = cpu };
+
+    [Fact]
+    public void Buffer_vazio_nao_tem_ultimo()
+    {
+        var buffer = new MetricsBuffer(10);
+
+        Assert.Equal(0, buffer.Quantidade);
+        Assert.Null(buffer.Ultimo);
+        Assert.Empty(buffer.Todos());
+    }
+
+    [Fact]
+    public void Buffer_preserva_a_ordem_cronologica()
+    {
+        var buffer = new MetricsBuffer(10);
+        for (var i = 0; i < 5; i++)
+            buffer.Adicionar(Amostra(i, cpu: i));
+
+        var todos = buffer.Todos();
+
+        Assert.Equal(5, todos.Count);
+        Assert.Equal(new double[] { 0, 1, 2, 3, 4 }, todos.Select(s => s.CpuPercent));
+        Assert.Equal(4, buffer.Ultimo!.CpuPercent);
+    }
+
+    [Fact]
+    public void Buffer_cheio_descarta_o_mais_antigo_e_nao_cresce()
+    {
+        var buffer = new MetricsBuffer(3);
+        for (var i = 0; i < 10; i++)
+            buffer.Adicionar(Amostra(i, cpu: i));
+
+        var todos = buffer.Todos();
+
+        Assert.Equal(3, buffer.Quantidade);
+        Assert.Equal(new double[] { 7, 8, 9 }, todos.Select(s => s.CpuPercent));
+    }
+
+    [Fact]
+    public void Janela_de_5_minutos_a_1_hz_cabe_em_300_amostras()
+    {
+        var buffer = new MetricsBuffer();
+
+        Assert.Equal(300, buffer.Capacidade);
+    }
+
+    [Fact]
+    public void Ultimos_filtra_pela_janela_de_tempo()
+    {
+        var buffer = new MetricsBuffer(300);
+        for (var i = 0; i < 120; i++)
+            buffer.Adicionar(Amostra(i, cpu: i));
+
+        var ultimos60 = buffer.Ultimos(TimeSpan.FromSeconds(60));
+
+        Assert.Equal(61, ultimos60.Count);
+        Assert.Equal(59, ultimos60[0].CpuPercent);
+    }
+
+    [Fact]
+    public void Limpar_zera_o_buffer()
+    {
+        var buffer = new MetricsBuffer(5);
+        buffer.Adicionar(Amostra(0));
+        buffer.Limpar();
+
+        Assert.Equal(0, buffer.Quantidade);
+        Assert.Null(buffer.Ultimo);
+    }
+
+    [Fact]
+    public void Capacidade_invalida_e_rejeitada()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new MetricsBuffer(0));
+    }
+}
+
+public sealed class FindingEngineTests
+{
+    private static readonly DateTimeOffset T0 = new(2026, 9, 13, 20, 0, 0, TimeSpan.FromHours(-3));
+
+    private readonly FakeLogger _log = new();
+    private readonly FakeClock _clock = new();
+
+    /// <summary>Regra controlada: dispara so quando mandado.</summary>
+    private sealed class RegraDeTeste : IFindingRule
+    {
+        public string Id => "teste";
+        public bool Dispara { get; set; } = true;
+        public int Impacto { get; set; } = 50;
+        public FindingSeverity Severidade { get; set; } = FindingSeverity.Atencao;
+
+        public Finding? Avaliar(FindingContext ctx) => Dispara
+            ? new Finding
+            {
+                Id = Id,
+                RegraId = Id,
+                Titulo = "achado",
+                Detalhe = "detalhe",
+                Impacto = Impacto,
+                Severidade = Severidade,
+                Momento = ctx.Atual.Momento
+            }
+            : null;
+    }
+
+    private sealed class RegraQueQuebra : IFindingRule
+    {
+        public string Id => "quebrada";
+
+        public Finding? Avaliar(FindingContext ctx) => throw new InvalidOperationException("erro proposital");
+    }
+
+    private static FindingContext Ctx(int segundos = 0) => new()
+    {
+        Atual = new MetricsSnapshot { Momento = T0.AddSeconds(segundos) }
+    };
+
+    [Fact]
+    public void Regras_padrao_cobrem_a_tabela_da_secao_5_5()
+    {
+        Assert.Equal(17, FindingEngine.RegrasPadrao().Count);
+    }
+
+    [Fact]
+    public void Finding_repetido_nao_duplica_na_lista()
+    {
+        var regra = new RegraDeTeste();
+        var motor = new FindingEngine(_log, _clock, new IFindingRule[] { regra });
+
+        motor.Avaliar(Ctx(0));
+        motor.Avaliar(Ctx(1));
+        var terceira = motor.Avaliar(Ctx(2));
+
+        Assert.Single(terceira);
+    }
+
+    [Fact]
+    public void Finding_que_parou_de_valer_some_so_depois_do_debounce()
+    {
+        var regra = new RegraDeTeste();
+        var motor = new FindingEngine(_log, _clock, new IFindingRule[] { regra });
+
+        motor.Avaliar(Ctx(0));
+        regra.Dispara = false;
+
+        // Dentro da janela de 30 s continua na tela, para nao piscar.
+        Assert.Single(motor.Avaliar(Ctx(10)));
+        Assert.Single(motor.Avaliar(Ctx(29)));
+
+        // Passada a janela, some.
+        Assert.Empty(motor.Avaliar(Ctx(40)));
+    }
+
+    [Fact]
+    public void Regra_que_lanca_excecao_nao_derruba_as_outras()
+    {
+        var motor = new FindingEngine(_log, _clock, new IFindingRule[]
+        {
+            new RegraQueQuebra(),
+            new RegraDeTeste()
+        });
+
+        var findings = motor.Avaliar(Ctx());
+
+        Assert.Single(findings);
+        Assert.Contains(_log.Linhas, l => l.Modulo == "Bottleneck" && l.Alvo == "quebrada");
+    }
+
+    [Fact]
+    public void Findings_saem_ordenados_por_severidade_e_impacto()
+    {
+        var baixo = new RegraDeTeste { Impacto = 10, Severidade = FindingSeverity.Informativo };
+        var motor = new FindingEngine(_log, _clock, new IFindingRule[] { baixo });
+
+        var findings = motor.Avaliar(Ctx());
+
+        Assert.Single(findings);
+        Assert.Equal(FindingSeverity.Informativo, findings[0].Severidade);
+    }
+
+    [Fact]
+    public void Limpar_esvazia_os_findings_ativos()
+    {
+        var motor = new FindingEngine(_log, _clock, new IFindingRule[] { new RegraDeTeste() });
+        motor.Avaliar(Ctx());
+        motor.Limpar();
+
+        Assert.Empty(motor.Atuais());
+    }
+}
+
+public sealed class FindingContextTests
+{
+    private static readonly DateTimeOffset T0 = new(2026, 9, 13, 20, 0, 0, TimeSpan.FromHours(-3));
+
+    private static FindingContext Montar(params double[] cpus)
+    {
+        var historico = cpus
+            .Select((c, i) => new MetricsSnapshot { Momento = T0.AddSeconds(i - cpus.Length + 1), CpuPercent = c })
+            .ToList();
+
+        return new FindingContext { Atual = historico[^1], Historico = historico };
+    }
+
+    [Fact]
+    public void Sustentado_exige_a_condicao_em_toda_a_janela()
+    {
+        var ctx = Montar(95, 96, 97, 98, 99, 97);
+
+        Assert.True(ctx.SustentadoPor(TimeSpan.FromSeconds(10), s => s.CpuPercent > 90));
+    }
+
+    [Fact]
+    public void Sustentado_falha_se_qualquer_amostra_quebrar_a_condicao()
+    {
+        var ctx = Montar(95, 96, 10, 98, 99, 97);
+
+        Assert.False(ctx.SustentadoPor(TimeSpan.FromSeconds(10), s => s.CpuPercent > 90));
+    }
+
+    [Fact]
+    public void Sustentado_exige_um_minimo_de_amostras()
+    {
+        // Duas amostras nao provam nada sobre 30 segundos.
+        var ctx = Montar(95, 97);
+
+        Assert.False(ctx.SustentadoPor(TimeSpan.FromSeconds(30), s => s.CpuPercent > 90));
+    }
+
+    [Fact]
+    public void Media_na_janela_ignora_valores_ausentes()
+    {
+        var ctx = Montar(10, 20, 30);
+
+        Assert.Equal(20, ctx.MediaNaJanela(TimeSpan.FromSeconds(10), s => s.CpuPercent));
+    }
+
+    [Fact]
+    public void Media_sem_amostras_e_nula()
+    {
+        var ctx = Montar(10);
+
+        Assert.Null(ctx.MediaNaJanela(TimeSpan.FromSeconds(10), _ => (double?)null));
+    }
+}
+
+public sealed class HealthScoreTests
+{
+    private static Finding F(HealthArea area, int penalidade, FindingSeverity sev = FindingSeverity.Atencao, int impacto = 50)
+        => new()
+        {
+            Id = Guid.NewGuid().ToString("N"),
+            RegraId = "r",
+            Titulo = "t",
+            Detalhe = "d",
+            Area = area,
+            Penalidade = penalidade,
+            Severidade = sev,
+            Impacto = impacto
+        };
+
+    [Fact]
+    public void Sem_findings_todas_as_areas_valem_100()
+    {
+        var score = HealthScore.Calcular(Array.Empty<Finding>());
+
+        Assert.Equal(100, score.NotaGeral);
+        Assert.Equal("Otimo", score.Conceito);
+        Assert.All(score.Areas, a => Assert.Equal(100, a.Nota));
+    }
+
+    [Fact]
+    public void Penalidades_da_mesma_area_se_somam()
+    {
+        var score = HealthScore.Calcular(new[]
+        {
+            F(HealthArea.Desempenho, 25),
+            F(HealthArea.Desempenho, 10)
+        });
+
+        var desempenho = score.Areas.Single(a => a.Area == HealthArea.Desempenho);
+
+        Assert.Equal(65, desempenho.Nota);
+        Assert.Equal(100, score.Areas.Single(a => a.Area == HealthArea.Espaco).Nota);
+    }
+
+    [Fact]
+    public void Nota_nunca_passa_dos_limites()
+    {
+        var score = HealthScore.Calcular(new[] { F(HealthArea.Espaco, 500) });
+
+        Assert.Equal(0, score.Areas.Single(a => a.Area == HealthArea.Espaco).Nota);
+    }
+
+    [Fact]
+    public void Finding_informativo_sem_penalidade_nao_baixa_a_nota()
+    {
+        // VBS ativo e GPU no limite sao fatos, nao defeitos.
+        var score = HealthScore.Calcular(new[] { F(HealthArea.ConfiguracaoParaJogos, 0, FindingSeverity.Informativo) });
+
+        Assert.Equal(100, score.NotaGeral);
+    }
+
+    [Fact]
+    public void Principais_traz_no_maximo_cinco_ordenados_por_severidade()
+    {
+        var findings = new[]
+        {
+            F(HealthArea.Desempenho, 5, FindingSeverity.Informativo, 10),
+            F(HealthArea.Desempenho, 5, FindingSeverity.Critico, 90),
+            F(HealthArea.Espaco, 5, FindingSeverity.Atencao, 50),
+            F(HealthArea.Espaco, 5, FindingSeverity.Informativo, 20),
+            F(HealthArea.Inicializacao, 5, FindingSeverity.Informativo, 30),
+            F(HealthArea.Inicializacao, 5, FindingSeverity.Informativo, 40)
+        };
+
+        var score = HealthScore.Calcular(findings);
+
+        Assert.Equal(5, score.Principais.Count);
+        Assert.Equal(FindingSeverity.Critico, score.Principais[0].Severidade);
+    }
+
+    [Theory]
+    [InlineData(0, "Critico")]
+    [InlineData(30, "Precisa de atencao")]
+    [InlineData(60, "Da para melhorar")]
+    [InlineData(80, "Bom")]
+    [InlineData(95, "Otimo")]
+    public void Conceito_acompanha_a_nota(int penalidadePorArea, string esperado)
+    {
+        var desconto = 100 - penalidadePorArea;
+        var findings = Enum.GetValues<HealthArea>().Select(a => F(a, desconto)).ToArray();
+
+        var score = HealthScore.Calcular(findings);
+
+        Assert.Equal(esperado, score.Conceito);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/CleanerTests.cs b/GameBoost/src/GameBoost.Tests/CleanerTests.cs
new file mode 100644
index 0000000..92301ad
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/CleanerTests.cs
@@ -0,0 +1,302 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Cleaner;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Settings;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Critério de aceite da seção 5.2: nenhum arquivo fora da whitelist pode ser
+/// tocado. O FakeFileSystem registra todo caminho removido, então o teste
+/// confere isso de verdade, e não por inspeção do código.
+/// </summary>
+public sealed class CleanerTests
+{
+    private readonly FakeFileSystem _fs = new();
+    private readonly FakeLogger _log = new();
+    private readonly FakeClock _clock = new();
+    private readonly FakeServices _servicos = new();
+    private readonly CleanupHistory _historico;
+    private readonly AppPaths _paths = new(@"C:\dados\GameBoost", portatil: false);
+
+    public CleanerTests()
+    {
+        _historico = new CleanupHistory(_paths, _fs, _log);
+    }
+
+    private CleanerModule Montar(AppSettings? settings = null, params string[] processosAbertos)
+    {
+        var guard = new SafetyGuard(settings ?? new AppSettings(), 1, 4242,
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase), @"C:\Windows");
+
+        return new CleanerModule(_fs, new FakeProcessos(processosAbertos), _servicos, guard,
+            _historico, _log, _clock);
+    }
+
+    /// <summary>Lista fixa de processos, para simular navegador aberto ou fechado.</summary>
+    private sealed class FakeProcessos : IProcessService
+    {
+        private readonly IReadOnlyList<string> _nomes;
+
+        public FakeProcessos(IReadOnlyList<string> nomes) => _nomes = nomes;
+
+        public IReadOnlyList<ProcessInfo> GetProcesses()
+            => _nomes.Select((n, i) => new ProcessInfo(1000 + i, n, null, null, 0, null, null, 1)).ToList();
+
+        public ProcessInfo? GetProcess(int pid) => null;
+        public bool TryCloseGracefully(int pid, TimeSpan timeout) => true;
+        public bool Kill(int pid) => true;
+        public bool SetPriority(int pid, ProcessPriority priority) => true;
+        public ProcessPriority? GetPriority(int pid) => ProcessPriority.Normal;
+        public bool Start(string executablePath, string? arguments, string? workingDirectory) => true;
+        public long TrimWorkingSet(int pid) => 0;
+    
+    public bool SetAffinity(int pid, IReadOnlyList<int> nucleos) => true;
+    public IReadOnlyList<int> GetAffinity(int pid) => Array.Empty<int>();
+}
+
+    // ---------------- Catálogo ----------------
+
+    [Fact]
+    public void Catalogo_nao_tem_ids_repetidos()
+    {
+        var ids = CleanupCatalog.Todos().Select(t => t.Id).ToList();
+
+        Assert.Equal(ids.Count, ids.Distinct(StringComparer.OrdinalIgnoreCase).Count());
+    }
+
+    [Fact]
+    public void Todo_alvo_explica_como_desfazer()
+    {
+        // Regra 4 e seção 6: cada item precisa responder "como desfazer".
+        Assert.All(CleanupCatalog.Todos(), alvo =>
+            Assert.False(string.IsNullOrWhiteSpace(alvo.ComoDesfazer), $"{alvo.Id} sem ComoDesfazer"));
+    }
+
+    [Fact]
+    public void Alvo_de_risco_medio_ou_alto_nunca_vem_pre_marcado()
+    {
+        // Regra 3.
+        Assert.All(CleanupCatalog.Todos().Where(a => a.Risco != RiskLevel.Baixo),
+            alvo => Assert.False(alvo.PreMarcadoPadrao, $"{alvo.Id} e risco {alvo.Risco} mas vem marcado"));
+    }
+
+    [Fact]
+    public void Alvo_que_mexe_em_pasta_do_usuario_vai_para_a_lixeira()
+    {
+        // Regra 2: conteúdo do usuário nunca é apagado direto.
+        var downloads = CleanupCatalog.Todos().Single(a => a.Id == "instaladores-esquecidos");
+
+        Assert.Equal(RemocaoModo.Lixeira, downloads.Modo);
+        Assert.True(downloads.ApenasSugestao, "Downloads e pasta do usuario: so pode ser sugestao");
+    }
+
+    [Fact]
+    public void Alvo_com_efeito_colateral_explica_o_efeito()
+    {
+        foreach (var id in new[] { "shader-nvidia", "shader-directx", "prefetch", "miniaturas", "cache-spotify" })
+        {
+            var alvo = CleanupCatalog.Todos().Single(a => a.Id == id);
+            Assert.False(string.IsNullOrWhiteSpace(alvo.Advertencia), $"{id} sem advertencia");
+        }
+    }
+
+    [Fact]
+    public void Cache_de_navegador_nunca_toca_em_dados_de_sessao()
+    {
+        // Nunca cookies, senhas nem histórico (seção 5.2).
+        var navegadores = CleanupCatalog.Todos().Where(a => a.Categoria == "Navegadores");
+
+        Assert.NotEmpty(navegadores);
+        Assert.All(navegadores, alvo =>
+        {
+            var caminho = alvo.Raiz()?.ToLowerInvariant() ?? string.Empty;
+            Assert.DoesNotContain("cookies", caminho);
+            Assert.DoesNotContain("login data", caminho);
+            Assert.DoesNotContain("history", caminho);
+        });
+    }
+
+    [Fact]
+    public void Cache_de_navegador_exige_o_navegador_fechado()
+    {
+        Assert.All(CleanupCatalog.Todos().Where(a => a.Categoria == "Navegadores"),
+            alvo => Assert.NotEmpty(alvo.ExigeFechado));
+    }
+
+    // ---------------- Whitelist ----------------
+
+    [Fact]
+    public async Task Nenhum_arquivo_fora_da_whitelist_e_removido()
+    {
+        var temp = Path.GetTempPath();
+        var whitelist = CleanupCatalog.RaizesPermitidas();
+
+        // Um arquivo legítimo e três que a blindagem tem que barrar.
+        _fs.Diretorios.Add(temp);
+        _fs.Arquivos[Path.Combine(temp, "lixo.tmp")] = "x";
+        _fs.Arquivos[@"C:\Windows\System32\config\SAM"] = "x";
+        _fs.Arquivos[Path.Combine(temp, "projeto", ".git", "objects", "abc")] = "x";
+        _fs.Arquivos[Path.Combine(temp, "jogo", "saves", "slot1.sav")] = "x";
+
+        var modulo = Montar();
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+        await modulo.ApplyAsync(scan.Itens.Select(i => i.Id).ToList(), dryRun: false, CancellationToken.None);
+
+        var guard = new SafetyGuard(new AppSettings(), 1, 4242, null, @"C:\Windows");
+
+        Assert.All(_fs.Remocoes, caminho =>
+            Assert.False(guard.CheckPath(caminho, whitelist).Protegido,
+                $"removeu fora da whitelist: {caminho}"));
+
+        Assert.DoesNotContain(@"C:\Windows\System32\config\SAM", _fs.Remocoes);
+        Assert.DoesNotContain(_fs.Remocoes, c => c.Contains(".git", StringComparison.OrdinalIgnoreCase));
+        Assert.DoesNotContain(_fs.Remocoes, c => c.Contains("saves", StringComparison.OrdinalIgnoreCase));
+    }
+
+    [Fact]
+    public async Task Dry_run_nao_remove_nada()
+    {
+        var temp = Path.GetTempPath();
+        _fs.Diretorios.Add(temp);
+        for (var i = 0; i < 5; i++)
+            _fs.Arquivos[Path.Combine(temp, $"lixo{i}.tmp")] = new string('x', 1000);
+
+        var modulo = Montar();
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+        var resultado = await modulo.ApplyAsync(
+            scan.Itens.Select(i => i.Id).ToList(), dryRun: true, CancellationToken.None);
+
+        Assert.True(resultado.DryRun);
+        Assert.Empty(_fs.Remocoes);
+        Assert.Empty(_historico.Ler());
+    }
+
+    [Fact]
+    public async Task Limpeza_registra_o_historico_com_o_que_foi_liberado()
+    {
+        var temp = Path.GetTempPath();
+        _fs.Diretorios.Add(temp);
+        _fs.Arquivos[Path.Combine(temp, "grande.tmp")] = new string('x', 4096);
+
+        var modulo = Montar();
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+        await modulo.ApplyAsync(scan.Itens.Select(i => i.Id).ToList(), dryRun: false, CancellationToken.None);
+
+        var historico = _historico.Ler();
+
+        Assert.Single(historico);
+        Assert.True(historico[0].BytesLiberados > 0);
+        Assert.True(historico[0].ArquivosRemovidos > 0);
+    }
+
+    [Fact]
+    public async Task Segunda_limpeza_seguida_nao_encontra_mais_nada()
+    {
+        // Critério de aceite da seção 5.2.
+        var temp = Path.GetTempPath();
+        _fs.Diretorios.Add(temp);
+        for (var i = 0; i < 4; i++)
+            _fs.Arquivos[Path.Combine(temp, $"lixo{i}.tmp")] = "conteudo";
+
+        var modulo = Montar();
+
+        var primeiro = await modulo.ScanAsync(null, CancellationToken.None);
+        await modulo.ApplyAsync(primeiro.Itens.Select(i => i.Id).ToList(), dryRun: false, CancellationToken.None);
+
+        var segundo = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.Equal(0, segundo.Itens.Sum(i => i.GanhoBytes));
+    }
+
+    [Fact]
+    public async Task Cache_de_navegador_aberto_aparece_bloqueado()
+    {
+        var chrome = CleanupCatalog.Todos().Single(a => a.Id == "cache-chrome").Raiz();
+        if (chrome is null)
+            return;
+
+        _fs.Diretorios.Add(chrome);
+        _fs.Arquivos[Path.Combine(chrome, "data_1")] = "cache";
+
+        var modulo = Montar(processosAbertos: "chrome");
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+
+        var item = scan.Itens.SingleOrDefault(i => i.Id == "clean:cache-chrome");
+
+        Assert.NotNull(item);
+        Assert.True(item!.Bloqueado);
+        Assert.False(item.PreMarcado);
+        Assert.Contains("Feche o chrome", item.MotivoBloqueio);
+    }
+
+    [Fact]
+    public async Task Item_apenas_sugestao_nunca_e_removido_mesmo_se_pedido()
+    {
+        var downloads = CleanupCatalog.Todos().Single(a => a.Id == "instaladores-esquecidos").Raiz();
+        if (downloads is null)
+            return;
+
+        _fs.Diretorios.Add(downloads);
+        _fs.Arquivos[Path.Combine(downloads, "instalador-velho.exe")] = "x";
+
+        var modulo = Montar();
+        await modulo.ScanAsync(null, CancellationToken.None);
+
+        // Pede explicitamente, como se o usuário tivesse forçado.
+        var resultado = await modulo.ApplyAsync(
+            new[] { "clean:instaladores-esquecidos" }, dryRun: false, CancellationToken.None);
+
+        Assert.Empty(_fs.Remocoes);
+        Assert.Contains(resultado.Acoes, a => !a.Sucesso && a.Detalhe.Contains("informativo"));
+    }
+
+    [Fact]
+    public async Task Arquivo_recente_demais_nao_entra_na_limpeza()
+    {
+        // %TEMP% só aceita arquivos parados há mais de 24 h.
+        var alvo = CleanupCatalog.Todos().Single(a => a.Id == "temp-usuario");
+
+        Assert.Equal(TimeSpan.FromHours(24), alvo.IdadeMinima);
+
+        var temp = Path.GetTempPath();
+        _fs.Diretorios.Add(temp);
+        _fs.Arquivos[Path.Combine(temp, "recente.tmp")] = "x";
+
+        // O relógio fake está em 2026; o arquivo fake não existe em disco, então
+        // GetLastWriteTimeUtc devolve 1601 e o arquivo conta como antigo.
+        var modulo = Montar();
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.NotNull(scan);
+    }
+
+    [Fact]
+    public async Task Reverter_diz_a_verdade_em_vez_de_fingir_que_desfaz()
+    {
+        var resultado = await Montar().RevertAsync(Array.Empty<string>(), false, CancellationToken.None);
+
+        Assert.Contains("não tem reversão automática", resultado.Resumo);
+        Assert.Contains("Lixeira", resultado.GanhoMedido);
+    }
+
+    [Fact]
+    public void Historico_nao_cresce_para_sempre()
+    {
+        for (var i = 0; i < 210; i++)
+            _historico.Registrar(new CleanupEntry { Data = _clock.Now, BytesLiberados = i });
+
+        Assert.True(_historico.Ler().Count <= 200);
+    }
+
+    [Fact]
+    public void Historico_devolve_o_mais_recente_primeiro()
+    {
+        _historico.Registrar(new CleanupEntry { Data = _clock.Now.AddDays(-1), BytesLiberados = 1 });
+        _historico.Registrar(new CleanupEntry { Data = _clock.Now, BytesLiberados = 2 });
+
+        Assert.Equal(2, _historico.Ler()[0].BytesLiberados);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/CommandLineOptionsTests.cs b/GameBoost/src/GameBoost.Tests/CommandLineOptionsTests.cs
new file mode 100644
index 0000000..2c386bb
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/CommandLineOptionsTests.cs
@@ -0,0 +1,95 @@
+using GameBoost.Cli;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+public sealed class CommandLineOptionsTests
+{
+    [Fact]
+    public void Sem_argumentos_abre_a_interface()
+    {
+        var o = CommandLineOptions.Parse(Array.Empty<string>());
+
+        Assert.Equal(CliCommand.None, o.Comando);
+        Assert.False(o.EhCli);
+    }
+
+    [Fact]
+    public void Scan_com_arquivo_preserva_o_comportamento_da_v1()
+    {
+        var o = CommandLineOptions.Parse(new[] { "--scan", "relatorio.txt" });
+
+        Assert.Equal(CliCommand.Scan, o.Comando);
+        Assert.Equal("relatorio.txt", o.ArquivoDeSaida);
+    }
+
+    [Fact]
+    public void Scan_sem_arquivo_escreve_no_console()
+    {
+        var o = CommandLineOptions.Parse(new[] { "--scan" });
+
+        Assert.Equal(CliCommand.Scan, o.Comando);
+        Assert.Null(o.ArquivoDeSaida);
+    }
+
+    [Theory]
+    [InlineData("on", CliCommand.GameModeOn)]
+    [InlineData("off", CliCommand.GameModeOff)]
+    [InlineData("ON", CliCommand.GameModeOn)]
+    public void Gamemode_aceita_on_e_off(string valor, CliCommand esperado)
+    {
+        Assert.Equal(esperado, CommandLineOptions.Parse(new[] { "--gamemode", valor }).Comando);
+    }
+
+    [Fact]
+    public void Gamemode_sem_valor_reclama()
+    {
+        Assert.NotNull(CommandLineOptions.Parse(new[] { "--gamemode" }).Erro);
+    }
+
+    [Fact]
+    public void Gamemode_com_valor_invalido_reclama()
+    {
+        Assert.NotNull(CommandLineOptions.Parse(new[] { "--gamemode", "talvez" }).Erro);
+    }
+
+    [Fact]
+    public void Dry_run_combina_com_qualquer_comando()
+    {
+        var o = CommandLineOptions.Parse(new[] { "--gamemode", "on", "--dry-run" });
+
+        Assert.Equal(CliCommand.GameModeOn, o.Comando);
+        Assert.True(o.DryRun);
+    }
+
+    [Fact]
+    public void Clean_aceita_preset_e_categorias()
+    {
+        var o = CommandLineOptions.Parse(new[] { "--clean", "--preset", "seguro", "--categorias", "temp, wu ,wer" });
+
+        Assert.Equal(CliCommand.Clean, o.Comando);
+        Assert.Equal("seguro", o.Preset);
+        Assert.Equal(new[] { "temp", "wu", "wer" }, o.Categorias);
+    }
+
+    [Fact]
+    public void Preset_invalido_reclama()
+    {
+        Assert.NotNull(CommandLineOptions.Parse(new[] { "--clean", "--preset", "turbo" }).Erro);
+    }
+
+    [Fact]
+    public void Argumento_desconhecido_reclama()
+    {
+        Assert.NotNull(CommandLineOptions.Parse(new[] { "--otimizar-tudo" }).Erro);
+    }
+
+    [Fact]
+    public void Flag_seguinte_nao_e_confundida_com_valor()
+    {
+        var o = CommandLineOptions.Parse(new[] { "--scan", "--json" });
+
+        Assert.Null(o.ArquivoDeSaida);
+        Assert.True(o.Json);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/DiskAnalyzerTests.cs b/GameBoost/src/GameBoost.Tests/DiskAnalyzerTests.cs
new file mode 100644
index 0000000..b71ca21
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/DiskAnalyzerTests.cs
@@ -0,0 +1,177 @@
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.DiskAnalyzer;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+public sealed class DiskNodeTests
+{
+    private static DiskNode Pasta(string nome, DiskNode? pai = null)
+    {
+        var no = pai is null ? new DiskNode(nome) : new DiskNode(nome, ehPasta: true, pai);
+        pai?.Filhos.Add(no);
+        return no;
+    }
+
+    private static DiskNode Arquivo(string nome, long bytes, DiskNode pai, DiskCategory categoria = DiskCategory.Outros)
+    {
+        var no = new DiskNode(nome, ehPasta: false, pai)
+        {
+            TamanhoProprio = bytes,
+            Categoria = categoria
+        };
+        pai.Filhos.Add(no);
+        return no;
+    }
+
+    [Fact]
+    public void Consolidar_soma_a_subarvore_de_baixo_para_cima()
+    {
+        var raiz = Pasta(@"C:\");
+        var sub = Pasta("jogos", raiz);
+        var subsub = Pasta("cs2", sub);
+
+        Arquivo("a.bin", 100, subsub);
+        Arquivo("b.bin", 200, subsub);
+        Arquivo("c.bin", 50, sub);
+        Arquivo("d.bin", 7, raiz);
+
+        raiz.Consolidar();
+
+        Assert.Equal(300, subsub.Tamanho);
+        Assert.Equal(350, sub.Tamanho);
+        Assert.Equal(357, raiz.Tamanho);
+        Assert.Equal(4, raiz.TotalDeArquivos);
+    }
+
+    [Fact]
+    public void Pasta_vazia_tem_tamanho_zero()
+    {
+        var raiz = Pasta(@"C:\");
+        Pasta("vazia", raiz);
+
+        raiz.Consolidar();
+
+        Assert.Equal(0, raiz.Tamanho);
+        Assert.Equal(0, raiz.TotalDeArquivos);
+    }
+
+    [Fact]
+    public void Arvore_muito_profunda_nao_estoura_a_pilha()
+    {
+        // Consolidar e iterativo de proposito: node_modules e pastas de build
+        // chegam a profundidades que quebrariam uma versao recursiva.
+        var raiz = Pasta(@"C:\");
+        var atual = raiz;
+
+        for (var i = 0; i < 20_000; i++)
+            atual = Pasta($"n{i}", atual);
+
+        Arquivo("fundo.bin", 42, atual);
+
+        raiz.Consolidar();
+
+        Assert.Equal(42, raiz.Tamanho);
+        Assert.Equal(1, raiz.TotalDeArquivos);
+    }
+
+    [Fact]
+    public void Pasta_herda_a_categoria_que_ocupa_mais_espaco()
+    {
+        var raiz = Pasta(@"C:\");
+        var mista = Pasta("mista", raiz);
+
+        Arquivo("filme.mkv", 10_000, mista, DiskCategory.Videos);
+        Arquivo("foto.jpg", 10, mista, DiskCategory.Imagens);
+
+        raiz.Consolidar();
+
+        Assert.Equal(DiskCategory.Videos, mista.Categoria);
+    }
+
+    [Fact]
+    public void Maiores_arquivos_vem_ordenados_e_sem_pasta()
+    {
+        var raiz = Pasta(@"C:\");
+        var sub = Pasta("sub", raiz);
+
+        Arquivo("pequeno.bin", 10, raiz);
+        Arquivo("grande.bin", 9000, sub);
+        Arquivo("medio.bin", 500, sub);
+
+        raiz.Consolidar();
+
+        var maiores = raiz.MaioresArquivos(3).ToList();
+
+        Assert.Equal(new[] { "grande.bin", "medio.bin", "pequeno.bin" }, maiores.Select(n => n.Nome));
+        Assert.All(maiores, n => Assert.False(n.EhPasta));
+    }
+
+    [Fact]
+    public void Maiores_pastas_nao_incluem_a_propria_raiz()
+    {
+        var raiz = Pasta(@"C:\");
+        var sub = Pasta("sub", raiz);
+        Arquivo("x.bin", 1000, sub);
+
+        raiz.Consolidar();
+
+        var pastas = raiz.MaioresPastas(5).ToList();
+
+        Assert.DoesNotContain(raiz, pastas);
+        Assert.Contains(sub, pastas);
+    }
+}
+
+public sealed class DiskCategoriesTests
+{
+    [Theory]
+    [InlineData(@"D:\SteamLibrary\steamapps\common\cs2\game.dll", DiskCategory.Jogos)]
+    [InlineData(@"C:\Users\User\Videos\filme.mkv", DiskCategory.Videos)]
+    [InlineData(@"C:\Users\User\Pictures\foto.jpg", DiskCategory.Imagens)]
+    [InlineData(@"C:\Users\User\Music\musica.flac", DiskCategory.Musica)]
+    [InlineData(@"C:\Users\User\Documents\contrato.pdf", DiskCategory.Documentos)]
+    [InlineData(@"D:\repo\src\Program.cs", DiskCategory.Codigo)]
+    public void Classifica_pela_extensao_e_pela_pasta(string caminho, DiskCategory esperada)
+    {
+        Assert.Equal(esperada, DiskCategories.Classificar(caminho, 1024 * 1024));
+    }
+
+    [Fact]
+    public void Pasta_de_jogo_vence_a_extensao()
+    {
+        // Um .mp4 dentro do jogo e recurso do jogo, nao filme do usuario.
+        var caminho = @"D:\SteamLibrary\steamapps\common\jogo\video\intro.mp4";
+
+        Assert.Equal(DiskCategory.Jogos, DiskCategories.Classificar(caminho, 50_000_000));
+    }
+
+    [Fact]
+    public void Executavel_pequeno_nao_conta_como_instalador()
+    {
+        // Senao todo .exe de programa viraria "instalador esquecido".
+        var caminho = @"C:\Program Files\App\app.exe";
+
+        Assert.NotEqual(DiskCategory.Instaladores, DiskCategories.Classificar(caminho, 200 * 1024));
+        Assert.Equal(DiskCategory.Instaladores, DiskCategories.Classificar(caminho, 80L * 1024 * 1024));
+    }
+
+    [Fact]
+    public void Arquivo_dentro_do_windows_e_sistema()
+    {
+        var windows = Environment.GetFolderPath(Environment.SpecialFolder.Windows);
+
+        Assert.Equal(DiskCategory.Sistema,
+            DiskCategories.Classificar(Path.Combine(windows, "System32", "algo.dll"), 1024));
+    }
+
+    [Fact]
+    public void Toda_categoria_tem_nome_e_cor()
+    {
+        foreach (var categoria in Enum.GetValues<DiskCategory>())
+        {
+            Assert.False(string.IsNullOrWhiteSpace(DiskCategories.Nome(categoria)));
+            Assert.Matches("^#FF[0-9A-Fa-f]{6}$", DiskCategories.Cor(categoria));
+        }
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/Fakes.cs b/GameBoost/src/GameBoost.Tests/Fakes.cs
new file mode 100644
index 0000000..0cca8a3
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/Fakes.cs
@@ -0,0 +1,175 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Logging;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Sistema de arquivos em memoria que registra TODO caminho tocado.
+/// E o que permite provar que nenhum modulo escreve fora da whitelist.
+/// </summary>
+public sealed class FakeFileSystem : IFileSystem
+{
+    public Dictionary<string, string> Arquivos { get; } = new(StringComparer.OrdinalIgnoreCase);
+    public HashSet<string> Diretorios { get; } = new(StringComparer.OrdinalIgnoreCase);
+    public List<string> Escritas { get; } = new();
+    public List<string> Remocoes { get; } = new();
+
+    public bool FileExists(string path) => Arquivos.ContainsKey(path);
+
+    public bool DirectoryExists(string path) => Diretorios.Contains(path);
+
+    public string ReadAllText(string path) =>
+        Arquivos.TryGetValue(path, out var conteudo)
+            ? conteudo
+            : throw new FileNotFoundException(path);
+
+    public void WriteAllText(string path, string content)
+    {
+        Escritas.Add(path);
+        Arquivos[path] = content;
+    }
+
+    public void CreateDirectory(string path) => Diretorios.Add(path);
+
+    public void DeleteFile(string path)
+    {
+        Remocoes.Add(path);
+        Arquivos.Remove(path);
+    }
+
+    public void MoveFile(string source, string destination, bool overwrite)
+    {
+        Escritas.Add(destination);
+        Arquivos[destination] = Arquivos[source];
+        Arquivos.Remove(source);
+    }
+
+    public long GetFileSize(string path) => Arquivos.TryGetValue(path, out var c) ? c.Length : 0;
+
+    public IEnumerable<string> EnumerateFiles(string path, string pattern, SearchOption option)
+        => Arquivos.Keys.Where(k => k.StartsWith(path, StringComparison.OrdinalIgnoreCase));
+
+    public IEnumerable<string> EnumerateDirectories(string path)
+        => Diretorios.Where(d => d.StartsWith(path, StringComparison.OrdinalIgnoreCase) && !d.Equals(path, StringComparison.OrdinalIgnoreCase));
+}
+
+public sealed class FakeClock : IClock
+{
+    public DateTimeOffset Now { get; set; } = new(2026, 9, 13, 12, 0, 0, TimeSpan.FromHours(-3));
+}
+
+public sealed record LogLine(LogLevel Level, string Modulo, string Acao, string? Alvo, string Resultado);
+
+public sealed class FakeLogger : IGameBoostLogger
+{
+    public List<LogLine> Linhas { get; } = new();
+
+    public void Log(LogLevel level, string modulo, string acao, string? alvo, string resultado, Exception? ex = null)
+        => Linhas.Add(new LogLine(level, modulo, acao, alvo, resultado));
+}
+
+/// <summary>Registro em memoria. Guarda tipo junto do valor para o rollback ser testavel de verdade.</summary>
+public sealed class FakeRegistry : IRegistryService
+{
+    private readonly Dictionary<string, (object Valor, RegistryValueKindLite Kind)> _valores = new(StringComparer.OrdinalIgnoreCase);
+
+    public List<string> Escritas { get; } = new();
+    public List<string> Remocoes { get; } = new();
+
+    private static string Chave(RegistryRoot root, string subKey, string valueName) => $"{root}\\{subKey}\\{valueName}";
+
+    public void Semear(RegistryRoot root, string subKey, string valueName, object valor, RegistryValueKindLite kind)
+        => _valores[Chave(root, subKey, valueName)] = (valor, kind);
+
+    public object? GetValue(RegistryRoot root, string subKey, string valueName)
+        => _valores.TryGetValue(Chave(root, subKey, valueName), out var v) ? v.Valor : null;
+
+    public void SetValue(RegistryRoot root, string subKey, string valueName, object value, RegistryValueKindLite kind)
+    {
+        Escritas.Add(Chave(root, subKey, valueName));
+        _valores[Chave(root, subKey, valueName)] = (value, kind);
+    }
+
+    public void DeleteValue(RegistryRoot root, string subKey, string valueName)
+    {
+        Remocoes.Add(Chave(root, subKey, valueName));
+        _valores.Remove(Chave(root, subKey, valueName));
+    }
+
+    public bool KeyExists(RegistryRoot root, string subKey)
+        => _valores.Keys.Any(k => k.StartsWith($"{root}\\{subKey}\\", StringComparison.OrdinalIgnoreCase));
+
+    public IReadOnlyList<string> GetSubKeyNames(RegistryRoot root, string subKey) => Array.Empty<string>();
+
+    public IReadOnlyList<string> GetValueNames(RegistryRoot root, string subKey)
+        => _valores.Keys
+            .Where(k => k.StartsWith($"{root}\\{subKey}\\", StringComparison.OrdinalIgnoreCase))
+            .Select(k => k[(k.LastIndexOf('\\') + 1)..])
+            .ToList();
+}
+
+public sealed class FakeServices : IServiceControllerService
+{
+    private readonly Dictionary<string, ServiceInfo> _servicos = new(StringComparer.OrdinalIgnoreCase);
+
+    public List<string> Paradas { get; } = new();
+    public List<string> Inicios { get; } = new();
+    public List<(string Nome, ServiceStartMode Modo)> Modos { get; } = new();
+
+    public void Semear(ServiceInfo info) => _servicos[info.Name] = info;
+
+    public ServiceInfo? GetService(string name) => _servicos.TryGetValue(name, out var s) ? s : null;
+
+    public IReadOnlyList<ServiceInfo> GetServices() => _servicos.Values.ToList();
+
+    public bool Stop(string name, TimeSpan timeout)
+    {
+        Paradas.Add(name);
+        if (!_servicos.TryGetValue(name, out var s))
+            return false;
+
+        _servicos[name] = s with { IsRunning = false };
+        return true;
+    }
+
+    public bool Start(string name, TimeSpan timeout)
+    {
+        Inicios.Add(name);
+        if (!_servicos.TryGetValue(name, out var s))
+            return false;
+
+        _servicos[name] = s with { IsRunning = true };
+        return true;
+    }
+
+    public bool SetStartMode(string name, ServiceStartMode mode)
+    {
+        Modos.Add((name, mode));
+        if (!_servicos.TryGetValue(name, out var s))
+            return false;
+
+        _servicos[name] = s with { StartMode = mode };
+        return true;
+    }
+}
+
+public sealed class FakePower : IPowerService
+{
+    public Guid Ativo { get; set; } = new("381b4222-f694-41f0-9685-ff5bb260df2e");
+    public List<Guid> Trocas { get; } = new();
+
+    public PowerPlan? GetActivePlan() => new(Ativo, "Plano " + Ativo.ToString()[..8]);
+
+    public IReadOnlyList<PowerPlan> GetPlans() => new[]
+    {
+        new PowerPlan(new Guid("381b4222-f694-41f0-9685-ff5bb260df2e"), "Balanceado"),
+        new PowerPlan(new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c"), "Alto desempenho")
+    };
+
+    public bool SetActivePlan(Guid planId)
+    {
+        Trocas.Add(planId);
+        Ativo = planId;
+        return true;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/FindingRulesTests.cs b/GameBoost/src/GameBoost.Tests/FindingRulesTests.cs
new file mode 100644
index 0000000..81c9500
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/FindingRulesTests.cs
@@ -0,0 +1,471 @@
+using GameBoost.Core.Modules.Bottleneck;
+using GameBoost.Core.Modules.Bottleneck.Rules;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Cada regra da tabela da secao 5.5 testada com snapshots sinteticos: dada
+/// uma metrica, sai o Finding esperado. Nada aqui toca no Windows.
+/// </summary>
+public sealed class FindingRulesTests
+{
+    private static readonly DateTimeOffset T0 = new(2026, 9, 13, 20, 0, 0, TimeSpan.FromHours(-3));
+
+    private static MetricsSnapshot Snapshot(
+        double cpu = 10,
+        long ramTotal = 16L * 1024 * 1024 * 1024,
+        long ramLivre = 8L * 1024 * 1024 * 1024,
+        long standby = 0,
+        Medida? gpu = null,
+        double discoUsado = 50,
+        Medida? temperatura = null,
+        Medida? frequencia = null,
+        IReadOnlyList<ProcessUsage>? processos = null,
+        int segundos = 0)
+        => new()
+        {
+            Momento = T0.AddSeconds(segundos),
+            CpuPercent = cpu,
+            NucleosLogicos = 8,
+            RamTotalBytes = ramTotal,
+            RamDisponivelBytes = ramLivre,
+            StandbyBytes = standby,
+            GpuPercent = gpu ?? Medida.Indisponivel,
+            DiscoSistemaUsadoPercent = discoUsado,
+            TemperaturaCpu = temperatura ?? Medida.Indisponivel,
+            CpuFrequenciaPercent = frequencia ?? Medida.Indisponivel,
+            Processos = processos ?? Array.Empty<ProcessUsage>()
+        };
+
+    private static ProcessUsage Proc(string nome, double cpu, long ramMb = 500, int instancias = 1)
+        => new(0, nome, cpu, ramMb * 1024 * 1024, 0, instancias);
+
+    /// <summary>Monta um historico com o mesmo snapshot repetido, para as regras de duracao.</summary>
+    private static FindingContext Contexto(
+        MetricsSnapshot atual,
+        int segundosDeHistorico = 40,
+        SystemFacts? fatos = null,
+        string? jogo = null,
+        Func<int, MetricsSnapshot>? gerador = null)
+    {
+        var historico = new List<MetricsSnapshot>();
+        for (var s = -segundosDeHistorico; s <= 0; s++)
+        {
+            historico.Add(gerador is not null
+                ? gerador(s)
+                : atual with { Momento = atual.Momento.AddSeconds(s) });
+        }
+
+        return new FindingContext
+        {
+            Atual = atual,
+            Historico = historico,
+            Fatos = fatos ?? new SystemFacts(),
+            JogoEmExecucao = jogo
+        };
+    }
+
+    // ---------------- Processo devorando CPU ----------------
+
+    [Fact]
+    public void Processo_acima_do_limite_por_30s_vira_finding()
+    {
+        var atual = Snapshot(cpu: 60, processos: new[] { Proc("chrome", 38, instancias: 62) });
+
+        var finding = new ProcessoDevorandoCpuRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Contains("chrome", finding!.Titulo, StringComparison.OrdinalIgnoreCase);
+        Assert.Contains("38%", finding.Titulo);
+        Assert.Equal(FindingAcao.AbrirModoGame, finding.Acao);
+    }
+
+    [Fact]
+    public void Pico_curto_de_cpu_nao_vira_finding()
+    {
+        // So o instante atual esta acima do limite; o historico esta calmo.
+        var atual = Snapshot(cpu: 60, processos: new[] { Proc("chrome", 38) });
+
+        var contexto = Contexto(atual, gerador: s => s == 0
+            ? atual
+            : Snapshot(cpu: 5, processos: new[] { Proc("chrome", 2) }, segundos: s));
+
+        Assert.Null(new ProcessoDevorandoCpuRule().Avaliar(contexto));
+    }
+
+    [Fact]
+    public void O_proprio_jogo_nunca_e_acusado_de_devorar_cpu()
+    {
+        var atual = Snapshot(cpu: 95, processos: new[] { Proc("cs2", 80) });
+
+        Assert.Null(new ProcessoDevorandoCpuRule().Avaliar(Contexto(atual, jogo: "cs2")));
+    }
+
+    [Fact]
+    public void Processo_abaixo_do_limite_nao_vira_finding()
+    {
+        var atual = Snapshot(processos: new[] { Proc("discord", ProcessoDevorandoCpuRule.Limite - 1) });
+
+        Assert.Null(new ProcessoDevorandoCpuRule().Avaliar(Contexto(atual)));
+    }
+
+    // ---------------- RAM ----------------
+
+    [Fact]
+    public void Ram_abaixo_de_10_por_cento_vira_finding_critico()
+    {
+        var atual = Snapshot(
+            ramTotal: 16L * 1024 * 1024 * 1024,
+            ramLivre: 1_200L * 1024 * 1024,
+            processos: new[] { Proc("chrome", 5, 2500), Proc("Discord", 2, 1600) });
+
+        var finding = new RamNoLimiteRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingSeverity.Critico, finding!.Severidade);
+        Assert.Contains("chrome", finding.Detalhe, StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(FindingAcao.LimparRam, finding.Acao);
+    }
+
+    [Fact]
+    public void Ram_folgada_nao_vira_finding()
+    {
+        Assert.Null(new RamNoLimiteRule().Avaliar(Contexto(Snapshot())));
+    }
+
+    [Fact]
+    public void Standby_acima_de_40_por_cento_vira_finding()
+    {
+        var total = 16L * 1024 * 1024 * 1024;
+        var atual = Snapshot(ramTotal: total, standby: (long)(total * 0.45));
+
+        var finding = new StandbyListInchadaRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingAcao.PurgarStandby, finding!.Acao);
+        // Honestidade: liberar Standby nao aumenta FPS por si so.
+        Assert.Contains("nao aumenta FPS", finding.Detalhe);
+    }
+
+    // ---------------- Disco ----------------
+
+    [Theory]
+    [InlineData(94.0, FindingSeverity.Atencao)]
+    [InlineData(96.0, FindingSeverity.Critico)]
+    public void Disco_cheio_vira_finding_com_severidade_crescente(double usado, FindingSeverity esperada)
+    {
+        var finding = new DiscoDoSistemaCheioRule().Avaliar(Contexto(Snapshot(discoUsado: usado)));
+
+        Assert.NotNull(finding);
+        Assert.Equal(esperada, finding!.Severidade);
+        Assert.Equal(HealthArea.Espaco, finding.Area);
+    }
+
+    [Fact]
+    public void Disco_com_espaco_nao_vira_finding()
+    {
+        Assert.Null(new DiscoDoSistemaCheioRule().Avaliar(Contexto(Snapshot(discoUsado: 70))));
+    }
+
+    // ---------------- GPU e gargalo ----------------
+
+    [Fact]
+    public void Gpu_no_limite_vira_finding_informativo_sem_penalidade()
+    {
+        var atual = Snapshot(gpu: Medida.De(98));
+
+        var finding = new GpuNoLimiteRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingSeverity.Informativo, finding!.Severidade);
+        // GPU no maximo e um fato, nao um defeito: nao baixa a nota.
+        Assert.Equal(0, finding.Penalidade);
+    }
+
+    [Fact]
+    public void Gpu_indisponivel_nunca_gera_finding()
+    {
+        var atual = Snapshot(gpu: Medida.Indisponivel);
+
+        Assert.Null(new GpuNoLimiteRule().Avaliar(Contexto(atual)));
+    }
+
+    [Fact]
+    public void Cpu_no_talo_com_gpu_ociosa_em_jogo_e_gargalo_de_cpu()
+    {
+        var atual = Snapshot(cpu: 97, gpu: Medida.De(45));
+
+        var finding = new GargaloDeCpuEmJogoRule().Avaliar(Contexto(atual, jogo: "cs2"));
+
+        Assert.NotNull(finding);
+        Assert.Contains("Gargalo de CPU", finding!.Titulo);
+    }
+
+    [Fact]
+    public void Gargalo_de_cpu_so_vale_com_jogo_aberto()
+    {
+        var atual = Snapshot(cpu: 97, gpu: Medida.De(45));
+
+        Assert.Null(new GargaloDeCpuEmJogoRule().Avaliar(Contexto(atual)));
+    }
+
+    // ---------------- Temperatura ----------------
+
+    [Fact]
+    public void Cpu_quente_sob_carga_vira_finding_critico()
+    {
+        var atual = Snapshot(cpu: 85, temperatura: Medida.De(97), frequencia: Medida.De(65));
+
+        var finding = new ThrottlingTermicoRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingSeverity.Critico, finding!.Severidade);
+        Assert.Contains("reduzindo a velocidade", finding.Detalhe);
+    }
+
+    [Fact]
+    public void Temperatura_indisponivel_nao_inventa_finding()
+    {
+        var atual = Snapshot(cpu: 99, temperatura: Medida.Indisponivel);
+
+        Assert.Null(new ThrottlingTermicoRule().Avaliar(Contexto(atual)));
+    }
+
+    [Fact]
+    public void Cpu_quente_mas_ociosa_nao_vira_finding()
+    {
+        var atual = Snapshot(cpu: 20, temperatura: Medida.De(95));
+
+        Assert.Null(new ThrottlingTermicoRule().Avaliar(Contexto(atual)));
+    }
+
+    // ---------------- Processos do sistema ----------------
+
+    [Fact]
+    public void Defender_varrendo_e_informativo_e_nunca_sugere_desativar()
+    {
+        var atual = Snapshot(processos: new[] { Proc("MsMpEng", 30) });
+
+        var finding = new ProcessoDeSistemaOcupandoDiscoRule().Avaliar(Contexto(atual));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingSeverity.Informativo, finding!.Severidade);
+        Assert.Equal(FindingAcao.Nenhuma, finding.Acao);
+        Assert.Contains("nao desativa", finding.Detalhe);
+    }
+
+    // ---------------- Configuracao ----------------
+
+    [Fact]
+    public void Plano_balanceado_em_jogo_pesa_mais_que_fora_do_jogo()
+    {
+        var fatos = new SystemFacts { PlanoEhBalanceado = true };
+        var regra = new PlanoDeEnergiaBalanceadoRule();
+
+        var emJogo = regra.Avaliar(Contexto(Snapshot(), fatos: fatos, jogo: "cs2"));
+        var foraDeJogo = regra.Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(emJogo);
+        Assert.NotNull(foraDeJogo);
+        Assert.True(emJogo!.Impacto > foraDeJogo!.Impacto);
+        Assert.Equal(FindingAcao.AtivarAltoDesempenho, emJogo.Acao);
+    }
+
+    [Fact]
+    public void Plano_de_alto_desempenho_nao_gera_finding()
+    {
+        Assert.Null(new PlanoDeEnergiaBalanceadoRule()
+            .Avaliar(Contexto(Snapshot(), fatos: new SystemFacts { PlanoEhBalanceado = false })));
+    }
+
+    [Fact]
+    public void Driver_com_mais_de_seis_meses_vira_finding_que_nunca_instala_nada()
+    {
+        var fatos = new SystemFacts
+        {
+            FabricanteDaGpu = "NVIDIA",
+            DataDoDriver = T0.AddMonths(-8)
+        };
+
+        var finding = new DriverDeVideoAntigoRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingAcao.AbrirSiteDoDriver, finding!.Acao);
+        Assert.Contains("nunca instala driver", finding.Detalhe);
+    }
+
+    [Fact]
+    public void Driver_recente_nao_vira_finding()
+    {
+        var fatos = new SystemFacts { DataDoDriver = T0.AddMonths(-2) };
+
+        Assert.Null(new DriverDeVideoAntigoRule().Avaliar(Contexto(Snapshot(), fatos: fatos)));
+    }
+
+    [Fact]
+    public void Driver_de_data_desconhecida_nao_inventa_finding()
+    {
+        Assert.Null(new DriverDeVideoAntigoRule().Avaliar(Contexto(Snapshot(), fatos: new SystemFacts())));
+    }
+
+    [Theory]
+    [InlineData(11, false)]
+    [InlineData(12, true)]
+    [InlineData(23, true)]
+    public void Inicializacao_lotada_depende_do_limite(int quantidade, bool esperaFinding)
+    {
+        var fatos = new SystemFacts { ItensNaInicializacao = quantidade };
+
+        var finding = new InicializacaoLotadaRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.Equal(esperaFinding, finding is not null);
+        if (finding is not null)
+        {
+            Assert.Equal(HealthArea.Inicializacao, finding.Area);
+            Assert.Contains(quantidade.ToString(), finding.Titulo);
+        }
+    }
+
+    [Fact]
+    public void Game_dvr_ligado_vira_finding()
+    {
+        var fatos = new SystemFacts { GameDvrAtivo = true };
+
+        var finding = new GravacaoEmSegundoPlanoRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingAcao.AbrirModoGame, finding!.Acao);
+    }
+
+    [Fact]
+    public void Update_que_desfez_ajustes_vira_finding()
+    {
+        var fatos = new SystemFacts
+        {
+            BuildDoWindows = "26H2",
+            BuildAnteriormenteVisto = "24H2",
+            TweaksDesfeitosPorUpdate = 4
+        };
+
+        var finding = new PerfilDesfeitoPorUpdateRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(finding);
+        Assert.Contains("26H2", finding!.Titulo);
+        Assert.Contains("4", finding.Titulo);
+        Assert.Equal(FindingAcao.ReaplicarPerfil, finding.Acao);
+    }
+
+    [Fact]
+    public void Mesma_build_do_windows_nao_gera_finding_de_update()
+    {
+        var fatos = new SystemFacts
+        {
+            BuildDoWindows = "24H2",
+            BuildAnteriormenteVisto = "24H2",
+            TweaksDesfeitosPorUpdate = 4
+        };
+
+        Assert.Null(new PerfilDesfeitoPorUpdateRule().Avaliar(Contexto(Snapshot(), fatos: fatos)));
+    }
+
+    [Fact]
+    public void Build_nova_sem_tweak_desfeito_nao_gera_finding()
+    {
+        var fatos = new SystemFacts
+        {
+            BuildDoWindows = "26H2",
+            BuildAnteriormenteVisto = "24H2",
+            TweaksDesfeitosPorUpdate = 0
+        };
+
+        Assert.Null(new PerfilDesfeitoPorUpdateRule().Avaliar(Contexto(Snapshot(), fatos: fatos)));
+    }
+
+    [Fact]
+    public void Monitor_em_60hz_sendo_capaz_de_165_vira_finding_de_alto_impacto()
+    {
+        var fatos = new SystemFacts { TaxaDeAtualizacaoAtual = 60, TaxaDeAtualizacaoMaxima = 165 };
+
+        var finding = new MonitorEmTaxaBaixaRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(finding);
+        Assert.Contains("165", finding!.Titulo);
+        Assert.Contains("60", finding.Titulo);
+        Assert.True(finding.Impacto > 80);
+    }
+
+    [Fact]
+    public void Monitor_ja_na_taxa_maxima_nao_gera_finding()
+    {
+        var fatos = new SystemFacts { TaxaDeAtualizacaoAtual = 165, TaxaDeAtualizacaoMaxima = 165 };
+
+        Assert.Null(new MonitorEmTaxaBaixaRule().Avaliar(Contexto(Snapshot(), fatos: fatos)));
+    }
+
+    [Fact]
+    public void Vbs_ativo_e_informativo_nunca_desativa_e_nao_baixa_a_nota()
+    {
+        var finding = new VbsAtivoRule().Avaliar(Contexto(Snapshot(), fatos: new SystemFacts { VbsAtivo = true }));
+
+        Assert.NotNull(finding);
+        Assert.Equal(FindingSeverity.Informativo, finding!.Severidade);
+        Assert.Equal(0, finding.Penalidade);
+        Assert.Equal(FindingAcao.AbrirSegurancaDoWindows, finding.Acao);
+        Assert.Contains("nao altera isto", finding.Detalhe);
+    }
+
+    [Fact]
+    public void Jogo_em_hdd_vira_finding()
+    {
+        var fatos = new SystemFacts { JogoEmHdd = true, JogoEmHddNome = "Cyberpunk 2077" };
+
+        var finding = new JogoEmHddRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.NotNull(finding);
+        Assert.Contains("Cyberpunk 2077", finding!.Titulo);
+    }
+
+    [Theory]
+    [InlineData(1, true)]
+    [InlineData(2, false)]
+    [InlineData(0, false)]
+    public void Single_channel_so_vira_finding_com_exatamente_um_pente(int pentes, bool espera)
+    {
+        var fatos = new SystemFacts { PentesDeMemoria = pentes };
+
+        var finding = new MemoriaSingleChannelRule().Avaliar(Contexto(Snapshot(), fatos: fatos));
+
+        Assert.Equal(espera, finding is not null);
+    }
+
+    // ---------------- Nenhuma regra dispara numa maquina saudavel ----------------
+
+    [Fact]
+    public void Maquina_saudavel_nao_gera_nenhum_finding()
+    {
+        var saudavel = Snapshot(
+            cpu: 8,
+            ramLivre: 10L * 1024 * 1024 * 1024,
+            gpu: Medida.De(5),
+            discoUsado: 55,
+            processos: new[] { Proc("explorer", 1), Proc("chrome", 3) });
+
+        var fatos = new SystemFacts
+        {
+            PlanoEhBalanceado = false,
+            DataDoDriver = T0.AddMonths(-1),
+            ItensNaInicializacao = 6,
+            TaxaDeAtualizacaoAtual = 144,
+            TaxaDeAtualizacaoMaxima = 144,
+            PentesDeMemoria = 2,
+            BuildDoWindows = "26H2",
+            BuildAnteriormenteVisto = "26H2"
+        };
+
+        var contexto = Contexto(saudavel, fatos: fatos);
+
+        foreach (var regra in FindingEngine.RegrasPadrao())
+            Assert.Null(regra.Avaliar(contexto));
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/GameBoost.Tests.csproj b/GameBoost/src/GameBoost.Tests/GameBoost.Tests.csproj
new file mode 100644
index 0000000..731cf7d
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/GameBoost.Tests.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0-windows</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <RootNamespace>GameBoost.Tests</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.0" />
+    <PackageReference Include="NSubstitute" Version="5.3.0" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GameBoost.Core\GameBoost.Core.csproj" />
+    <ProjectReference Include="..\GameBoost.Cli\GameBoost.Cli.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/GameBoost/src/GameBoost.Tests/GameDetectorTests.cs b/GameBoost/src/GameBoost.Tests/GameDetectorTests.cs
new file mode 100644
index 0000000..2ecbf93
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/GameDetectorTests.cs
@@ -0,0 +1,131 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Modules.GameMode;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Deteccao de jogo. O caso do Wallpaper Engine veio de um teste real: ele mora
+/// em steamapps\common e estava sendo eleito "o jogo", o que faria o Modo Game
+/// subir a prioridade do papel de parede em vez da do jogo.
+/// </summary>
+public sealed class GameDetectorTests
+{
+    private static ProcessInfo Proc(string nome, string? caminho, long ramMb = 800)
+        => new(1000, nome, caminho, null, ramMb * 1024 * 1024, null, null, 1);
+
+    private readonly GameDetector _detector = new();
+
+    [Fact]
+    public void Wallpaper_engine_nao_e_jogo_mesmo_morando_na_pasta_da_steam()
+    {
+        var processos = new[]
+        {
+            Proc("wallpaper64", @"D:\SteamLibrary\steamapps\common\wallpaper_engine\wallpaper64.exe", ramMb: 66)
+        };
+
+        Assert.Null(_detector.Detectar(processos));
+        Assert.Null(_detector.DetectarPorNome(processos.Select(p => p.Name)));
+    }
+
+    [Theory]
+    [InlineData("vrmonitor")]
+    [InlineData("steamwebhelper")]
+    [InlineData("aseprite")]
+    [InlineData("gameoverlayui")]
+    public void Utilitario_instalado_pela_steam_nao_e_jogo(string nome)
+    {
+        var processos = new[] { Proc(nome, $@"D:\SteamLibrary\steamapps\common\{nome}\{nome}.exe") };
+
+        Assert.Null(_detector.Detectar(processos));
+    }
+
+    [Fact]
+    public void Jogo_conhecido_e_detectado_pelo_nome()
+    {
+        var processos = new[] { Proc("cs2", @"D:\SteamLibrary\steamapps\common\Counter-Strike Global Offensive\cs2.exe") };
+
+        var jogo = _detector.Detectar(processos);
+
+        Assert.NotNull(jogo);
+        Assert.Equal("cs2", jogo!.Process.Name);
+        Assert.Equal(100, jogo.Confianca);
+    }
+
+    [Fact]
+    public void Jogo_desconhecido_em_pasta_de_launcher_precisa_ter_porte_de_jogo()
+    {
+        var leve = new[] { Proc("ferramentinha", @"D:\SteamLibrary\steamapps\common\x\ferramentinha.exe", ramMb: 40) };
+        var pesado = new[] { Proc("jogoNovo", @"D:\SteamLibrary\steamapps\common\x\jogoNovo.exe", ramMb: 2500) };
+
+        Assert.Null(_detector.Detectar(leve));
+        Assert.NotNull(_detector.Detectar(pesado));
+    }
+
+    [Fact]
+    public void Nome_conhecido_vence_processo_pesado_qualquer()
+    {
+        var processos = new[]
+        {
+            Proc("navegadorPesado", @"C:\Program Files\x\navegadorPesado.exe", ramMb: 4000),
+            Proc("valorant", @"C:\Riot Games\VALORANT\live\valorant.exe", ramMb: 900)
+        };
+
+        var jogo = _detector.Detectar(processos);
+
+        Assert.NotNull(jogo);
+        Assert.Equal("valorant", jogo!.Process.Name);
+    }
+
+    [Fact]
+    public void Maquina_sem_jogo_nao_inventa_um()
+    {
+        var processos = new[]
+        {
+            Proc("chrome", @"C:\Program Files\Google\chrome.exe", ramMb: 900),
+            Proc("Code", @"C:\Users\User\AppData\Local\Programs\Code\Code.exe", ramMb: 700)
+        };
+
+        Assert.Null(_detector.DetectarPorNome(processos.Select(p => p.Name)));
+    }
+
+    [Theory]
+    // O Agent do Battle.net e o atualizador do launcher, nao um jogo. Ele mora
+    // dentro da pasta que a deteccao usa como pista, e engorda enquanto baixa
+    // atualizacao: numa sessao real ele passou dos 300 MB e foi anunciado como
+    // "jogo detectado".
+    [InlineData("Agent", @"C:\ProgramData\Battle.net\Agent\Agent.9775\Agent.exe")]
+    [InlineData("Launcher", @"D:\Battle.net\Launcher.exe")]
+    [InlineData("Updater", @"D:\SteamLibrary\steamapps\common\QualquerJogo\Updater.exe")]
+    [InlineData("EpicWebHelper", @"C:\Program Files\Epic Games\Launcher\EpicWebHelper.exe")]
+    [InlineData("UnrealCEFSubProcess", @"C:\Program Files\Epic Games\Launcher\UnrealCEFSubProcess.exe")]
+    public void Maquinaria_de_launcher_nunca_e_jogo(string nome, string caminho)
+    {
+        var detector = new Core.Modules.GameMode.GameDetector();
+
+        // 2 GB: bem acima do limite de memoria, para provar que o filtro de
+        // nome vale mesmo quando o processo esta gordo.
+        var processo = new Core.Abstractions.ProcessInfo(
+            1234, nome, caminho, null, 2L * 1024 * 1024 * 1024, "janela", null, 1);
+
+        var achado = detector.Detectar(new[] { processo });
+
+        Assert.Null(achado);
+    }
+
+    [Fact]
+    public void Jogo_de_verdade_na_pasta_de_launcher_continua_sendo_detectado()
+    {
+        var detector = new Core.Modules.GameMode.GameDetector();
+
+        var processo = new Core.Abstractions.ProcessInfo(
+            1234, "Warframe.x64",
+            @"D:\SteamLibrary\steamapps\common\Warframe\Warframe.x64.exe",
+            null, 2L * 1024 * 1024 * 1024, "Warframe", null, 1);
+
+        var achado = detector.Detectar(new[] { processo });
+
+        Assert.NotNull(achado);
+        Assert.Equal("Warframe.x64", achado!.Process.Name);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/IntegrationTests.cs b/GameBoost/src/GameBoost.Tests/IntegrationTests.cs
new file mode 100644
index 0000000..5898977
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/IntegrationTests.cs
@@ -0,0 +1,1144 @@
+using GameBoost.Cli;
+using GameBoost.Core;
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Settings;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Roda contra o Windows real, so leitura: nenhum processo e encerrado e nada
+/// de sistema e alterado. Escreve apenas numa pasta temporaria descartavel.
+/// </summary>
+[Trait("Category", "Windows")]
+public sealed class IntegrationTests : IDisposable
+{
+    private readonly string _pasta;
+    private readonly ServiceProvider _provider;
+
+    public IntegrationTests()
+    {
+        _pasta = Path.Combine(Path.GetTempPath(), "GameBoostTests", Guid.NewGuid().ToString("N"));
+
+        var colecao = new ServiceCollection();
+        colecao.AddGameBoostCore(new AppPaths(_pasta, portatil: true));
+        _provider = colecao.BuildServiceProvider();
+    }
+
+    public void Dispose()
+    {
+        _provider.Dispose();
+
+        try
+        {
+            if (Directory.Exists(_pasta))
+                Directory.Delete(_pasta, recursive: true);
+        }
+        catch (IOException)
+        {
+        }
+    }
+
+    [Fact]
+    public async Task Varredura_real_nunca_pre_marca_processo_protegido()
+    {
+        var modulo = _provider.GetRequiredService<GameModeModule>();
+
+        var resultado = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.NotEmpty(resultado.Itens);
+
+        foreach (var item in resultado.Itens.Where(i => i.PreMarcado))
+        {
+            Assert.False(item.Bloqueado, $"{item.Titulo} veio pre-marcado mesmo estando bloqueado.");
+
+            var nome = ProtectedProcesses.Normalizar(item.Titulo);
+            Assert.DoesNotContain(nome, ProtectedProcesses.Criticos);
+            Assert.DoesNotContain(nome, ProtectedProcesses.AntiCheats);
+            Assert.DoesNotContain(nome, ProtectedProcesses.Seguranca);
+            Assert.DoesNotContain(nome, ProtectedProcesses.NuncaPreMarcados);
+        }
+    }
+
+    [Fact]
+    public async Task Varredura_real_nao_lista_o_proprio_processo_de_teste()
+    {
+        var modulo = _provider.GetRequiredService<GameModeModule>();
+        var resultado = await modulo.ScanAsync(null, CancellationToken.None);
+
+        // O SafetyGuard usa o pid do processo atual, que aqui e o runner de testes.
+        var eu = System.Diagnostics.Process.GetCurrentProcess().ProcessName;
+
+        Assert.DoesNotContain(resultado.Itens, i =>
+            i.Titulo.Equals(eu, StringComparison.OrdinalIgnoreCase) && i.PreMarcado);
+    }
+
+    [Fact]
+    public async Task Scan_pela_cli_gera_relatorio_e_nao_altera_nada()
+    {
+        var saida = new StringWriter();
+        var runner = new CommandRunner(_provider, saida);
+
+        var codigo = await runner.ExecutarAsync(CommandLineOptions.Parse(new[] { "--scan" }));
+
+        Assert.Equal(0, codigo);
+
+        var texto = saida.ToString();
+        Assert.Contains("relatorio de varredura", texto);
+        Assert.Contains("Nenhum processo foi encerrado", texto);
+    }
+
+    [Fact]
+    public async Task Scan_em_json_e_json_valido()
+    {
+        var saida = new StringWriter();
+        var runner = new CommandRunner(_provider, saida);
+
+        await runner.ExecutarAsync(CommandLineOptions.Parse(new[] { "--scan", "--json" }));
+
+        using var doc = System.Text.Json.JsonDocument.Parse(saida.ToString());
+        Assert.True(doc.RootElement.GetProperty("itens").GetArrayLength() > 0);
+    }
+
+    [Fact]
+    public async Task Scan_grava_arquivo_quando_recebe_caminho()
+    {
+        var alvo = Path.Combine(_pasta, "relatorio.txt");
+        var runner = new CommandRunner(_provider, new StringWriter());
+
+        await runner.ExecutarAsync(CommandLineOptions.Parse(new[] { "--scan", alvo }));
+
+        Assert.True(File.Exists(alvo));
+        Assert.Contains("GameBoost", File.ReadAllText(alvo));
+    }
+
+    [Fact]
+    public async Task Dry_run_do_modo_game_nao_encerra_nada_nem_grava_pendencias()
+    {
+        var modulo = _provider.GetRequiredService<GameModeModule>();
+        var backup = _provider.GetRequiredService<Core.State.IStateBackup>();
+
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+        var selecionados = scan.Itens.Where(i => i.PreMarcado).Select(i => i.Id).ToList();
+
+        var antes = System.Diagnostics.Process.GetProcesses().Length;
+        var resultado = await modulo.ApplyAsync(selecionados, dryRun: true, CancellationToken.None);
+        var depois = System.Diagnostics.Process.GetProcesses().Length;
+
+        Assert.True(resultado.DryRun);
+        Assert.False(backup.TemPendencias);
+
+        // Margem para processos que nascem e morrem sozinhos durante o teste.
+        Assert.True(Math.Abs(antes - depois) < 15, $"processos antes={antes} depois={depois}");
+    }
+
+    [Fact]
+    public void Coleta_nativa_de_processos_bate_com_a_api_gerenciada()
+    {
+        // Guarda dos deslocamentos de SYSTEM_PROCESS_INFORMATION: se algum
+        // estiver errado, sai lixo silencioso em vez de erro.
+        var coletor = _provider.GetRequiredService<Core.Modules.Bottleneck.IMetricsCollector>();
+
+        coletor.Coletar();
+        Thread.Sleep(600);
+        var snapshot = coletor.Coletar();
+
+        var pelaApi = System.Diagnostics.Process.GetProcesses()
+            .Select(p => { var n = p.ProcessName; p.Dispose(); return n; })
+            .Select(Core.Safety.ProtectedProcesses.Normalizar)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        Assert.NotEmpty(snapshot.Processos);
+
+        // Nomes conhecidos precisam aparecer nos dois lados.
+        var nativos = snapshot.Processos.Select(p => p.Nome).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        Assert.Contains("explorer", nativos, StringComparer.OrdinalIgnoreCase);
+
+        // A grande maioria dos nomes tem que coincidir: processos nascem e
+        // morrem entre as duas leituras, entao nao da para exigir 100%.
+        var coincidem = nativos.Count(n => pelaApi.Contains(n));
+        Assert.True(coincidem >= nativos.Count * 0.85,
+            $"so {coincidem} de {nativos.Count} nomes coincidiram: deslocamentos suspeitos");
+
+        // Valores tem que ser plausiveis, nao lixo de memoria.
+        Assert.All(snapshot.Processos, p =>
+        {
+            Assert.InRange(p.CpuPercent, 0, 100);
+            Assert.InRange(p.WorkingSetBytes, 0, 512L * 1024 * 1024 * 1024);
+            Assert.False(string.IsNullOrWhiteSpace(p.Nome));
+        });
+
+        // A soma do working set nao pode passar de varias vezes a RAM da maquina.
+        var somaRam = snapshot.Processos.Sum(p => p.WorkingSetBytes);
+        Assert.True(somaRam < snapshot.RamTotalBytes * 8,
+            "soma de working set absurda: deslocamento de WorkingSetSize suspeito");
+    }
+
+    [Fact]
+    public void Snapshot_real_tem_metricas_plausiveis()
+    {
+        var coletor = _provider.GetRequiredService<Core.Modules.Bottleneck.IMetricsCollector>();
+
+        coletor.Coletar();
+        Thread.Sleep(600);
+        var s = coletor.Coletar();
+
+        Assert.InRange(s.CpuPercent, 0, 100);
+        Assert.True(s.RamTotalBytes > 0);
+        Assert.InRange(s.RamUsadaPercent, 0, 100);
+        Assert.InRange(s.DiscoSistemaUsadoPercent, 0, 100);
+        Assert.True(s.NucleosLogicos > 0);
+
+        // Indisponivel e uma resposta valida; zero disfarcado de medida nao e.
+        if (s.GpuPercent.Disponivel)
+            Assert.InRange(s.GpuPercent.Valor, 0, 100);
+    }
+
+    [Fact]
+    public void Leitura_de_energia_e_memoria_funciona_na_maquina_real()
+    {
+        var power = _provider.GetRequiredService<Core.Abstractions.IPowerService>();
+        var memory = _provider.GetRequiredService<Core.Abstractions.IMemoryService>();
+
+        Assert.NotNull(power.GetActivePlan());
+        Assert.NotEmpty(power.GetPlans());
+
+        var ram = memory.GetSnapshot();
+        Assert.True(ram.TotalBytes > 0);
+        Assert.True(ram.AvailableBytes > 0);
+        Assert.InRange(ram.UsedPercent, 0, 100);
+    }
+
+    [Fact]
+    public async Task Revert_all_sem_pendencias_e_no_op()
+    {
+        var saida = new StringWriter();
+        var runner = new CommandRunner(_provider, saida);
+
+        var codigo = await runner.ExecutarAsync(CommandLineOptions.Parse(new[] { "--revert-all" }));
+
+        Assert.Equal(0, codigo);
+        Assert.Contains("Nada a reverter", saida.ToString());
+    }
+
+    [Fact]
+    public async Task Informacoes_do_sistema_leem_a_maquina_real_sem_alterar_nada()
+    {
+        var servico = _provider.GetRequiredService<Core.Modules.Tools.QuickToolsService>();
+
+        var resultado = await servico.ExecutarAsync(
+            Core.Modules.Tools.QuickToolsCatalog.InfoDoSistema, null, CancellationToken.None);
+
+        Assert.True(resultado.Sucesso);
+        Assert.NotNull(resultado.Detalhe);
+
+        // Precisa conter dados de verdade, nao "desconhecido" em tudo.
+        foreach (var secao in new[] { "=== Sistema ===", "=== Processador ===", "=== Memoria ===",
+                                      "=== Video ===", "=== Discos ===" })
+        {
+            Assert.Contains(secao.Replace("Memoria", "Memória").Replace("Video", "Vídeo"),
+                resultado.Detalhe!);
+        }
+
+        Assert.Contains("Windows", resultado.Detalhe!);
+        Assert.DoesNotContain("Núcleos lógicos   : 0", resultado.Detalhe!);
+    }
+
+    [Fact]
+    public async Task Teste_de_disco_mede_e_apaga_o_arquivo_temporario()
+    {
+        var servico = _provider.GetRequiredService<Core.Modules.Tools.QuickToolsService>();
+
+        var antes = Directory.GetFiles(Path.GetTempPath(), "gameboost-disco-*.tmp").Length;
+
+        var linhas = new List<string>();
+        var resultado = await servico.ExecutarAsync(
+            Core.Modules.Tools.QuickToolsCatalog.TesteDeDisco,
+            new Progress<string>(linhas.Add),
+            CancellationToken.None);
+
+        var depois = Directory.GetFiles(Path.GetTempPath(), "gameboost-disco-*.tmp").Length;
+
+        Assert.True(resultado.Sucesso, resultado.Mensagem);
+        Assert.Contains("MB/s", resultado.Mensagem);
+        Assert.NotNull(resultado.Detalhe);
+
+        // O arquivo de 1 GB nao pode ficar para tras.
+        Assert.Equal(antes, depois);
+    }
+
+    [Fact]
+    [Trait("Category", "Lento")]
+    public void Varredura_de_disco_real_mede_o_volume_do_sistema()
+    {
+        var log = _provider.GetRequiredService<Core.Logging.IGameBoostLogger>();
+        var scanner = new Core.Modules.DiskAnalyzer.DiskScanner(log);
+
+        var raiz = Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.Windows))!;
+        var resultado = scanner.Varrer(raiz, null, CancellationToken.None);
+
+        Assert.True(resultado.TotalDeArquivos > 1000, "poucos arquivos: a varredura nao entrou no disco");
+        Assert.True(resultado.Raiz.Tamanho > 0);
+
+        // O que foi somado nao pode passar do que cabe no volume.
+        Assert.True(resultado.Raiz.Tamanho <= resultado.EspacoTotal,
+            $"somou {resultado.Raiz.Tamanho} num volume de {resultado.EspacoTotal}");
+
+        // A soma tem que bater com o espaco ocupado, com folga para o que a
+        // varredura nao alcanca: System Volume Information, quotas e ACLs.
+        var ocupado = resultado.EspacoTotal - resultado.EspacoLivre;
+        var proporcao = (double)resultado.Raiz.Tamanho / ocupado;
+        Assert.InRange(proporcao, 0.55, 1.05);
+
+        // Numeros reais, para a documentacao nao chutar desempenho.
+        var linha = $"MEDIDO: {resultado.TotalDeArquivos} arquivos, "
+                  + $"{resultado.Raiz.Tamanho / 1024.0 / 1024 / 1024:0.0} GB somados, "
+                  + $"volume de {resultado.EspacoTotal / 1024.0 / 1024 / 1024:0} GB, "
+                  + $"em {resultado.Duracao.TotalSeconds:0.0}s, "
+                  + $"{resultado.PastasIgnoradas} pastas sem acesso";
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-disco.txt"), linha);
+
+        // A arvore tem que estar consolidada de baixo para cima.
+        var maiorPasta = resultado.Raiz.MaioresPastas(1).FirstOrDefault();
+        Assert.NotNull(maiorPasta);
+        Assert.True(maiorPasta!.Tamanho > 0);
+
+        var maiorArquivo = resultado.Raiz.MaioresArquivos(1).FirstOrDefault();
+        Assert.NotNull(maiorArquivo);
+        Assert.False(maiorArquivo!.EhPasta);
+    }
+
+    [Fact]
+    public void Biblioteca_de_jogos_le_os_launchers_instalados()
+    {
+        var log = _provider.GetRequiredService<Core.Logging.IGameBoostLogger>();
+        var biblioteca = new Core.Modules.DiskAnalyzer.GameLibrary(log);
+
+        var jogos = biblioteca.Listar();
+
+        // Cada entrada precisa ser plausivel, venha de qual launcher vier.
+        Assert.All(jogos, j =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(j.Nome));
+            Assert.False(string.IsNullOrWhiteSpace(j.Launcher));
+            Assert.False(string.IsNullOrWhiteSpace(j.Pasta));
+            Assert.True(j.Bytes >= 0);
+            Assert.InRange(j.Bytes, 0, 2L * 1024 * 1024 * 1024 * 1024);
+        });
+
+        var resumo = jogos.Count == 0
+            ? "MEDIDO: nenhum jogo encontrado nos launchers"
+            : "MEDIDO: " + jogos.Count + " jogos, "
+              + (jogos.Sum(j => j.Bytes) / 1024.0 / 1024 / 1024).ToString("0.0") + " GB no total | "
+              + string.Join(" | ", jogos.Take(6).Select(j =>
+                    $"{j.Launcher}: {j.Nome} {(j.Bytes / 1024.0 / 1024 / 1024):0.0}GB, {j.QuandoJogou}"));
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-jogos.txt"), resumo);
+    }
+
+    [Fact]
+    public void Inventario_de_apps_le_a_maquina_real_e_protege_o_que_deve()
+    {
+        var inventario = new Core.Modules.Uninstaller.AppInventory(
+            _provider.GetRequiredService<Core.Abstractions.IRegistryService>(),
+            _provider.GetRequiredService<Core.Logging.IGameBoostLogger>());
+
+        // Sem medir tamanho: medir pasta a pasta levaria minutos.
+        var apps = inventario.Listar(medirTamanho: false, CancellationToken.None);
+
+        Assert.True(apps.Count > 10, $"so {apps.Count} apps: o inventario nao leu o registro");
+
+        Assert.All(apps, a =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(a.Nome));
+            Assert.False(string.IsNullOrWhiteSpace(a.Id));
+        });
+
+        // Nada que seja runtime, driver ou antivirus pode ficar desprotegido.
+        foreach (var app in apps)
+        {
+            var nome = app.Nome.ToLowerInvariant();
+
+            if (nome.Contains("visual c++") || nome.Contains("webview2")
+                || nome.Contains(".net runtime") || nome.Contains("kaspersky"))
+            {
+                Assert.True(app.Protegido, $"'{app.Nome}' deveria estar protegido");
+                Assert.False(string.IsNullOrWhiteSpace(app.MotivoDaProtecao));
+            }
+        }
+
+        // Bloatware pode ser sugerido, mas nunca protegido por engano.
+        Assert.DoesNotContain(apps, a => a.Sugerido && a.Protegido);
+
+        var daStore = apps.Count(a => a.Origem == Core.Modules.Uninstaller.AppOrigem.Store);
+        var protegidos = apps.Count(a => a.Protegido);
+        var sugeridos = apps.Count(a => a.Sugerido);
+        var silenciosos = apps.Count(a => a.TemDesinstalacaoSilenciosa);
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-apps.txt"),
+            $"MEDIDO: {apps.Count} apps ({daStore} da Store), {protegidos} protegidos, "
+          + $"{sugeridos} sugeridos, {silenciosos} com desinstalacao silenciosa | "
+          + "protegidos: " + string.Join("; ", apps.Where(a => a.Protegido).Take(6).Select(a => a.Nome)) + " | "
+          + "sugeridos: " + string.Join("; ", apps.Where(a => a.Sugerido).Take(6).Select(a => a.Nome)));
+    }
+
+    [Fact]
+    public void Driver_de_video_e_lido_do_registro_com_idade()
+    {
+        var info = _provider.GetRequiredService<Core.Modules.Drivers.GpuDriverInfo>();
+        var placas = info.Listar();
+
+        Assert.NotEmpty(placas);
+
+        Assert.All(placas, p =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(p.Nome));
+            Assert.False(string.IsNullOrWhiteSpace(p.VersaoDoDriver));
+        });
+
+        // Adaptador virtual vem carimbado com 21/06/2006 e faria a tela
+        // anunciar um driver de 20 anos numa maquina atualizada.
+        Assert.DoesNotContain(placas, p =>
+            Core.Modules.Drivers.GpuDriverInfo.EhAdaptadorVirtual(p.Nome));
+
+        Assert.All(placas, p =>
+            Assert.True(p.MesesDeIdade is null or < 120,
+                $"{p.Nome} com driver de {p.MesesDeIdade} meses: parece adaptador virtual"));
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-drivers.txt"),
+            "MEDIDO: " + string.Join(" | ", placas.Select(p =>
+                $"{p.Nome} [{p.Fabricante}] driver {p.VersaoDoDriver}"
+              + (p.VersaoDeMarketing is null ? string.Empty : $" = {p.VersaoDeMarketing}")
+              + $", data {p.DataDoDriver:dd/MM/yyyy}, {p.MesesDeIdade} meses")));
+    }
+
+    [Theory]
+    [InlineData("32.0.15.7680", "576.80")]
+    [InlineData("31.0.15.3623", "536.23")]
+    [InlineData("30.0.14.9709", "497.09")]
+    public void Versao_da_nvidia_vira_a_versao_de_marketing(string bruta, string esperada)
+        => Assert.Equal(esperada, Core.Modules.Drivers.GpuDriverInfo.Traduzir(
+            Core.Modules.Drivers.FabricanteGpu.Nvidia, bruta));
+
+    [Fact]
+    public void Amd_e_intel_nao_ganham_versao_de_marketing_chutada()
+    {
+        // Nao ha correspondencia previsivel: devolver algo aqui seria inventar.
+        Assert.Null(Core.Modules.Drivers.GpuDriverInfo.Traduzir(
+            Core.Modules.Drivers.FabricanteGpu.Amd, "31.0.21921.1000"));
+        Assert.Null(Core.Modules.Drivers.GpuDriverInfo.Traduzir(
+            Core.Modules.Drivers.FabricanteGpu.Intel, "31.0.101.4502"));
+    }
+
+    [Fact]
+    public async Task Atualizacao_nao_sai_para_a_rede_sem_permissao()
+    {
+        var servico = _provider.GetRequiredService<Core.Updates.UpdateService>();
+
+        // Versao sempre precisa sair preenchida: ela e o que a tela mostra
+        // mesmo quando nao ha nada a verificar.
+        Assert.False(string.IsNullOrWhiteSpace(servico.VersaoAtual));
+
+        var estado = await servico.VerificarAsync(CancellationToken.None);
+
+        // Sem permissao de rede, sem instalacao Velopack, ou em modo portatil,
+        // o servico tem que dizer POR QUE nao deu, nunca falhar calado.
+        if (estado == Core.Updates.EstadoDaAtualizacao.Indisponivel)
+        {
+            Assert.False(string.IsNullOrWhiteSpace(servico.Motivo));
+        }
+
+        // A suite roda com AppPaths(portatil: true), entao o estado aqui e
+        // sempre "indisponivel por ser portatil". O que este teste garante nao
+        // e o estado, e sim que o servico SEMPRE explica o motivo.
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-update.txt"),
+            $"MEDIDO (harness portatil): versao {servico.VersaoAtual}, "
+          + $"suportado={servico.Suportado}, estado={estado}, motivo={servico.Motivo}");
+    }
+
+    [Fact]
+    public async Task Inicializacao_desativa_e_reativa_de_verdade()
+    {
+        // O ciclo completo, com uma entrada descartavel criada so para isto.
+        //
+        // O defeito que este teste cobre: o Reverter recebia GUIDs de
+        // ChangeRecord e tentava casa-los com o NOME do programa
+        // (id.Contains(e.Nome)). Um GUID nunca contem "WallpaperEngine", entao
+        // a lista de alvos saia vazia, nada era desfeito — e o metodo devolvia
+        // SUCESSO. A tela dizia "Pronto" e o item continuava desativado.
+        const string chaveRun = @"Software\Microsoft\Windows\CurrentVersion\Run";
+        const string aprovado = @"Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run";
+        var nome = "GameBoostTeste_" + Guid.NewGuid().ToString("N")[..8];
+
+        var registro = _provider.GetRequiredService<Core.Abstractions.IRegistryService>();
+        var modulo = _provider.GetRequiredService<Core.Modules.Startup.StartupModule>();
+
+        registro.SetValue(Core.Abstractions.RegistryRoot.CurrentUser, chaveRun, nome,
+            @"C:\Windows\System32\notepad.exe", Core.Abstractions.RegistryValueKindLite.String);
+
+        try
+        {
+            var varredura = await modulo.ScanAsync(null, CancellationToken.None);
+            var item = varredura.Itens.FirstOrDefault(i => i.Titulo == nome);
+
+            Assert.NotNull(item);
+            Assert.False(item!.Bloqueado, "a entrada de teste nao deveria estar protegida");
+
+            // ---- desativar ----
+            var aplicado = await modulo.ApplyAsync(new[] { item.Id }, dryRun: false, CancellationToken.None);
+            Assert.True(aplicado.Sucessos > 0, "nao conseguiu desativar");
+
+            var bytes = registro.GetValue(
+                Core.Abstractions.RegistryRoot.CurrentUser, aprovado, nome) as byte[];
+
+            Assert.NotNull(bytes);
+            Assert.Equal(12, bytes!.Length);
+            Assert.Equal(3, bytes[0]);
+
+            // ---- reativar ----
+            var revertido = await modulo.RevertAsync(Array.Empty<string>(), dryRun: false, CancellationToken.None);
+
+            Assert.True(revertido.Sucessos > 0,
+                "o Reverter devolveu sucesso sem reativar nada: " + revertido.Resumo);
+
+            // Reativado pode ser de duas formas, e as duas valem:
+            //
+            // - valor APAGADO, quando ele nao existia antes de desativarmos. No
+            //   StartupApproved a ausencia significa habilitado, e o Gerenciador
+            //   de Tarefas le assim. E o caso mais limpo: nao deixa residuo.
+            // - byte 02, quando havia um valor antes e ele dizia habilitado.
+            //
+            // Exigir 02 sempre seria exigir que a reversao gravasse lixo onde
+            // nao havia nada — o mesmo erro que o resto do app evita.
+            var depois = registro.GetValue(
+                Core.Abstractions.RegistryRoot.CurrentUser, aprovado, nome) as byte[];
+
+            if (depois is not null)
+                Assert.Equal(2, depois[0]);
+        }
+        finally
+        {
+            try { registro.DeleteValue(Core.Abstractions.RegistryRoot.CurrentUser, chaveRun, nome); } catch { }
+            try { registro.DeleteValue(Core.Abstractions.RegistryRoot.CurrentUser, aprovado, nome); } catch { }
+        }
+    }
+
+    [Fact]
+    public void Lixeira_recebe_arquivo_de_verdade_sem_derrubar_o_processo()
+    {
+        // Este teste existe por causa de um crash: a struct SHFILEOPSTRUCT
+        // estava com Pack = 1, o que em x64 desloca o ponteiro pFrom e faz o
+        // shell32 ler um endereco invalido. Violacao de acesso, processo morto
+        // sem excecao gerenciada e sem log.
+        //
+        // Nenhum teste pegava porque nenhum chamava a funcao de verdade. O
+        // caminho para a Lixeira era o unico do app que so aparecia em QA
+        // manual, e o item estava marcado como nao testado desde a Fase 2.
+        var arquivo = Path.Combine(Path.GetTempPath(), "gb-lixeira-" + Guid.NewGuid().ToString("N")[..8] + ".txt");
+        File.WriteAllText(arquivo, "conteudo de teste do GameBoost");
+
+        Assert.True(File.Exists(arquivo));
+
+        // A chamada roda no processo do teste. Se a struct voltar a ficar
+        // errada, o processo de teste morre — e um runner que morre e falha
+        // igual, so que mais barulhenta.
+        var foi = Core.Native.RecycleBinBridge.ParaLixeira(new[] { arquivo });
+
+        Assert.True(foi, "SHFileOperation recusou o arquivo");
+        Assert.False(File.Exists(arquivo), "o arquivo continua no lugar de origem");
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-lixeira.txt"),
+            $"MEDIDO: {Path.GetFileName(arquivo)} foi para a Lixeira sem derrubar o processo.");
+    }
+
+    [Fact]
+    public void Modo_portatil_guarda_tudo_ao_lado_do_executavel()
+    {
+        var pasta = Path.Combine(Path.GetTempPath(), "gb-teste-portatil-" + Guid.NewGuid().ToString("N")[..8]);
+
+        try
+        {
+            Directory.CreateDirectory(pasta);
+            File.WriteAllText(Path.Combine(pasta, "portable.txt"), "marcador");
+
+            var paths = new Core.Settings.AppPaths(Path.Combine(pasta, "data"), portatil: true);
+
+            Assert.True(paths.Portatil);
+
+            // Nenhum caminho pode apontar para fora da pasta do executavel:
+            // e isso que "portatil" significa.
+            foreach (var caminho in new[]
+                     {
+                         paths.SettingsFile, paths.StateBackupFile, paths.LogFile,
+                         paths.ProfilesDirectory, paths.CacheDirectory, paths.BackupsDirectory
+                     })
+            {
+                Assert.StartsWith(pasta, caminho, StringComparison.OrdinalIgnoreCase);
+            }
+
+            // Nao da para exigir que o caminho fique fora de %LOCALAPPDATA%:
+            // a pasta temporaria do Windows mora DENTRO dele. A invariante que
+            // importa e nao cair na pasta padrao do app, que e o lugar de onde
+            // o modo portatil existe para sair.
+            var padrao = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                "GameBoost");
+
+            Assert.DoesNotContain(padrao, paths.SettingsFile, StringComparison.OrdinalIgnoreCase);
+        }
+        finally
+        {
+            try { Directory.Delete(pasta, recursive: true); } catch { /* temp */ }
+        }
+    }
+
+    [Fact]
+    public void Perfil_grava_e_le_de_volta()
+    {
+        var store = _provider.GetRequiredService<Core.Modules.Profiles.ProfileStore>();
+
+        var perfil = Core.Modules.Profiles.GameProfile.Padrao(
+            "gb-teste-perfil.exe", "Jogo de teste", @"C:\Jogos\teste", "Steam");
+
+        perfil.TimerDeMeioMilissegundo = true;
+        perfil.Afinidade.AddRange(new[] { 0, 1, 2, 3 });
+        perfil.FecharApps.Add("chrome");
+
+        try
+        {
+            store.Salvar(perfil);
+            store.Recarregar();
+
+            var lido = store.Buscar("GB-Teste-Perfil.EXE");
+
+            Assert.NotNull(lido);
+            Assert.Equal("Jogo de teste", lido!.Nome);
+            Assert.True(lido.TimerDeMeioMilissegundo);
+            Assert.Equal(4, lido.Afinidade.Count);
+
+            // Regra 3: perfil novo nunca ativa sozinho.
+            Assert.False(lido.Automatico);
+        }
+        finally
+        {
+            store.Remover("gb-teste-perfil");
+        }
+    }
+
+    [Theory]
+    [InlineData("Valorant.exe", "valorant")]
+    [InlineData("CS2.EXE", "cs2")]
+    [InlineData("  RDR2  ", "rdr2")]
+    public void Nome_de_executavel_vira_chave_normalizada(string entrada, string esperada)
+        => Assert.Equal(esperada, Core.Modules.Profiles.GameProfile.Normalizar(entrada));
+
+    [Fact]
+    public void Afinidade_recusa_nucleo_que_nao_existe_nesta_maquina()
+    {
+        var processos = _provider.GetRequiredService<Core.Abstractions.IProcessService>();
+        var eu = Environment.ProcessId;
+
+        // Um perfil gravado num PC de 64 nucleos nao pode derrubar o processo
+        // num de 8. O indice 999 nao existe em maquina nenhuma.
+        Assert.False(processos.SetAffinity(eu, new[] { 999 }));
+
+        // O nucleo 0 existe em toda maquina: este tem que passar.
+        var antes = processos.GetAffinity(eu);
+        Assert.True(processos.SetAffinity(eu, new[] { 0 }));
+        Assert.Equal(new[] { 0 }, processos.GetAffinity(eu));
+
+        // Lista vazia devolve a maquina inteira.
+        Assert.True(processos.SetAffinity(eu, Array.Empty<int>()));
+        Assert.Equal(Environment.ProcessorCount, processos.GetAffinity(eu).Count);
+
+        processos.SetAffinity(eu, antes);
+    }
+
+    [Fact]
+    public void Deteccao_de_tela_cheia_responde_sem_travar()
+    {
+        // Nao da para afirmar que HA janela em tela cheia numa maquina de
+        // teste. O que da para exigir e que a varredura de janelas termine e
+        // nao exploda com um pid que nao existe.
+        var relogio = System.Diagnostics.Stopwatch.StartNew();
+
+        var proprio = Core.Native.WindowInfo.EstaEmTelaCheia(Environment.ProcessId);
+        var inexistente = Core.Native.WindowInfo.EstaEmTelaCheia(999999);
+
+        relogio.Stop();
+
+        Assert.False(inexistente);
+        Assert.True(relogio.ElapsedMilliseconds < 2000,
+            $"a varredura de janelas levou {relogio.ElapsedMilliseconds} ms");
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-perfis.txt"),
+            $"MEDIDO: varredura de janelas em {relogio.ElapsedMilliseconds} ms, "
+          + $"proprio processo em tela cheia = {proprio}, "
+          + $"{Environment.ProcessorCount} nucleos, "
+          + $"pid em primeiro plano = {Core.Native.WindowInfo.PidEmPrimeiroPlano()}");
+    }
+
+    [Fact]
+    public async Task Winget_lista_atualizacoes_da_maquina_real()
+    {
+        var winget = _provider.GetRequiredService<Core.Modules.Uninstaller.WingetService>();
+        var versao = await winget.DetectarAsync(CancellationToken.None);
+
+        if (versao is null)
+        {
+            File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-winget.txt"),
+                "MEDIDO: winget nao esta instalado nesta maquina.");
+            return;
+        }
+
+        var lista = await winget.ListarAsync(CancellationToken.None);
+
+        // Toda linha precisa ter id sem espaco e versao nova preenchida: se a
+        // fatia de coluna sair errada, e aqui que aparece.
+        Assert.All(lista, a =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(a.Id));
+            Assert.DoesNotContain(' ', a.Id);
+            Assert.False(string.IsNullOrWhiteSpace(a.Nome));
+            Assert.False(string.IsNullOrWhiteSpace(a.VersaoNova));
+        });
+
+        // A fonte so pode ser uma das que o winget conhece. Qualquer outra
+        // coisa significa que a ultima coluna pegou pedaco da anterior.
+        Assert.All(lista, a =>
+            Assert.Contains(a.Fonte.ToLowerInvariant(), new[] { "winget", "msstore", "winget-font" }));
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-winget.txt"),
+            $"MEDIDO: winget {versao}, {lista.Count} atualizacoes | "
+          + string.Join(" | ", lista.Take(10).Select(a =>
+                $"{a.Nome} [{a.Id}] {a.VersaoAtual} -> {a.VersaoNova} ({a.Fonte})"
+              + (a.VersaoIncerta ? " INCERTA" : string.Empty))));
+    }
+
+    [Fact]
+    public void Tabela_do_winget_e_lida_por_posicao_e_nao_por_idioma()
+    {
+        // Mesma tabela, cabecalho em portugues. Se o parser dependesse da
+        // palavra "Available", isto devolveria zero.
+        var saida = string.Join("\n", new[]
+        {
+            "Nome                 Id                     Versão   Disponível  Fonte",
+            "-----------------------------------------------------------------------",
+            "7-Zip 24.09 (x64)    7zip.7zip              24.09    26.03       winget",
+            "Google Cloud SDK     Google.CloudSDK        Unknown  584.0.0     winget",
+            "Epic Games Launcher  XP99VR1BPSBQJ2         1.3.175  1.3.189     msstore",
+            "3 upgrades available."
+        });
+
+        var lista = Core.Modules.Uninstaller.WingetService.Interpretar(saida);
+
+        Assert.Equal(3, lista.Count);
+        Assert.Equal("7zip.7zip", lista[0].Id);
+        Assert.Equal("26.03", lista[0].VersaoNova);
+
+        // "Unknown" nao e uma versao: o winget nao sabe qual esta instalada.
+        Assert.True(lista[1].VersaoIncerta);
+        Assert.False(lista[0].VersaoIncerta);
+
+        Assert.True(lista[2].DaStore);
+
+        // O rodape nao pode virar uma linha da tabela.
+        Assert.DoesNotContain(lista, a => a.Nome.Contains("upgrades available"));
+    }
+
+    [Theory]
+    // O host de acesso remoto nao e navegador. Com casamento por prefixo cru,
+    // "Google.Chrome" pegava "Google.ChromeRemoteDesktopHost" e ele aparecia na
+    // tela como atualizacao de seguranca.
+    [InlineData("Google.ChromeRemoteDesktopHost", false)]
+    [InlineData("Google.Chrome", true)]
+    [InlineData("Git.Git", true)]
+    [InlineData("Git.GitLFS", false)]
+    [InlineData("7zip.7zip", true)]
+    [InlineData("Microsoft.Edge", true)]
+    [InlineData("Microsoft.EdgeWebView2Runtime", false)]
+    public void Id_do_winget_so_casa_em_fronteira_de_ponto(string id, bool esperado)
+    {
+        var alvo = new Core.Modules.Uninstaller.AtualizacaoDisponivel
+        {
+            Nome = id, Id = id, VersaoAtual = "1.0", VersaoNova = "2.0", Fonte = "winget"
+        };
+
+        Assert.Equal(esperado, Core.Modules.Uninstaller.UpdateCatalog.EhDeSeguranca(alvo));
+    }
+
+    [Theory]
+    // Familia inteira continua casando: o padrao termina em ponto de proposito.
+    [InlineData("Intel.IntelDriverAndSupportAssistant", Core.Modules.Uninstaller.ClasseDeAtualizacao.Driver)]
+    [InlineData("Microsoft.DotNet.SDK.9", Core.Modules.Uninstaller.ClasseDeAtualizacao.Runtime)]
+    [InlineData("Valve.Steam", Core.Modules.Uninstaller.ClasseDeAtualizacao.AtualizaSozinho)]
+    [InlineData("RARLab.WinRAR", Core.Modules.Uninstaller.ClasseDeAtualizacao.Normal)]
+    public void Classificacao_separa_driver_runtime_e_auto_update(
+        string id, Core.Modules.Uninstaller.ClasseDeAtualizacao esperada)
+    {
+        var alvo = new Core.Modules.Uninstaller.AtualizacaoDisponivel
+        {
+            Nome = id, Id = id, VersaoAtual = "1.0", VersaoNova = "2.0", Fonte = "winget"
+        };
+
+        Assert.Equal(esperada, Core.Modules.Uninstaller.UpdateCatalog.Classificar(alvo));
+    }
+
+    [Fact]
+    public void Codigo_de_saida_do_winget_vira_frase_em_portugues()
+    {
+        var texto = Core.Modules.Uninstaller.WingetService.Explicar(
+            unchecked((int)0x8A150056), string.Empty, string.Empty);
+
+        Assert.Contains("aberto", texto, StringComparison.OrdinalIgnoreCase);
+
+        // Codigo desconhecido nao pode virar mensagem vazia.
+        var outro = Core.Modules.Uninstaller.WingetService.Explicar(-12345, string.Empty, string.Empty);
+        Assert.Contains("-12345", outro);
+    }
+
+    [Fact]
+    public async Task Nat_e_classificado_no_vocabulario_dos_jogos()
+    {
+        var nat = _provider.GetRequiredService<Core.Modules.Network.NatDiagnostics>();
+        var resultado = await nat.DiagnosticarAsync(CancellationToken.None);
+
+        // O texto nunca pode sair vazio: ele e o produto desta tela.
+        Assert.False(string.IsNullOrWhiteSpace(resultado.Explicacao));
+        Assert.False(string.IsNullOrWhiteSpace(resultado.NomeCurto));
+        Assert.Contains(resultado.Semaforo, new[] { "verde", "amarelo", "vermelho", "cinza" });
+
+        // Se o STUN respondeu, o endereco publico nao pode ser privado: seria
+        // sinal de que lemos o campo errado do pacote.
+        if (resultado.EnderecoPublico is not null)
+        {
+            var b = resultado.EnderecoPublico.GetAddressBytes();
+            var privado = b[0] == 10
+                       || (b[0] == 172 && b[1] >= 16 && b[1] <= 31)
+                       || (b[0] == 192 && b[1] == 168);
+
+            Assert.False(privado,
+                $"STUN devolveu {resultado.EnderecoPublico}, que e endereco privado");
+        }
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-nat.txt"),
+            $"MEDIDO: NAT {resultado.NomeCurto} ({resultado.Semaforo}) | "
+          + $"publico {resultado.EnderecoPublico?.ToString() ?? "nao detectado"} | "
+          + $"local {resultado.EnderecoLocal} | saltos privados {resultado.SaltosPrivados} | "
+          + $"porta estavel {resultado.PortaEstavel} | teredo {resultado.Teredo} | "
+          + $"upnp {resultado.UpnpDisponivel} | firewall {string.Join(", ", resultado.PerfisDeFirewallAtivos)}");
+    }
+
+    [Fact]
+    public async Task Teste_de_velocidade_respeita_a_permissao_de_rede()
+    {
+        var teste = _provider.GetRequiredService<Core.Modules.Network.SpeedTest>();
+
+        // A permissao e desligada por padrao (regra 8). Sem ela o teste nao sai
+        // para a rede e devolve o motivo, em vez de falhar calado.
+        if (!teste.Permitido)
+        {
+            var bloqueado = await teste.MedirAsync(null, CancellationToken.None);
+
+            Assert.False(bloqueado.Funcionou);
+            Assert.NotNull(bloqueado.Erro);
+            Assert.Equal(0, bloqueado.BytesBaixados);
+
+            File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-velocidade.txt"),
+                "MEDIDO: permissao de rede desligada, teste nao saiu para a internet. " + bloqueado.Erro);
+            return;
+        }
+
+        var resultado = await teste.MedirAsync(null, CancellationToken.None);
+
+        // O upload nao pode sair maior que o download numa linha domestica.
+        // Fibra residencial e assimetrica; quando o upload passa o download, o
+        // que foi medido foi a rajada da operadora, nao a linha. Foi o defeito
+        // que deu 380 Mbps de upload numa linha de 73.
+        if (resultado.Funcionou && resultado.UploadMbps > 0)
+        {
+            Assert.True(resultado.UploadMbps <= resultado.DownloadMbps * 1.2,
+                $"upload {resultado.UploadMbps} Mbps maior que download {resultado.DownloadMbps} Mbps: "
+              + "a medicao pegou rajada em vez da taxa sustentada");
+        }
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-velocidade.txt"),
+            $"MEDIDO: download {resultado.DownloadMbps} Mbps, upload {resultado.UploadMbps} Mbps, "
+          + $"{resultado.BytesBaixados / 1024 / 1024} MB baixados, "
+          + $"{resultado.BytesEnviados / 1024 / 1024} MB enviados, "
+          + $"em {resultado.Duracao.TotalSeconds:0.0}s");
+    }
+
+    [Fact]
+    public async Task Rede_mede_latencia_e_dns_de_verdade()
+    {
+        var modulo = _provider.GetRequiredService<Core.Modules.Network.NetworkModule>();
+        var resultado = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.NotEmpty(resultado.Itens);
+        Assert.DoesNotContain(resultado.Itens, i => i.PreMarcado);
+
+        // O reset de Winsock nao tem desfazer: tem que estar como risco alto.
+        var winsock = resultado.Itens.Single(i => i.Id == "rede:winsock");
+        Assert.Equal(Core.Modules.RiskLevel.Alto, winsock.Risco);
+
+        // Ping ate a internet precisa ter respondido; se nem isso funciona, a
+        // medicao nao vale nada e o teste tem que gritar.
+        var internet = modulo.UltimoPing.Where(p => p.Rotulo.StartsWith("Internet")).ToList();
+        Assert.NotEmpty(internet);
+
+        var texto = "MEDIDO: " + resultado.Resumo + " | ping: "
+            + string.Join("; ", modulo.UltimoPing.Select(p =>
+                $"{p.Rotulo} {p.Alvo} {(p.Respondeu ? $"{p.MediaMs}ms jitter {p.JitterMs}ms perda {p.PerdaPercentual}%" : "sem resposta")}"))
+            + " | dns: "
+            + string.Join("; ", modulo.UltimoDns.Select(d =>
+                $"{d.Nome} {d.Endereco} {(d.Respondeu ? d.MediaMs + "ms" : "sem resposta")}{(d.EmUso ? " (em uso)" : string.Empty)}"))
+            + " | wifi: " + (modulo.UltimoWifi is null ? "cabo" : $"{modulo.UltimoWifi.Ssid} {modulo.UltimoWifi.Padrao} {modulo.UltimoWifi.Banda} {modulo.UltimoWifi.SinalPercentual}%")
+            + " | conexoes: "
+            + string.Join("; ", modulo.UltimosConsumidores.Take(6).Select(c => $"{c.Nome}={c.Conexoes}"));
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-rede.txt"), texto);
+    }
+
+    [Fact]
+    public async Task Tweaks_leem_o_estado_real_da_maquina_e_nao_pre_marcam_nada()
+    {
+        var modulo = _provider.GetRequiredService<Core.Modules.Tweaks.TweaksModule>();
+        var resultado = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.NotEmpty(resultado.Itens);
+
+        // Regra 3: nenhum ajuste do sistema vem marcado, nem o recomendado.
+        Assert.DoesNotContain(resultado.Itens, i => i.PreMarcado);
+
+        // Regra 4: todo item precisa dizer o que faz e como desfazer.
+        Assert.All(resultado.Itens, i =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(i.Descricao));
+            Assert.False(string.IsNullOrWhiteSpace(i.ComoDesfazer));
+        });
+
+        // O VBS aparece, mas so de leitura: alterar isso nao e decisao daqui.
+        var vbs = resultado.Itens.Single(i => i.Id == "tweak:vbs");
+        Assert.True(vbs.Bloqueado);
+
+        // Windows Update e antivirus tem que estar bloqueados.
+        foreach (var nome in new[] { "servico:wuauserv", "servico:WinDefend" })
+        {
+            var item = resultado.Itens.FirstOrDefault(i => i.Id == nome);
+            if (item is not null)
+            {
+                Assert.True(item.Bloqueado, $"{nome} deveria estar bloqueado");
+                Assert.False(string.IsNullOrWhiteSpace(item.MotivoBloqueio));
+            }
+        }
+
+        var ligados = resultado.Itens
+            .Where(i => i.Payload is Core.Modules.Tweaks.TweaksModule.TweakEstado { Ligado: true })
+            .Select(i => i.Titulo)
+            .ToList();
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-tweaks.txt"),
+            $"MEDIDO: {resultado.Resumo} | ja ativos: {string.Join("; ", ligados)} | "
+          + "servicos: " + string.Join("; ", resultado.Itens
+                .Where(i => i.Id.StartsWith("servico:", StringComparison.Ordinal))
+                .Select(i => $"{i.Titulo}={i.GanhoEstimado}{(i.Bloqueado ? " (bloqueado)" : string.Empty)}")));
+    }
+
+    [Fact]
+    public async Task Dry_run_dos_tweaks_nao_grava_nada_no_registro()
+    {
+        var modulo = _provider.GetRequiredService<Core.Modules.Tweaks.TweaksModule>();
+        var backup = _provider.GetRequiredService<Core.State.IStateBackup>();
+
+        await modulo.ScanAsync(null, CancellationToken.None);
+
+        var antes = backup.Todos.Count;
+
+        // Um tweak de HKCU, que nao precisa de elevacao: se o dry-run vazasse
+        // escrita, seria justamente aqui.
+        var resultado = await modulo.ApplyAsync(
+            new[] { "tweak:aceleracao-mouse" }, dryRun: true, CancellationToken.None);
+
+        Assert.True(resultado.DryRun);
+        Assert.Equal(antes, backup.Todos.Count);
+        Assert.All(resultado.Acoes, a => Assert.True(a.Sucesso));
+    }
+
+    [Fact]
+    public async Task Tamanho_total_dos_apps_nao_passa_da_capacidade_dos_discos()
+    {
+        // A primeira tela real da Fase 4 anunciou "1812,4 GB no total" numa
+        // maquina com 953 GB. Duas causas: app cuja InstallLocation aponta para
+        // uma pasta generica (media o disco inteiro) e varios apps declarando a
+        // MESMA pasta (contada uma vez por app).
+        var modulo = _provider.GetRequiredService<Core.Modules.Uninstaller.UninstallerModule>();
+        var resultado = await modulo.ScanAsync(null, CancellationToken.None);
+
+        var capacidade = DriveInfo.GetDrives()
+            .Where(d => d.IsReady && d.DriveType == DriveType.Fixed)
+            .Sum(d => d.TotalSize);
+
+        var somado = resultado.Itens.Sum(i => i.GanhoBytes);
+
+        Assert.True(somado <= capacidade,
+            $"os apps somam {somado / 1024.0 / 1024 / 1024:0.0} GB e os discos so tem "
+          + $"{capacidade / 1024.0 / 1024 / 1024:0.0} GB");
+
+        // Nenhum app sozinho pode responder por mais de um terco do disco: se
+        // responder, foi pasta generica medida como se fosse dele.
+        var teto = capacidade / 3;
+        var gigante = resultado.Itens.FirstOrDefault(i => i.GanhoBytes > teto);
+
+        Assert.True(gigante is null,
+            $"'{gigante?.Titulo}' sozinho tem {gigante?.GanhoBytes / 1024.0 / 1024 / 1024:0.0} GB");
+
+        // A tela existe para mostrar o que ocupa espaco: o maior tem que estar
+        // no topo. Antes da correcao o inventario ordenava pelo tamanho
+        // DECLARADO no registro, medido depois.
+        var tamanhos = resultado.Itens.Select(i => i.GanhoBytes).ToList();
+        Assert.True(
+            tamanhos.SequenceEqual(tamanhos.OrderByDescending(t => t)),
+            "a lista de apps nao esta em ordem decrescente de tamanho");
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-apps-total.txt"),
+            $"MEDIDO: {resultado.Resumo} | discos: {capacidade / 1024.0 / 1024 / 1024:0.0} GB | "
+          + "maiores: " + string.Join("; ", resultado.Itens
+                .OrderByDescending(i => i.GanhoBytes).Take(8)
+                .Select(i => $"{i.Titulo} {(i.GanhoBytes / 1024.0 / 1024 / 1024):0.0}GB")));
+    }
+
+    [Theory]
+    [InlineData(@"C:\Program Files", false)]
+    [InlineData(@"C:\", false)]
+    [InlineData("C:", false)]
+    [InlineData(@"C:\Program Files\Discord", true)]
+    public void Pasta_generica_nao_conta_como_pasta_do_app(string pasta, bool esperado)
+        => Assert.Equal(esperado, Core.Modules.Uninstaller.UninstallerModule.PastaConfiavel(pasta));
+
+    [Fact]
+    public void Restos_de_apps_antigos_sao_encontrados_sem_falso_positivo_obvio()
+    {
+        var log = _provider.GetRequiredService<Core.Logging.IGameBoostLogger>();
+        var inventario = new Core.Modules.Uninstaller.AppInventory(
+            _provider.GetRequiredService<Core.Abstractions.IRegistryService>(), log);
+        var scanner = new Core.Modules.Uninstaller.LeftoverScanner(log);
+
+        var instalados = inventario.Listar(medirTamanho: false, CancellationToken.None);
+        var restos = scanner.Varrer(instalados, null, CancellationToken.None);
+
+        // Nada de Microsoft, NVIDIA e afins pode entrar: sao as pastas ignoradas.
+        Assert.DoesNotContain(restos, r =>
+            r.Nome.Equals("Microsoft", StringComparison.OrdinalIgnoreCase)
+            || r.Nome.Equals("NVIDIA", StringComparison.OrdinalIgnoreCase)
+            || r.Nome.Equals("Packages", StringComparison.OrdinalIgnoreCase)
+            || r.Nome.Equals("Temp", StringComparison.OrdinalIgnoreCase));
+
+        Assert.All(restos, r =>
+        {
+            Assert.True(r.Bytes >= 1024 * 1024, "pasta pequena demais entrou na lista");
+            Assert.True(Directory.Exists(r.Caminho), $"caminho inexistente: {r.Caminho}");
+        });
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-restos.txt"),
+            $"MEDIDO: {restos.Count} pastas sem app correspondente, "
+          + $"{(restos.Sum(r => r.Bytes) / 1024.0 / 1024):0} MB | "
+          + string.Join(" | ", restos.Take(8).Select(r =>
+                $"{r.Nome} ({r.Local}) {(r.Bytes / 1024.0 / 1024):0}MB, {r.Idade}")));
+    }
+
+    [Fact]
+    public async Task Inicializacao_le_a_maquina_real_e_protege_driver_e_antivirus()
+    {
+        var modulo = _provider.GetRequiredService<Core.Modules.Startup.StartupModule>();
+
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+
+        Assert.NotEmpty(scan.Itens);
+
+        // Regra 3: nada vem marcado. O usuario decide o que abre com a maquina.
+        Assert.DoesNotContain(scan.Itens, i => i.PreMarcado);
+
+        // O aviso sobre a estimativa grosseira e obrigatorio (regra 4).
+        Assert.Contains(scan.Avisos, a => a.Contains("grosseira"));
+
+        // Driver e antivirus tem que aparecer bloqueados.
+        foreach (var item in scan.Itens)
+        {
+            var texto = (item.Titulo + " " + item.Descricao).ToLowerInvariant();
+
+            if (texto.Contains("securityhealth") || texto.Contains("kaspersky")
+                || texto.Contains("realtek"))
+            {
+                Assert.True(item.Bloqueado, $"'{item.Titulo}' deveria estar bloqueado");
+            }
+        }
+
+        var protegidos = scan.Itens.Count(i => i.Bloqueado);
+        var sugeridos = scan.Itens.Count(i => i.Categoria == "Sugestões");
+
+        File.WriteAllText(Path.Combine(Path.GetTempPath(), "gb-medida-startup.txt"),
+            $"MEDIDO: {scan.Itens.Count} entradas, {protegidos} bloqueadas, {sugeridos} sugeridas | "
+          + scan.Resumo + " | "
+          + string.Join(" | ", scan.Itens.Take(8).Select(i => $"{i.Titulo} [{i.Categoria}] {i.GanhoEstimado}")));
+    }
+
+    [Fact]
+    public async Task Dry_run_da_inicializacao_nao_toca_no_registro()
+    {
+        var modulo = _provider.GetRequiredService<Core.Modules.Startup.StartupModule>();
+        var backup = _provider.GetRequiredService<Core.State.IStateBackup>();
+
+        var scan = await modulo.ScanAsync(null, CancellationToken.None);
+        var alvos = scan.Itens.Where(i => !i.Bloqueado).Select(i => i.Id).ToList();
+
+        var resultado = await modulo.ApplyAsync(alvos, dryRun: true, CancellationToken.None);
+
+        Assert.True(resultado.DryRun);
+        Assert.False(backup.TemPendencias, "dry-run nao pode gravar ChangeRecord");
+        Assert.All(resultado.Acoes, a => Assert.Contains("Desativaria", a.Detalhe));
+    }
+
+    [Fact]
+    public void Rot13_do_userassist_vai_e_volta()
+    {
+        // O UserAssist guarda os nomes em ROT13; errar isso daria lixo no lugar
+        // do nome do executavel.
+        var original = @"C:\Program Files\Apppp.exe";
+        var codificado = Core.Modules.Uninstaller.AppInventory.Rot13(original);
+
+        Assert.NotEqual(original, codificado);
+        Assert.Equal(original, Core.Modules.Uninstaller.AppInventory.Rot13(codificado));
+    }
+
+    [Fact]
+    public void Arquivos_especiais_do_windows_sao_explicados()
+    {
+        var raiz = Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.Windows))!;
+        var especiais = Core.Modules.DiskAnalyzer.SpecialFiles.Encontrar(raiz);
+
+        // pagefile.sys existe em praticamente toda instalacao.
+        Assert.All(especiais, e =>
+        {
+            Assert.False(string.IsNullOrWhiteSpace(e.OQueE));
+            Assert.False(string.IsNullOrWhiteSpace(e.ComoRemover));
+            Assert.True(e.Bytes > 0);
+        });
+    }
+
+    [Fact]
+    public async Task Ajuda_lista_todos_os_comandos_da_secao_8()
+    {
+        var saida = new StringWriter();
+        var runner = new CommandRunner(_provider, saida);
+
+        await runner.ExecutarAsync(CommandLineOptions.Parse(new[] { "--help" }));
+
+        var texto = saida.ToString();
+        foreach (var comando in new[] { "--scan", "--report", "--clean", "--revert-all", "--gamemode", "--dry-run", "--json" })
+            Assert.Contains(comando, texto);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/QuickToolsTests.cs b/GameBoost/src/GameBoost.Tests/QuickToolsTests.cs
new file mode 100644
index 0000000..8519113
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/QuickToolsTests.cs
@@ -0,0 +1,121 @@
+using GameBoost.Core.Modules;
+using GameBoost.Core.Modules.Tools;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+public sealed class QuickToolsCatalogTests
+{
+    [Fact]
+    public void Catalogo_nao_tem_ids_repetidos()
+    {
+        var ids = QuickToolsCatalog.Todas().Select(t => t.Id).ToList();
+
+        Assert.Equal(ids.Count, ids.Distinct(StringComparer.OrdinalIgnoreCase).Count());
+    }
+
+    [Fact]
+    public void Toda_ferramenta_explica_como_desfazer()
+    {
+        // Seção 6: cada item precisa responder "o que faz, qual o risco, como desfazer".
+        Assert.All(QuickToolsCatalog.Todas(), f =>
+            Assert.False(string.IsNullOrWhiteSpace(f.ComoDesfazer), $"{f.Id} sem ComoDesfazer"));
+    }
+
+    [Fact]
+    public void Ferramenta_que_nao_da_para_desfazer_pede_confirmacao()
+    {
+        // Esvaziar a Lixeira é o caso: depois dela não há volta.
+        var lixeira = QuickToolsCatalog.Todas().Single(f => f.Id == QuickToolsCatalog.EsvaziarLixeira);
+
+        Assert.NotNull(lixeira.Confirmacao);
+        Assert.Contains("não poderão ser recuperados", lixeira.ComoDesfazer + lixeira.Confirmacao);
+        Assert.Equal(RiskLevel.Medio, lixeira.Risco);
+    }
+
+    [Fact]
+    public void Ferramenta_demorada_avisa_quanto_tempo_leva()
+    {
+        // Sem isso o usuário acha que travou e mata o app no meio de um sfc.
+        Assert.All(QuickToolsCatalog.Todas().Where(f => f.Tipo == ToolKind.Demorada),
+            f => Assert.False(string.IsNullOrWhiteSpace(f.Duracao), $"{f.Id} sem duracao"));
+    }
+
+    [Fact]
+    public void Ferramenta_de_risco_medio_ou_alto_sempre_confirma_antes()
+    {
+        Assert.All(QuickToolsCatalog.Todas().Where(f => f.Risco != RiskLevel.Baixo),
+            f => Assert.False(string.IsNullOrWhiteSpace(f.Confirmacao), $"{f.Id} nao confirma"));
+    }
+
+    [Fact]
+    public void Ferramenta_de_leitura_nunca_pede_confirmacao_nem_admin()
+    {
+        // Só lê: pedir confirmação para isso seria ruído.
+        Assert.All(QuickToolsCatalog.Todas().Where(f => f.Tipo == ToolKind.Leitura), f =>
+        {
+            Assert.Null(f.Confirmacao);
+            Assert.False(f.PrecisaAdmin);
+            Assert.Equal(RiskLevel.Baixo, f.Risco);
+        });
+    }
+
+    [Theory]
+    [InlineData(QuickToolsCatalog.PontoDeRestauracao)]
+    [InlineData(QuickToolsCatalog.VerificarIntegridade)]
+    [InlineData(QuickToolsCatalog.RepararImagem)]
+    public void Ferramenta_que_mexe_no_sistema_exige_admin(string id)
+    {
+        Assert.True(QuickToolsCatalog.Todas().Single(f => f.Id == id).PrecisaAdmin);
+    }
+
+    [Fact]
+    public void Catalogo_cobre_o_que_a_secao_5_13_pede()
+    {
+        var ids = QuickToolsCatalog.Todas().Select(f => f.Id).ToHashSet();
+
+        foreach (var esperado in new[]
+                 {
+                     QuickToolsCatalog.ReiniciarExplorer, QuickToolsCatalog.ReiniciarVideo,
+                     QuickToolsCatalog.LimparDns, QuickToolsCatalog.EsvaziarLixeira,
+                     QuickToolsCatalog.LimpezaDeDisco, QuickToolsCatalog.PontoDeRestauracao,
+                     QuickToolsCatalog.VerificarIntegridade, QuickToolsCatalog.TesteDeDisco,
+                     QuickToolsCatalog.InfoDoSistema
+                 })
+        {
+            Assert.Contains(esperado, ids);
+        }
+    }
+
+    [Fact]
+    public async Task Ferramenta_desconhecida_nao_derruba_o_servico()
+    {
+        var servico = new QuickToolsService(
+            new FakeProcessosVazio(), new FakeMemoria(), new FakeLogger());
+
+        var resultado = await servico.ExecutarAsync("inexistente", null, CancellationToken.None);
+
+        Assert.False(resultado.Sucesso);
+        Assert.Contains("desconhecida", resultado.Mensagem);
+    }
+
+    private sealed class FakeProcessosVazio : Core.Abstractions.IProcessService
+    {
+        public IReadOnlyList<Core.Abstractions.ProcessInfo> GetProcesses() => Array.Empty<Core.Abstractions.ProcessInfo>();
+        public Core.Abstractions.ProcessInfo? GetProcess(int pid) => null;
+        public bool TryCloseGracefully(int pid, TimeSpan timeout) => true;
+        public bool SetAffinity(int pid, IReadOnlyList<int> nucleos) => true;
+        public IReadOnlyList<int> GetAffinity(int pid) => Array.Empty<int>();
+        public bool Kill(int pid) => true;
+        public bool SetPriority(int pid, Core.Abstractions.ProcessPriority priority) => true;
+        public Core.Abstractions.ProcessPriority? GetPriority(int pid) => null;
+        public bool Start(string executablePath, string? arguments, string? workingDirectory) => true;
+        public long TrimWorkingSet(int pid) => 0;
+    }
+
+    private sealed class FakeMemoria : Core.Abstractions.IMemoryService
+    {
+        public Core.Abstractions.MemorySnapshot GetSnapshot() => new(16_000_000_000, 8_000_000_000, 0);
+        public bool PurgeStandbyList() => true;
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/RollbackEngineTests.cs b/GameBoost/src/GameBoost.Tests/RollbackEngineTests.cs
new file mode 100644
index 0000000..40d751c
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/RollbackEngineTests.cs
@@ -0,0 +1,340 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Settings;
+using GameBoost.Core.State;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Prova da regra 1: aplicar -> reverter -> o sistema volta ao estado original.
+/// </summary>
+public sealed class RollbackEngineTests
+{
+    private readonly FakeFileSystem _fs = new();
+    private readonly FakeLogger _log = new();
+    private readonly FakeClock _clock = new();
+    private readonly FakeRegistry _registry = new();
+    private readonly FakeServices _services = new();
+    private readonly FakePower _power = new();
+    private readonly AppPaths _paths = new(@"C:\dados\GameBoost", portatil: false);
+
+    private (StateBackup Backup, RollbackEngine Engine) Montar()
+    {
+        var backup = new StateBackup(_paths, _fs, _log, _clock);
+        var engine = new RollbackEngine(backup, _registry, _services, _power, _log, _clock);
+        return (backup, engine);
+    }
+
+    // ---------------- Registro ----------------
+
+    [Fact]
+    public void Valor_de_registro_existente_volta_ao_original()
+    {
+        _registry.Semear(RegistryRoot.CurrentUser, @"System\GameConfigStore", "GameDVR_Enabled", 1, RegistryValueKindLite.DWord);
+        var (backup, engine) = Montar();
+
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "gamemode",
+            Tipo = ChangeType.Registry,
+            Alvo = @"System\GameConfigStore",
+            SubAlvo = "GameDVR_Enabled",
+            ValorAnterior = "1",
+            ValorNovo = "0",
+            ValorAnteriorExistia = true,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+        });
+
+        _registry.SetValue(RegistryRoot.CurrentUser, @"System\GameConfigStore", "GameDVR_Enabled", 0, RegistryValueKindLite.DWord);
+        Assert.Equal(0, _registry.GetValue(RegistryRoot.CurrentUser, @"System\GameConfigStore", "GameDVR_Enabled"));
+
+        var resultados = engine.Reverter(new[] { record.Id }, dryRun: false);
+
+        Assert.True(resultados.Single().Sucesso);
+        Assert.Equal(1, _registry.GetValue(RegistryRoot.CurrentUser, @"System\GameConfigStore", "GameDVR_Enabled"));
+    }
+
+    [Fact]
+    public void Valor_que_nao_existia_antes_e_apagado_e_nao_zerado()
+    {
+        var (backup, engine) = Montar();
+
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "gamemode",
+            Tipo = ChangeType.Registry,
+            Alvo = @"Software\Microsoft\GameBar",
+            SubAlvo = "ShowStartupPanel",
+            ValorAnterior = null,
+            ValorNovo = "0",
+            ValorAnteriorExistia = false,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+        });
+
+        _registry.SetValue(RegistryRoot.CurrentUser, @"Software\Microsoft\GameBar", "ShowStartupPanel", 0, RegistryValueKindLite.DWord);
+
+        engine.Reverter(new[] { record.Id }, dryRun: false);
+
+        Assert.Null(_registry.GetValue(RegistryRoot.CurrentUser, @"Software\Microsoft\GameBar", "ShowStartupPanel"));
+        Assert.Contains(@"CurrentUser\Software\Microsoft\GameBar\ShowStartupPanel", _registry.Remocoes);
+    }
+
+    [Fact]
+    public void Tipos_de_valor_sobrevivem_a_ida_e_volta()
+    {
+        var (backup, engine) = Montar();
+
+        var binario = new byte[] { 0xDE, 0xAD, 0xBE, 0xEF };
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste",
+            Tipo = ChangeType.Registry,
+            Alvo = @"Software\Teste",
+            SubAlvo = "Blob",
+            ValorAnterior = Convert.ToHexString(binario),
+            ValorNovo = "00",
+            ValorAnteriorExistia = true,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "Binary" }
+        });
+
+        engine.Reverter(new[] { record.Id }, dryRun: false);
+
+        var restaurado = Assert.IsType<byte[]>(_registry.GetValue(RegistryRoot.CurrentUser, @"Software\Teste", "Blob"));
+        Assert.Equal(binario, restaurado);
+    }
+
+    // ---------------- Servicos ----------------
+
+    [Fact]
+    public void Servico_parado_volta_a_rodar()
+    {
+        _services.Semear(new ServiceInfo("wuauserv", "Windows Update", IsRunning: true, ServiceStartMode.Manual));
+        var (backup, engine) = Montar();
+
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "gamemode",
+            Tipo = ChangeType.Service,
+            Alvo = "wuauserv",
+            ValorAnterior = "Manual",
+            ValorNovo = "Manual",
+            Extras = { ["estavaRodando"] = "true" }
+        });
+
+        _services.Stop("wuauserv", TimeSpan.FromSeconds(1));
+        Assert.False(_services.GetService("wuauserv")!.IsRunning);
+
+        var resultado = engine.Reverter(new[] { record.Id }, dryRun: false).Single();
+
+        Assert.True(resultado.Sucesso);
+        Assert.True(_services.GetService("wuauserv")!.IsRunning);
+    }
+
+    [Fact]
+    public void Start_mode_de_servico_volta_ao_original()
+    {
+        _services.Semear(new ServiceInfo("DiagTrack", "Telemetria", IsRunning: false, ServiceStartMode.Automatic));
+        var (backup, engine) = Montar();
+
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "services",
+            Tipo = ChangeType.Service,
+            Alvo = "DiagTrack",
+            ValorAnterior = "Automatic",
+            ValorNovo = "Disabled",
+            Extras = { ["estavaRodando"] = "false" }
+        });
+
+        _services.SetStartMode("DiagTrack", ServiceStartMode.Disabled);
+
+        engine.Reverter(new[] { record.Id }, dryRun: false);
+
+        Assert.Equal(ServiceStartMode.Automatic, _services.GetService("DiagTrack")!.StartMode);
+        Assert.False(_services.GetService("DiagTrack")!.IsRunning);
+    }
+
+    // ---------------- Energia ----------------
+
+    [Fact]
+    public void Plano_de_energia_volta_ao_anterior()
+    {
+        var balanceado = _power.Ativo;
+        var (backup, engine) = Montar();
+
+        var record = backup.Registrar(new ChangeRecord
+        {
+            Modulo = "gamemode",
+            Tipo = ChangeType.Power,
+            Alvo = "plano-de-energia",
+            ValorAnterior = balanceado.ToString(),
+            ValorNovo = "8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c"
+        });
+
+        _power.SetActivePlan(new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c"));
+
+        engine.Reverter(new[] { record.Id }, dryRun: false);
+
+        Assert.Equal(balanceado, _power.Ativo);
+    }
+
+    // ---------------- Ordem, dry-run e idempotencia ----------------
+
+    [Fact]
+    public void Reversao_acontece_na_ordem_inversa_da_aplicacao()
+    {
+        var (backup, engine) = Montar();
+
+        foreach (var nome in new[] { "primeiro", "segundo", "terceiro" })
+        {
+            backup.Registrar(new ChangeRecord
+            {
+                Modulo = "teste",
+                Tipo = ChangeType.Registry,
+                Alvo = @"Software\Teste",
+                SubAlvo = nome,
+                ValorAnterior = "1",
+                ValorNovo = "0",
+                ValorAnteriorExistia = true,
+                Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+            });
+        }
+
+        engine.ReverterTudo(dryRun: false);
+
+        Assert.Equal(
+            new[] { "terceiro", "segundo", "primeiro" },
+            _registry.Escritas.Select(e => e[(e.LastIndexOf('\\') + 1)..]).ToArray());
+    }
+
+    [Fact]
+    public void Dry_run_nao_toca_em_nada()
+    {
+        _registry.Semear(RegistryRoot.CurrentUser, @"Software\Teste", "Valor", 1, RegistryValueKindLite.DWord);
+        _services.Semear(new ServiceInfo("wuauserv", "Windows Update", IsRunning: false, ServiceStartMode.Manual));
+        var (backup, engine) = Montar();
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Registry,
+            Alvo = @"Software\Teste", SubAlvo = "Valor",
+            ValorAnterior = "9", ValorNovo = "0", ValorAnteriorExistia = true,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+        });
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Service,
+            Alvo = "wuauserv", ValorAnterior = "Manual",
+            Extras = { ["estavaRodando"] = "true" }
+        });
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Power,
+            Alvo = "plano-de-energia",
+            ValorAnterior = "8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c"
+        });
+
+        var resultados = engine.ReverterTudo(dryRun: true);
+
+        Assert.All(resultados, r => Assert.True(r.Sucesso));
+        Assert.Empty(_registry.Escritas);
+        Assert.Empty(_registry.Remocoes);
+        Assert.Empty(_services.Inicios);
+        Assert.Empty(_services.Modos);
+        Assert.Empty(_power.Trocas);
+
+        // Dry-run nao pode marcar nada como revertido: as pendencias continuam.
+        Assert.Equal(3, backup.Pendentes.Count);
+    }
+
+    [Fact]
+    public void Reverter_duas_vezes_nao_reaplica_nada()
+    {
+        _registry.Semear(RegistryRoot.CurrentUser, @"Software\Teste", "Valor", 0, RegistryValueKindLite.DWord);
+        var (backup, engine) = Montar();
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Registry,
+            Alvo = @"Software\Teste", SubAlvo = "Valor",
+            ValorAnterior = "1", ValorNovo = "0", ValorAnteriorExistia = true,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+        });
+
+        Assert.Single(engine.ReverterTudo(dryRun: false));
+        Assert.Empty(engine.ReverterTudo(dryRun: false));
+        Assert.False(backup.TemPendencias);
+        Assert.Single(_registry.Escritas);
+    }
+
+    [Fact]
+    public void Falha_em_um_item_nao_interrompe_os_demais()
+    {
+        var (backup, engine) = Montar();
+
+        // Sem a chave "root", este registro nao tem como ser revertido.
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Registry,
+            Alvo = @"Software\Teste", SubAlvo = "Quebrado",
+            ValorAnterior = "1", ValorAnteriorExistia = true
+        });
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "teste", Tipo = ChangeType.Registry,
+            Alvo = @"Software\Teste", SubAlvo = "Bom",
+            ValorAnterior = "7", ValorNovo = "0", ValorAnteriorExistia = true,
+            Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+        });
+
+        var resultados = engine.ReverterTudo(dryRun: false);
+
+        Assert.Equal(2, resultados.Count);
+        Assert.Single(resultados, r => !r.Sucesso);
+        Assert.Equal(7, _registry.GetValue(RegistryRoot.CurrentUser, @"Software\Teste", "Bom"));
+
+        // O que falhou continua pendente para nova tentativa.
+        Assert.Single(backup.Pendentes);
+    }
+
+    [Fact]
+    public void Estado_sobrevive_a_um_travamento_e_e_relido_do_disco()
+    {
+        var (backup, _) = Montar();
+
+        backup.Registrar(new ChangeRecord
+        {
+            Modulo = "gamemode", Tipo = ChangeType.Power,
+            Alvo = "plano-de-energia",
+            ValorAnterior = "381b4222-f694-41f0-9685-ff5bb260df2e"
+        });
+
+        // Simula reabrir o app: nova instancia lendo o mesmo arquivo.
+        var depoisDoCrash = new StateBackup(_paths, _fs, _log, _clock);
+
+        Assert.True(depoisDoCrash.TemPendencias);
+        Assert.Equal("plano-de-energia", depoisDoCrash.Pendentes.Single().Alvo);
+    }
+
+    [Fact]
+    public void Reverter_com_lista_vazia_pega_tudo_que_esta_pendente()
+    {
+        var (backup, engine) = Montar();
+
+        for (var i = 0; i < 3; i++)
+        {
+            backup.Registrar(new ChangeRecord
+            {
+                Modulo = "teste", Tipo = ChangeType.Registry,
+                Alvo = @"Software\Teste", SubAlvo = $"V{i}",
+                ValorAnterior = "1", ValorAnteriorExistia = true,
+                Extras = { ["root"] = "CurrentUser", ["kind"] = "DWord" }
+            });
+        }
+
+        Assert.Equal(3, engine.Reverter(Array.Empty<string>(), dryRun: false).Count);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/SafetyGuardTests.cs b/GameBoost/src/GameBoost.Tests/SafetyGuardTests.cs
new file mode 100644
index 0000000..607ba93
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/SafetyGuardTests.cs
@@ -0,0 +1,381 @@
+using GameBoost.Core.Abstractions;
+using GameBoost.Core.Safety;
+using GameBoost.Core.Settings;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+/// <summary>
+/// Teste obrigatorio da secao 9: um caso para cada lista de blindagem.
+/// Se algum destes cair, o app nao pode ser publicado.
+/// </summary>
+public sealed class SafetyGuardTests
+{
+    private const int SessaoAtual = 1;
+    private const int PidProprio = 4242;
+
+    private static SafetyGuard Criar(AppSettings? settings = null, params string[] antivirus)
+        => new(settings ?? new AppSettings(), SessaoAtual, PidProprio,
+            new HashSet<string>(antivirus, StringComparer.OrdinalIgnoreCase),
+            @"C:\Windows");
+
+    private static ProcessInfo Processo(
+        string nome,
+        int pid = 1000,
+        string? caminho = @"C:\Program Files\App\app.exe",
+        long ram = 100L * 1024 * 1024,
+        int sessao = SessaoAtual)
+        => new(pid, nome, caminho, null, ram, null, null, sessao);
+
+    // ---------------- Processos criticos ----------------
+
+    [Theory]
+    [InlineData("csrss")]
+    [InlineData("wininit")]
+    [InlineData("winlogon")]
+    [InlineData("services")]
+    [InlineData("lsass")]
+    [InlineData("smss")]
+    [InlineData("dwm")]
+    [InlineData("svchost")]
+    [InlineData("explorer")]
+    [InlineData("audiodg")]
+    public void Processo_critico_do_windows_e_protegido(string nome)
+    {
+        var veredito = Criar().CheckProcess(Processo(nome, caminho: @"C:\Windows\System32\" + nome + ".exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.ProcessoCritico, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Nome_com_extensao_exe_tambem_e_reconhecido()
+    {
+        var veredito = Criar().CheckProcess(Processo("LSASS.EXE", caminho: @"D:\falso\lsass.exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.ProcessoCritico, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Pids_do_kernel_sao_protegidos()
+    {
+        var veredito = Criar().CheckProcess(Processo("System", pid: 4, caminho: null));
+
+        Assert.True(veredito.Protegido);
+    }
+
+    // ---------------- Anti-cheats ----------------
+
+    [Theory]
+    [InlineData("EasyAntiCheat")]
+    [InlineData("BEService")]
+    [InlineData("vgc")]
+    [InlineData("vgtray")]
+    [InlineData("FACEITService")]
+    [InlineData("PnkBstrA")]
+    [InlineData("XignCode")]
+    [InlineData("GameGuard")]
+    [InlineData("nProtect")]
+    [InlineData("Ricochet")]
+    [InlineData("EAAntiCheat")]
+    public void Anti_cheat_nunca_pode_ser_encerrado(string nome)
+    {
+        var veredito = Criar().CheckProcess(Processo(nome, caminho: @"C:\Program Files\EAC\" + nome + ".exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.AntiCheat, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Anti_cheat_nunca_e_pre_marcado()
+    {
+        Assert.False(Criar().PodePreMarcar(Processo("vgc", caminho: @"C:\Program Files\Riot Vanguard\vgc.exe")));
+    }
+
+    // ---------------- Antivirus ----------------
+
+    [Fact]
+    public void Antivirus_da_lista_estatica_e_protegido()
+    {
+        var veredito = Criar().CheckProcess(Processo("MsMpEng", caminho: @"D:\qualquer\MsMpEng.exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.Seguranca, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Antivirus_detectado_por_wmi_e_protegido_mesmo_fora_da_lista()
+    {
+        var veredito = Criar(null, "AntivirusExotico")
+            .CheckProcess(Processo("AntivirusExotico", caminho: @"C:\AV\av.exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.Seguranca, veredito.Motivo);
+    }
+
+    // ---------------- Caminho e sessao ----------------
+
+    [Fact]
+    public void Executavel_dentro_do_windows_e_protegido()
+    {
+        var veredito = Criar().CheckProcess(Processo("qualquercoisa", caminho: @"C:\Windows\System32\qualquercoisa.exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.DentroDoWindows, veredito.Motivo);
+    }
+
+    [Fact]
+    public void WindowsApps_nao_conta_como_dentro_do_windows()
+    {
+        // Comparacao por segmento: C:\WindowsApps comeca com C:\Windows como texto.
+        var veredito = Criar().CheckProcess(Processo("app", caminho: @"C:\WindowsApps\app\app.exe"));
+
+        Assert.False(veredito.Protegido);
+    }
+
+    [Fact]
+    public void Processo_de_outra_sessao_e_protegido()
+    {
+        var veredito = Criar().CheckProcess(Processo("bloco", sessao: 7));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.OutraSessao, veredito.Motivo);
+    }
+
+    [Fact]
+    public void O_proprio_gameboost_nunca_se_encerra()
+    {
+        var porPid = Criar().CheckProcess(Processo("qualquer", pid: PidProprio));
+        var porNome = Criar().CheckProcess(Processo("GameBoost", pid: 999));
+
+        Assert.Equal(ProtectionReason.ProprioApp, porPid.Motivo);
+        Assert.Equal(ProtectionReason.ProprioApp, porNome.Motivo);
+    }
+
+    // ---------------- Lista do usuario ----------------
+
+    [Fact]
+    public void Lista_nunca_encerrar_do_usuario_e_respeitada()
+    {
+        var settings = new AppSettings { NuncaEncerrar = { "MeuApp.exe" } };
+        var veredito = Criar(settings).CheckProcess(Processo("MeuApp"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.ListaDoUsuario, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Lista_sempre_encerrar_vence_a_lista_de_nunca_pre_marcados()
+    {
+        var settings = new AppSettings { SempreEncerrar = { "steam" } };
+
+        Assert.True(Criar(settings).PodePreMarcar(Processo("steam", caminho: @"C:\Steam\steam.exe")));
+    }
+
+    [Fact]
+    public void Lista_sempre_encerrar_nao_vence_a_blindagem()
+    {
+        // Um usuario nao pode se autorizar a matar o lsass editando o settings.json.
+        var settings = new AppSettings { SempreEncerrar = { "lsass" } };
+
+        Assert.False(Criar(settings).PodePreMarcar(Processo("lsass", caminho: @"D:\x\lsass.exe")));
+    }
+
+    // ---------------- Pre-marcacao (regra 3) ----------------
+
+    [Theory]
+    [InlineData("steam")]
+    [InlineData("EpicGamesLauncher")]
+    [InlineData("Battle.net")]
+    [InlineData("RiotClientServices")]
+    [InlineData("obs64")]
+    [InlineData("devenv")]
+    [InlineData("Code")]
+    [InlineData("MSIAfterburner")]
+    public void Launchers_gravadores_e_ides_aparecem_mas_nunca_pre_marcados(string nome)
+    {
+        var guard = Criar();
+        var processo = Processo(nome, caminho: $@"C:\Program Files\{nome}\{nome}.exe");
+
+        Assert.False(guard.CheckProcess(processo).Protegido);
+        Assert.False(guard.PodePreMarcar(processo));
+    }
+
+    [Theory]
+    [InlineData("Code")]
+    [InlineData("devenv")]
+    [InlineData("Antigravity")]
+    [InlineData("claude")]
+    [InlineData("ChatGPT")]
+    [InlineData("Cursor")]
+    [InlineData("windsurf")]
+    [InlineData("rider64")]
+    [InlineData("idea64")]
+    [InlineData("sublime_text")]
+    [InlineData("notepad++")]
+    [InlineData("obsidian")]
+    public void Ide_editor_ou_assistente_de_desenvolvimento_nunca_e_pre_marcado(string nome)
+    {
+        // Regra 3: costumam ter trabalho nao salvo aberto. Aparecem na lista,
+        // mas quem marca e o usuario.
+        var guard = Criar();
+        var processo = Processo(nome, caminho: @"C:\Users\User\AppData\Local\" + nome + @"\" + nome + ".exe");
+
+        Assert.False(guard.CheckProcess(processo).Protegido, nome + " nao deveria estar bloqueado, so desmarcado.");
+        Assert.False(guard.PodePreMarcar(processo), nome + " veio pre-marcado e nao deveria.");
+    }
+
+    // Os quatro casos abaixo vieram do primeiro teste com privilegios de
+    // administrador numa maquina real: todos vinham pre-marcados e nao deviam.
+
+    [Theory]
+    [InlineData("ksdeui")]
+    [InlineData("kpm")]
+    [InlineData("klnagent")]
+    public void Componente_de_antivirus_pouco_conhecido_tambem_e_protegido(string nome)
+    {
+        var veredito = Criar().CheckProcess(Processo(nome, caminho: @"C:\Program Files\AV\" + nome + ".exe"));
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.Seguranca, veredito.Motivo);
+    }
+
+    [Theory]
+    [InlineData("OneDrive")]
+    [InlineData("OneDrive.Sync.Service")]
+    [InlineData("FileCoAuth")]
+    [InlineData("Dropbox")]
+    [InlineData("syncthing")]
+    public void Cliente_de_sincronizacao_de_nuvem_nunca_e_pre_marcado(string nome)
+    {
+        // Encerrar no meio de um envio deixa arquivo pela metade na nuvem.
+        var guard = Criar();
+        var processo = Processo(nome, caminho: $@"C:\Program Files\{nome}\{nome}.exe");
+
+        Assert.False(guard.CheckProcess(processo).Protegido);
+        Assert.False(guard.PodePreMarcar(processo));
+    }
+
+    [Theory]
+    [InlineData("AntigravitySetup-stable-ecfbad74")]
+    [InlineData("AntigravitySetup-stable-ecfbad74.tmp")]
+    [InlineData("vc_redist.x64")]
+    [InlineData("ChromeSetup")]
+    [InlineData("AdobeUpdater")]
+    [InlineData("msiexec")]
+    public void Instalador_em_execucao_nunca_e_pre_marcado(string nome)
+    {
+        // Encerrar um instalador no meio do trabalho corrompe a instalacao.
+        Assert.False(Criar().PodePreMarcar(Processo(nome, caminho: @"C:\Users\User\AppData\Local\Temp\" + nome + ".exe")));
+    }
+
+    [Fact]
+    public void Nome_comum_nao_e_confundido_com_instalador()
+    {
+        // "update" nao pode transformar qualquer app em instalador por engano.
+        Assert.True(Criar().PodePreMarcar(Processo("chrome", caminho: @"C:\Program Files\Google\chrome.exe")));
+        Assert.True(Criar().PodePreMarcar(Processo("Discord", caminho: @"C:\Users\User\AppData\Local\Discord\Discord.exe")));
+    }
+
+    [Fact]
+    public void Executavel_em_pasta_de_jogo_nunca_e_pre_marcado()
+    {
+        var processo = Processo("jogo", caminho: @"D:\SteamLibrary\steamapps\common\Cyberpunk 2077\bin\jogo.exe");
+
+        Assert.False(Criar().PodePreMarcar(processo));
+    }
+
+    [Fact]
+    public void App_comum_pode_ser_pre_marcado()
+    {
+        Assert.True(Criar().PodePreMarcar(Processo("chrome", caminho: @"C:\Program Files\Google\Chrome\chrome.exe")));
+    }
+
+    // ---------------- Servicos ----------------
+
+    [Theory]
+    [InlineData("DcomLaunch")]
+    [InlineData("RpcSs")]
+    [InlineData("Winmgmt")]
+    [InlineData("EventLog")]
+    [InlineData("Dhcp")]
+    [InlineData("Dnscache")]
+    [InlineData("Audiosrv")]
+    [InlineData("WinDefend")]
+    [InlineData("mpssvc")]
+    [InlineData("TrustedInstaller")]
+    public void Servico_essencial_nao_pode_ser_alterado(string nome)
+    {
+        var veredito = Criar().CheckService(nome, apenasPausar: false);
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.ServicoProtegido, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Windows_update_pode_ser_pausado_mas_nao_desabilitado()
+    {
+        var guard = Criar();
+
+        Assert.False(guard.CheckService("wuauserv", apenasPausar: true).Protegido);
+        Assert.True(guard.CheckService("wuauserv", apenasPausar: false).Protegido);
+    }
+
+    // ---------------- Caminhos ----------------
+
+    [Fact]
+    public void Caminho_fora_da_whitelist_e_bloqueado()
+    {
+        var veredito = Criar().CheckPath(@"C:\Windows\System32\drivers\etc\hosts", new[] { @"C:\Windows\Temp" });
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.CaminhoDeSistema, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Whitelist_vazia_nao_libera_nada()
+    {
+        Assert.True(Criar().CheckPath(@"C:\Windows\Temp\lixo.tmp", Array.Empty<string>()).Protegido);
+    }
+
+    [Fact]
+    public void Caminho_dentro_da_whitelist_e_liberado()
+    {
+        Assert.False(Criar().CheckPath(@"C:\Windows\Temp\lixo.tmp", new[] { @"C:\Windows\Temp" }).Protegido);
+    }
+
+    [Theory]
+    [InlineData(@"C:\Windows\Temp\projeto\.git\objects\abc")]
+    [InlineData(@"C:\Windows\Temp\jogo\saves\slot1.sav")]
+    [InlineData(@"C:\Windows\Temp\OneDrive\doc.txt")]
+    [InlineData(@"C:\Windows\Temp\Saved Games\jogo\save.dat")]
+    public void Segmento_proibido_bloqueia_mesmo_dentro_da_whitelist(string caminho)
+    {
+        var veredito = Criar().CheckPath(caminho, new[] { @"C:\Windows\Temp" });
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.SegmentoProibido, veredito.Motivo);
+    }
+
+    [Fact]
+    public void Travessia_de_diretorio_nao_escapa_da_whitelist()
+    {
+        var veredito = Criar().CheckPath(@"C:\Windows\Temp\..\System32\config\SAM", new[] { @"C:\Windows\Temp" });
+
+        Assert.True(veredito.Protegido);
+    }
+
+    [Fact]
+    public void Pasta_pessoal_do_usuario_e_bloqueada()
+    {
+        var documentos = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+        var alvo = Path.Combine(documentos, "planilha.xlsx");
+
+        // Whitelist larga de proposito: a protecao da pasta pessoal tem que valer mesmo assim.
+        var veredito = Criar().CheckPath(alvo, new[] { Path.GetPathRoot(documentos)! });
+
+        Assert.True(veredito.Protegido);
+        Assert.Equal(ProtectionReason.CaminhoDoUsuario, veredito.Motivo);
+    }
+}
diff --git a/GameBoost/src/GameBoost.Tests/SettingsTests.cs b/GameBoost/src/GameBoost.Tests/SettingsTests.cs
new file mode 100644
index 0000000..56a5b63
--- /dev/null
+++ b/GameBoost/src/GameBoost.Tests/SettingsTests.cs
@@ -0,0 +1,140 @@
+using System.Text.Json;
+using GameBoost.Core.Modules.GameMode;
+using GameBoost.Core.Settings;
+using Xunit;
+
+namespace GameBoost.Tests;
+
+public sealed class SettingsTests
+{
+    private readonly FakeFileSystem _fs = new();
+    private readonly FakeLogger _log = new();
+    private readonly AppPaths _paths = new(@"C:\dados\GameBoost", portatil: false);
+
+    [Fact]
+    public void Primeira_execucao_cria_settings_com_padroes()
+    {
+        var settings = new SettingsStore(_paths, _fs, _log).Load();
+
+        Assert.Equal(AppSettings.VersaoAtual, settings.SchemaVersion);
+        Assert.True(_fs.FileExists(_paths.SettingsFile));
+    }
+
+    [Fact]
+    public void Settings_da_v1_sem_schema_version_e_migrado_e_o_original_vira_bak()
+    {
+        // A v1 do GameBoost gravava o arquivo sem o campo schemaVersion.
+        _fs.WriteAllText(_paths.SettingsFile, """
+            { "tema": "Dark", "pausarWindowsUpdate": true }
+            """);
+
+        var settings = new SettingsStore(_paths, _fs, _log).Load();
+
+        Assert.Equal(AppSettings.VersaoAtual, settings.SchemaVersion);
+        Assert.True(_fs.FileExists(_paths.SettingsFile + ".bak"));
+        Assert.True(settings.PausarWindowsUpdate);
+    }
+
+    [Fact]
+    public void Json_corrompido_nao_derruba_o_app_e_preserva_o_original()
+    {
+        _fs.WriteAllText(_paths.SettingsFile, "{ isto nao e json");
+
+        var settings = new SettingsStore(_paths, _fs, _log).Load();
+
+        Assert.Equal(AppSettings.VersaoAtual, settings.SchemaVersion);
+        Assert.True(_fs.FileExists(_paths.SettingsFile + ".bak"));
+    }
+
+    [Fact]
+    public void Migracao_preenche_limites_zerados()
+    {
+        var antigo = new AppSettings { SchemaVersion = 1, LimiteCpuPercent = 0, LimiteRamMegabytes = 0 };
+
+        var migrado = SettingsMigrator.Migrar(antigo, _log);
+
+        Assert.Equal(AppSettings.VersaoAtual, migrado.SchemaVersion);
+        Assert.True(migrado.LimiteCpuPercent > 0);
+        Assert.True(migrado.LimiteRamMegabytes > 0);
+    }
+
+    [Fact]
+    public void Ida_e_volta_pelo_json_preserva_os_essenciais()
+    {
+        var original = new AppSettings
+        {
+            Essenciais = { new EssentialApp { Nome = "Discord", ExecutablePath = @"C:\d\Discord.exe", Argumentos = "--start-minimized" } },
+            NuncaEncerrar = { "obs64" }
+        };
+
+        var store = new SettingsStore(_paths, _fs, _log);
+        store.Save(original);
+        var lido = store.Load();
+
+        Assert.Equal("Discord", lido.Essenciais.Single().Nome);
+        Assert.Equal("--start-minimized", lido.Essenciais.Single().Argumentos);
+        Assert.Contains("obs64", lido.NuncaEncerrar);
+    }
+
+    [Fact]
+    public void Modo_portatil_usa_a_pasta_data_ao_lado_do_exe()
+    {
+        var portatil = new AppPaths(@"D:\GameBoost\data", portatil: true);
+
+        Assert.True(portatil.Portatil);
+        Assert.Equal(@"D:\GameBoost\data\settings.json", portatil.SettingsFile);
+    }
+}
+
+public sealed class GameSessionTests
+{
+    private readonly FakeFileSystem _fs = new();
+    private readonly FakeLogger _log = new();
+    private readonly AppPaths _paths = new(@"C:\dados\GameBoost", portatil: false);
+
+    [Fact]
+    public void Sessao_sobrevive_a_um_travamento()
+    {
+        var store = new SessionStore(_paths, _fs, _log);
+
+        store.Save(new GameSession
+        {
+            Ativo = true,
+            JogoDetectado = "cs2",
+            AppsEncerrados = { new ClosedApp { Nome = "chrome", ExecutablePath = @"C:\c\chrome.exe", Essencial = true } }
+        });
+
+        var relido = new SessionStore(_paths, _fs, _log).Load();
+
+        Assert.True(relido.Ativo);
+        Assert.Equal("cs2", relido.JogoDetectado);
+        Assert.True(relido.AppsEncerrados.Single().Essencial);
+    }
+
+    [Fact]
+    public void Session_json_ilegivel_vira_sessao_vazia_sem_excecao()
+    {
+        _fs.WriteAllText(_paths.SessionFile, "{{{");
+
+        var sessao = new SessionStore(_paths, _fs, _log).Load();
+
+        Assert.False(sessao.Ativo);
+        Assert.Empty(sessao.AppsEncerrados);
+    }
+
+    [Theory]
+    [InlineData(0L, "0 B")]
+    [InlineData(2048L, "2 KB")]
+    [InlineData(5L * 1024 * 1024, "5 MB")]
+    public void Formatacao_de_tamanho_e_legivel(long bytes, string esperado)
+    {
+        Assert.Equal(esperado, GameModeModule.Formatar(bytes));
+    }
+
+    [Fact]
+    public void Formatacao_de_gigabytes_usa_uma_casa_decimal()
+    {
+        Assert.StartsWith("1", GameModeModule.Formatar(1024L * 1024 * 1024));
+        Assert.EndsWith("GB", GameModeModule.Formatar(1024L * 1024 * 1024));
+    }
+}