Use `/doctor` quando a configuração parecer errada ou antes de ativar um provedor de LLM:```text
!decomp /doctor
!decomp /doctor:net

O caminho de comando normal realiza análise local, constrói fatos do analisador, opcionalmente chama o endpoint de LLM configurado, verifica a resposta contra as evidências recuperadas e imprime pseudo-C mais confiança, avisos e notas de incerteza:```text
!decomp ntdll!RtlAllocateHeap
!decomp kernel32!Sleep
!decomp game.exe!CheckIntegrity

- `brief` imprime alvo, confiança, resumo e a primeira incerteza ou aviso do verificador.
- `explain` adiciona seções de evidências, fluxo de controle, dica de tipo, comportamento observado e alvo de chamada.
- `json` imprime o JSON de requisição e resposta legível por máquina.
- `facts` imprime apenas os fatos do analisador e desativa o caminho do LLM.
- `prompt` imprime o prompt de sistema exato, o prompt do usuário e os fatos do prompt. Ele desativa a chamada do LLM.
- `data` imprime um snapshot JSON estável destinado à automação no estilo WinDbg JavaScript/NatVis.
- `analyzer` renderiza o caminho determinístico de pseudocódigo somente do analisador, sem chamar o LLM.
- `plan` executa análise local e imprime um plano de pré-execução sem chamar o LLM ou atualizar o cache de resultados. Inclui contagens de alvo/módulo/intervalo, disponibilidade de PDB, política de sessão, divisão em blocos estimada, contagens relevantes ao tamanho do prompt e recomendações práticas.

Use `/verbose` quando um comando parecer travado ou quando você quiser ver o fluxo completo de progresso:```text
!decomp /verbose module!SlowFunction
!decomp /verbose /view:json module!SlowFunction

- `/view:window` executa o caminho normal de resultado do `!decomp` para o alvo e abre o resultado totalmente renderizado em um visualizador separado.
- O visualizador usa o mesmo renderizador de respostas do caminho de console e, em seguida, abre uma janela de ferramenta nativa do Win32 não modal, de propriedade da janela do depurador quando uma puder ser encontrada.
- A saída do depurador informa o identificador da janela do visualizador nativo. Se a janela do visualizador não puder ser criada, o comando imprime um aviso e volta a usar o resultado normal do console.
- Links exclusivos em DML são renderizados como rótulos de texto com suas strings de comando no visualizador. Quando o RichEdit está disponível, a janela usa um layout RTF estilo GitHub com cabeçalhos de seção, estilo de metadados e realce de pseudocódigo; caso contrário, ela volta a usar texto simples.
- Quando a sessão atual tem resultados anteriores em cache, o visualizador mostra uma lista de histórico no lado esquerdo para que você possa alternar entre a saída atual e resultados de descompilação anteriores sem executar a análise novamente.
- `/view:json`, `/view:facts`, `/view:prompt` e `/view:data` permanecem como saídas de console legíveis por máquina e não são redirecionadas para o visualizador.

Funções grandes:```text
!decomp /limit:deep module!LargeFunction
!decomp /limit:huge module!VeryLargeFunction
!decomp /limit:12000 module!VeryLargeFunction
!decomp /timeout:120000 module!SlowFunction

- `/deobf:on` é o padrão. O analisador ainda emite fatos brutos, mas a recuperação de dispatcher estilo OLLVM de alta confiança, prova de arestas mortas opacas, idiomas de substituição e sobreposições semânticas de CFG podem orientar fatos de prompt, política de merge, política de conflito do verificador e recuperação estruturada de pseudo-C.
- `/deobf:off` mantém os fatos `obfuscation`, `semantic_control_flow` e `deobfuscation_readiness` visíveis, mas desativa ações seguras de reescrita, mantém a estruturação do fluxo de controle no CFG bruto e instrui os caminhos de prompt/merge/verificador a preservar a forma ofuscada bruta.
- Use `/deobf:off` quando quiser inspecionar o dispatcher, o ramo falso (bogus branch) ou a superfície de substituição diretamente, em vez de pedir à extensão para recuperar uma estrutura desofuscada.
- `/deobfuscation:on|off` é aceito como um alias mais longo.

Auxiliares de cache e replay:```text
!decomp /view:json module!FunctionName
!decomp /last:json
!decomp /view:explain module!FunctionName
!decomp /last:explain
!decomp /view:facts module!FunctionName
!decomp /last:facts
!decomp /view:data module!FunctionName
!decomp /last:data
!decomp /view:prompt module!FunctionName
!decomp /last:prompt
!decomp /history
!decomp /refresh module!FunctionName
!decomp /last:2:explain
!decomp /last:2:json

- `/fix:noreturn:name` trata chamadas correspondentes como sem retorno para desmontagem de fallback, recuperação de CFG, fatos de ABI e verificações do verificador.
- `/fix:type:expr=TYPE` adiciona uma dica de tipo de usuário de alta confiança.
- `/fix:field:expr=TYPE` adiciona uma dica de campo de usuário de alta confiança.
- `/fix:rename:old=new` adiciona uma dica de renomeação e aplica a renomeação aos identificadores finais do pseudocódigo.
- `/fix:clear` limpa todas as substituições de correção persistentes da sessão.

A variável de ambiente `DECOMP_NORETURN_OVERRIDES` continua suportada. Os valores de linha de comando `/fix:noreturn:` são sobrepostos ao valor original da variável de ambiente para a sessão atual do WinDbg.

Os comutadores de correção são persistentes na sessão:

- `/fix:noreturn:`, `/fix:type:`, `/fix:field:` e `/fix:rename:` são lembrados pela extensão carregada e reutilizados em execuções posteriores de `!decomp`.
- `/fix:clear` limpa todas as correções persistentes da sessão e restaura a substituição de ambiente para no-return ao seu valor original do momento em que a extensão foi carregada.
- Os comandos `/noreturn:`, `/type:`, `/field:`, `/rename:` e `/clear-overrides` legados continuam suportados.

Valores de correção malformados são ignorados e relatados em `uncertainties`, em vez de serem armazenados em cache. Por exemplo, `/fix:type:rcx` é ignorado porque não contém um par `expr=TYPE`.

Fluxo de trabalho recomendado para investigação:

1. Comece com `!decomp /view:facts target` para confirmar que o intervalo da função, blocos, chamadas, importações, dados PDB e fatos da sessão parecem razoáveis.
2. Use `!decomp /view:plan target` para estimar o particionamento, o tamanho do prompt, o risco de timeout e a qualidade dos símbolos antes de gastar uma solicitação de LLM.
3. Use `!decomp /view:prompt target` quando o tamanho do prompt, o idioma ou a seleção de evidências parecer incorreto.
4. Execute `!decomp target` para obter o resultado completo em pseudo-C verificado.
5. Use `!decomp /refresh target` quando um artefato persistente existente estiver sendo reproduzido, mas você precisar de uma análise nova.
6. Se o resultado parecer incorreto, execute `!decomp /view:explain target` e inspecione os avisos do verificador, a cobertura de evidências e as correções sugeridas.
7. Adicione correções direcionadas, como `/fix:noreturn:`, `/fix:type:`, `/fix:field:` ou `/fix:rename:`, e execute novamente o mesmo alvo.
8. Use `/history` e a reprodução indexada `/last:N:*` ao comparar vários resultados recentes.
9. Capture `/view:json` ou `/last:json` ao relatar bugs ou comparar o comportamento entre versões.

## Superfície de Fatos do Analisador

Os fatos recentes do analisador são intencionalmente transportados por `/view:json`, `/view:facts`, `/view:prompt` e pelo modo LLM normal. Campos de alto valor para inspecionar primeiro:

- `stack_pointer` registra deltas de pilha por instrução, aliases relativos ao frame e confiança.
- `call_arguments` registra argumentos de registro e pilha recuperados em locais de chamada, incluindo armazenamentos de pilha entre blocos próximos quando a evidência é forte o suficiente.
- `pdb.prototype_parameters` registra nomes de parâmetros de protótipo estruturado, tipos, ordinais, localizações de ABI e confiança da fonte.
- `control_flow` inclui variáveis de indução de loop, valores iniciais, passos, limites, direção, endereço da tabela de switch, alvos de caso, alvo padrão, limites de intervalo, sinalização e expressão de índice quando recuperados.
- `callee_summaries` e fatos de alvos de chamada incluem candidatos a chamadas diretas, indiretas e virtuais/vtable, além de semânticas conhecidas de memória, alocação, liberação e status do Win32/NT/Rtl.
- `obfuscation` expõe candidatos a dispatcher de achatamento (flattening) estilo OLLVM, variáveis de estado, arestas semânticas recuperadas, predicados opacos e idiomas de substituição escalar.
- `semantic_control_flow` expõe arestas vivas/mortas recuperadas que são derivadas de fatos de ofuscação e permanecem disponíveis para inspeção mesmo quando `/deobf:off` é usado.
- `deobfuscation_readiness` expõe `enabled`, ações de reescrita seguras, suposições bloqueadas, caminhos de fatos prioritários, contagens e confiança. Quando desabilitado, registra a decisão de política e bloqueia a reescrita do fluxo de controle desofuscado.
- A seleção de fatos do prompt classifica primeiro as entradas de alto sinal e depois preserva a distribuição com amostragem distribuída, para que funções grandes não percam todas as evidências de baixa frequência.

## Configuração Recomendada do dbgeng

O caminho mais rápido é incorporar (vendor) o cabeçalho e a biblioteca de importação ao projeto.
Layout de vendor esperado:```text
third_party\dbgeng\inc\dbgeng.h
third_party\dbgeng\lib\dbgeng.lib

### Prepare cópia do fornecedor a partir de caminhos de arquivo explícitos```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\Prepare-DbgengVendor.ps1 `
    -HeaderPath 'C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\sdk\inc\dbgeng.h' `
    -LibraryPath 'C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\dbgeng.lib'

Atualize ou crie a cópia do fornecedor:```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\Prepare-ZydisVendor.ps1

## Build

O caminho recomendado é um Visual Studio Developer PowerShell ou Developer Command Prompt.

O `decomp.dll` compilado agora incorpora uma versão de arquivo do Windows obtida de `version.txt`.
### Compilação normal```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\Build.ps1 -Reconfigure

`decomp_snapshot_tests` cobre os contratos do analisador/protocolo/verificador para argumentos de pilha recuperados, entradas de ABI SIMD/FP, supressão de zero-idiom vetorial, preferência de indução de loop, metadados de switch, metadados de chamada virtual, fatos de ofuscação no estilo OLLVM, política `/deobf:off`, resumos de API conhecidos, seleção de fatos para o prompt e verificações de fundamentação do verificador.

### Build legado do dbgeng```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\Build-Legacy.ps1 -Reconfigure

Este script incrementa o último componente em `version.txt` em `1`, força uma reconfiguração e então compila a DLL de Release. Por exemplo, `1.0.0.7` torna-se `1.0.0.8`.

### Opções comuns

- `-Configuration Release|Debug`
- `-Clean`
- `-Reconfigure`
- `-ConfigureOnly`
- `-Verbose`
- `-ZydisSource Auto|Vendor|Fetch`
- `-ZydisVendorDir 'C:\path\to\zydis'`
- `-DebuggersRoot 'C:\Program Files (x86)\Windows Kits\10\Debuggers\x64'`
- `-DbgengIncludeDir 'E:\works\windbg_llm_decomp_2\windbg_llm_decomp\third_party\dbgeng\inc'`
- `-DbgengLibrary 'E:\works\windbg_llm_decomp_2\windbg_llm_decomp\third_party\dbgeng\lib\dbgeng.lib'`

### Exemplo com prioridade para o fornecedor```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\Build.ps1 `
    -Configuration Release `
    -ZydisSource Vendor `
    -Reconfigure `
    -Verbose

O script de build tenta localizar automaticamente:

- `cmake.exe` a partir do PATH, do CMake autônomo ou do CMake incluído no Visual Studio
- `third_party\dbgeng` na raiz do projeto
- `DEBUGGERS_ROOT` a partir de variáveis de ambiente ou de locais comuns do Windows Kits

A seleção da fonte do Zydis funciona assim:

- `Auto`: prefere `third_party\zydis`; caso contrário, busca `Zydis` durante a configuração
- `Vendor`: exige uma árvore `third_party\zydis` utilizável ou o caminho passado por `-ZydisVendorDir`
- `Fetch`: ignora a árvore do vendor e sempre deixa o CMake baixar `Zydis`

`DEBUGGERS_ROOT` pode apontar para uma raiz de depurador que usa um destes layouts:

- `sdk\inc\dbgeng.h` e `sdk\lib\dbgeng.lib`
- `sdk\inc\dbgeng.h` e `sdk\lib\amd64\dbgeng.lib`
- `sdk\inc\dbgeng.h` e `sdk\lib\x64\dbgeng.lib`
- `sdk\inc\dbgeng.h` e `dbgeng.lib`
- `inc\dbgeng.h` e `lib\dbgeng.lib`
- `inc\dbgeng.h` e `lib\amd64\dbgeng.lib`
- `inc\dbgeng.h` e `lib\x64\dbgeng.lib`
- `dbgeng.h` e `dbgeng.lib`

Se a sua instalação não corresponder a esses layouts, passe os caminhos do CMake diretamente:```powershell
cmake -S . -B build-manual -G "Visual Studio 17 2022" -A x64 `
    -DDBGENG_INCLUDE_DIR='E:\works\windbg_llm_decomp_2\windbg_llm_decomp\third_party\dbgeng\inc' `
    -DDBGENG_LIBRARY='E:\works\windbg_llm_decomp_2\windbg_llm_decomp\third_party\dbgeng\lib\dbgeng.lib'
cmake --build build-manual --config Release

Exemplo de assinatura do ChatGPT:```json
{
  "provider": "chatgpt",
  "model": "gpt-5.5",
  "chatgpt_auth_file": "%USERPROFILE%\\.codex\\auth.json",
  "timeout_ms": 120000,
  "max_completion_tokens": 12000,
  "force_chunked": false,
  "chunk_trigger_instructions": 900,
  "chunk_trigger_blocks": 36,
  "chunk_block_limit": 24,
  "chunk_count_limit": 16,
  "chunk_completion_tokens": 6000,
  "merge_completion_tokens": 12000,
  "reasoning_effort": "medium"
}

Forçar inglês:```json
{
  "display_language": {
    "mode": "fixed",
    "tag": "en-US",
    "name": "English"
  }
}

Predefinição escura de realce de sintaxe:```json
{
  "syntax_highlighting": {
    "keyword_color": "warnfg",
    "type_color": "emphfg",
    "function_name_color": "srcid",
    "identifier_color": "wfg",
    "number_color": "changed",
    "string_color": "verbfg",
    "char_color": "srcchar",
    "comment_color": "subfg",
    "preprocessor_color": "normfg",
    "operator_color": "srcannot",
    "punctuation_color": "srcpair"
  }
}

Exemplo de detalhes da resposta `/view:json`:

- A resposta JSON inclui `pseudo_c` e `pseudo_c_tokens`.
- `pseudo_c_tokens` é um fluxo de tokens determinístico adequado para realce de sintaxe externo.
- A solicitação serializada inclui `preferred_natural_language_tag` e `preferred_natural_language_name`, que refletem o idioma de exibição resolvido após aplicar `display_language.mode`.
- Os fatos do analisador agora incluem campos de qualidade P0:
  `ir_values`, `block_value_states`, `control_flow` e `abi`.
- `ir_values` expõe IDs de valor semelhantes a SSA, locais de definição, alvos, expressões canônicas, links de uso, flags de constante/cópia e dicas de definição morta.
- `block_value_states` expõe definições de alcance live-in/live-out por bloco básico, valores canônicos, classe de armazenamento, estado de convergência e confiança.
- `stack_pointer` expõe deltas de pilha por instrução, aliases relativos ao frame, base/offsets brutos e confiança.
- `control_flow` expõe candidatos a região estruturada, como `natural_loop`, `if_else_candidate` e `switch_candidate`, com evidência de bloco, metadados de indução de loop, metadados de tabela/padrão/intervalo de switch, sinalização, expressões de índice e confiança.
- `abi` expõe suposições de shadow space do Microsoft x64, evidência de home slot, reconhecimento de frame/prólogo/epílogo, evidência de chamadas sem retorno, candidatos a tail call, candidatos a thunk, candidatos a wrapper de importação e argumentos de chamada recuperados de registradores e armazenamentos na pilha.
- Os fatos do analisador agora também incluem campos semânticos P1:
  `type_hints`, `idioms` e `callee_summaries`.
- `type_hints` expõe evidências de ponteiro, local, deslocamento de campo, semelhante a array, semelhante a enum, semelhante a bitflag e candidato a vtable, com fonte e confiança. Quando os dados de PDB estão disponíveis, parâmetros/locais com escopo, dicas de campo e constantes de enum também são promovidos para este fluxo unificado de dicas de tipo.
- `idioms` expõe substituições de nível superior para chamadas de auxiliares reconhecidas e padrões do compilador, como cópia/preenchimento de memória, cópia de string, verificações de cookie de segurança, sondas de pilha, auxiliares de alocação/liberação, inicializadores agregados e cargas globais/de importação relativas a RIP.
- `callee_summaries` expõe dicas de tipo de retorno, modelo de parâmetro, efeito colateral, efeito de memória, propriedade, fonte e confiança para chamados diretos e indiretos; alvos de chamada enriquecidos com símbolo/tipo substituem os resumos heurísticos iniciais quando o WinDbg consegue resolvê-los, e candidatos a chamadas virtuais incluem expressões de alvo e offsets de vtable quando recuperados.
- Os resumos conhecidos de APIs Win32/NT/Rtl descrevem cópia/preenchimento/zero de memória, alocação, liberação, status e comportamento de erro quando nomes de símbolo estão disponíveis.
- Os fatos do prompt incluem `analyzer_skeleton` e `graph_summary` para que o modelo refine um rascunho baseado em evidências em vez de começar de uma página em branco.
- `graph_summary` fornece bloco de entrada, regiões de fluxo de controle, condições normalizadas e blocos representativos de alto sinal com uma política explícita de truncamento. A seleção de fatos do prompt agora classifica entradas de alto sinal e usa amostragem distribuída para manter grandes conjuntos de fatos representativos.
- `evidence_graph` expõe nós de fato de alto sinal e arestas de proveniência para que valores de IR, estados de valor de bloco, acessos à memória, alvos de chamada, dicas de tipo, dicas de PDB e comportamento observado possam ser rastreados até evidências de instrução e bloco.
- `obfuscation`, `semantic_control_flow` e `deobfuscation_readiness` expõem fatos de recuperação no estilo OLLVM e se a orientação de reescrita de desofuscação está habilitada para o comando atual.
- A resposta do verificador inclui `warnings` legadas e entradas `issues` estruturadas. Cada issue carrega `severity`, `code`, `message` e `evidence` opcional para que ferramentas possam filtrar erros como `branch.true_target_not_successor` separadamente de avisos de menor risco.
- As verificações do verificador agora comparam alvos normalizados de desvio verdadeiro/falso com sucessores do CFG, comparam a densidade de desvios do pseudocódigo com desvios condicionais recuperados, cruzam resumos de chamados diretos com efeitos de chamada do pseudocódigo, validam o ancoramento de nós/arestas do grafo de evidências e verificam referências de estado de valor de bloco de volta para blocos e valores de IR recuperados.
- A saída normal e a de explain podem incluir uma seção concisa `suggested fixes`. Esses são comandos conservadores `/fix:*` derivados de issues do verificador, oportunidades de renomeação apoiadas por PDB ou hotspots de memória observados repetidamente. A saída compatível com DML renderiza sugestões imediatamente aplicáveis como links clicáveis de reexecução para o mesmo alvo; sugestões de tipo de campo com espaço reservado permanecem como texto simples até que `TYPE` seja substituído.
- No modo LLM, a extensão alimenta automaticamente os issues do verificador de volta em um prompt de nova tentativa. A nova tentativa é mantida quando preserva ou melhora a qualidade do verificador; caso contrário, a resposta original é mantida com uma nota de incerteza adicionada.
- `session_policy` e `observed_behavior` expõem contexto específico do WinDbg, como política live/dump/kernel/semelhante a TTD, amostras de argumentos de registro do frame atual, hotspots de memória e consultas de rastreamento sugeridas.
- A solicitação serializada agora também inclui um objeto `pdb` quando há dados de símbolo/tipo disponíveis.
- `pdb.availability` relata o nível de enriquecimento, como `none`, `symbols`, `typed` ou `scoped`.
- `pdb.params`, `pdb.locals`, `pdb.field_hints`, `pdb.enum_hints` e `pdb.source_locations` são destinados a dicas semânticas legíveis por máquina para ferramentas externas ou análise offline.

Substituições opcionais de ambiente:

- `DECOMP_LLM_PROVIDER`
- `DECOMP_LLM_ENDPOINT`
- `DECOMP_LLM_MODEL`
- `DECOMP_LLM_API_KEY`
- `OPENAI_API_KEY`
- `DECOMP_LLM_CHATGPT_ACCESS_TOKEN`
- `DECOMP_LLM_CODEX_ACCESS_TOKEN`
- `KERNFORGE_CODEX_ACCESS_TOKEN`
- `DECOMP_LLM_CHATGPT_AUTH_FILE`
- `DECOMP_LLM_CODEX_AUTH_FILE`
- `KERNFORGE_CODEX_AUTH_FILE`
- `DECOMP_LLM_REASONING_EFFORT`
- `DECOMP_LLM_TIMEOUT_MS`
- `DECOMP_LLM_MAX_COMPLETION_TOKENS`
- `DECOMP_LLM_FORCE_CHUNKED`
- `DECOMP_LLM_CHUNK_TRIGGER_INSTRUCTIONS`
- `DECOMP_LLM_CHUNK_TRIGGER_BLOCKS`
- `DECOMP_LLM_CHUNK_BLOCK_LIMIT`
- `DECOMP_LLM_CHUNK_COUNT_LIMIT`
- `DECOMP_LLM_CHUNK_COMPLETION_TOKENS`
- `DECOMP_LLM_MERGE_COMPLETION_TOKENS`
- `DECOMP_NORETURN_OVERRIDES`
  Fragmentos de nomes de função separados por vírgula ou ponto e vírgula tratados como alvos sem retorno durante a desmontagem de fallback, recuperação de sucessores do CFG, fatos de ABI e verificações do verificador. Exemplo: `DECOMP_NORETURN_OVERRIDES=MyAbort;PanicAndExit`.

Nota sobre prioridade à qualidade:

- A extensão agora suporta análise multi-passagem fragmentada para funções grandes.
- O analisador envia fatos de valor de IR, estados de valor de bloco, regiões de fluxo de controle, fatos do grafo de evidências e evidências de ABI/sem retorno x64 para o LLM antes do refinamento, de modo que `/view:analyzer`, `/view:json` e o modo LLM normal compartilham a mesma base de evidências P0.
- O verificador cruza loops, switch, sem retorno, alvos de desvio, comportamento de retorno, efeitos de chamada de chamados, ancoramento do grafo de evidências, consistência do estado de valor de bloco, cobertura de evidências e alegações suspeitas de identificadores com as evidências do analisador. Ele reduz a confiança quando uma prosa confiante ultrapassa os fatos recuperados e rotula cada issue com um par estável de severidade/código.
- Quando o feedback do verificador encontra erros de esquema, conflitos de fatos ou confiança ajustada muito baixa, o caminho do LLM realiza uma nova tentativa automática com os issues do verificador anexados ao prompt.
- Um bom ponto de partida para modelos em nuvem é `max_completion_tokens=12000`, `chunk_completion_tokens=6000` e `merge_completion_tokens=12000`, com `force_chunked=false` e gatilhos de fragmentação em torno de `900 instructions` ou `36 blocks`.
- Mantenha `force_chunked=true` apenas para testes de estresse do pipeline de fragmentação. A descompilação focada em qualidade de funções achatadas (flattened) ou com muitos dispatchers normalmente precisa de um único prompt até que a função seja grande o suficiente para exceder os gatilhos de fragmentação configurados.
- Mantenha `timeout_ms` alto para modelos em nuvem. `120000` é um ponto de partida mais seguro do que `15000`.
- Se a qualidade ainda estiver fraca em funções enormes, aumente `chunk_count_limit` antes de reduzir `/limit:N`.
- Se nenhum endpoint estiver configurado, a extensão usa o provedor mock determinístico como fallback.
- Mesmo quando a extensão está usando `/view:analyzer` ou o provedor mock, `display_language` e `syntax_highlighting` ainda afetam o que o usuário vê.

## Teste de Fumaça do WinDbg

1. Compile com `Build.ps1` ou `Build-Legacy.ps1`.
2. Coloque `decomp.llm.json` ao lado do `decomp.dll` compilado.
3. Inicie o WinDbg. As variáveis de ambiente são apenas substituições opcionais.
4. Carregue a extensão.
5. Valide o modo somente analisador antes de habilitar o caminho do LLM.```text
.load C:\path\to\decomp.dll
!decomp /view:analyzer ntdll!RtlAllocateHeap
!decomp /view:facts kernel32!Sleep

- `target`, `entry` e `module` devem resolver de forma consistente
- `regions` deve ser diferente de zero para funções normais
- `/view:analyzer` ainda deve imprimir a confiança do analyzer e o stub do pseudocódigo
- O modo LLM deve preencher `summary`, `pseudo_c`, `pseudo_c_tokens` e `verified`
- a saída de `/view:json` deve incluir `preferred_natural_language_tag` e `preferred_natural_language_name` no request serializado
- quando PDBs privados ou ricos estiverem carregados, `/view:json` também deve incluir `pdb.prototype`, `pdb.params` e possivelmente `pdb.locals`
- para structs e enums tipados, `/view:json` pode incluir `pdb.field_hints` e `pdb.enum_hints`

## Exemplo de Assinatura do ChatGPT```powershell
$env:DECOMP_LLM_PROVIDER = "chatgpt"
$env:DECOMP_LLM_MODEL = "gpt-5.5"
$env:DECOMP_LLM_CHATGPT_AUTH_FILE = "$env:USERPROFILE\.codex\auth.json"
$env:DECOMP_LLM_TIMEOUT_MS = "120000"

### LM Studio```powershell
$env:DECOMP_LLM_ENDPOINT = "http://127.0.0.1:1234/v1/chat/completions"
$env:DECOMP_LLM_MODEL = "local-model"
$env:DECOMP_LLM_API_KEY = "lm-studio"