kunglao-agent

kunglao-agent é um sistema autônomo de engenharia reversa. Você entrega um alvo e as perguntas que precisa responder; ele trabalha o problema por horas ou dias sozinho — planejando seu próprio caminho, recuperando-se de mortes de workers, retomando após crashes — e só converge quando cada resposta é derivada de evidência bruta e sobrevive a portões de verificação mecânica.

English · Simplified Chinese

Atualmente é distribuído como um plugin do Claude Code — o Claude Code é a interface com a qual você conversa, não o que o produto é. O produto é o loop: workers especialistas analisam (estático primeiro), um verificador independente re-deriva cada fato às cegas a partir da evidência bruta, e portões mecânicos decidem quando o trabalho está concluído. O entregável é uma base de fatos onde cada afirmação é ancorada em bytes, verificada independentemente e indexada por evidência — a confiança é imposta por maquinário, não por convenção.

Por que kunglao-agent

Longo horizonte por design. Os engajamentos rodam sem supervisão por horas e dias: um heartbeat agendado mantém o loop vivo, workers mortos são reconciliados e suas afirmações re-enfileiradas, crashes retomam a partir do estado em disco, afirmações bloqueadas se auto-recuperam. Você lê o veredito quando ele converge — você não fica de babá em cada passo. Veja Long-horizon autonomy.
Respostas em que você pode confiar. Nenhum fato é PROVEN até que um verificador independente o re-derive às cegas a partir do artefato bruto; cada fato cita um artefato bruto indexado por sha256 através de evidence/_index.json.
O espectro completo de engenharia reversa. Binários nativos Windows/Linux, APKs Android, web/JS, análise de protocolo, emulação de firmware, contramedidas de controle de risco — um sistema, não uma ferramenta de domínio único.
Economia estático-primeiro. Uma tarefa que se encerra estaticamente nunca toca ferramentas dinâmicas; cada escalonamento é declarado, controlado por portão e auditado.
Ele reutiliza conhecimento em vez de re-derivá-lo. Um catálogo crescente de ferramentas de análise registradas (decodificadores de cripto, pipelines de desmontagem, consultas de grafo) significa que o sistema recorre a ferramentas comprovadas antes de escrever scripts pontuais — e cada execução deixa para trás fatos reutilizáveis, não uma transcrição de chat que evapora.
Ele se recupera em vez de morrer. Mortes de workers, desconexões de API e crashes são eventos de primeira classe: o loop os detecta, tira snapshots do que já foi produzido e re-despacha para continuar de onde as coisas pararam — não do zero.
Seu ambiente, suas regras. VMware, ssh, docker, adb ou apenas estático puro — o sistema conduz qualquer canal de execução que você já tenha. Nada é um modo degradado; uma tarefa que nunca precisa de execução nunca pede uma VM.

Início rápido

kunglao-agent roda dentro do Claude Code. De uma amostra em disco até um veredito:

1. Instale o plugin

De qualquer diretório, no Claude Code:``` /plugin marketplace add amd2g2zz/kunglao-agent /plugin install kunglao-agent@kunglao-agent

(Alternativa: `claude --plugin-dir /path/to/kunglao-agent` para desenvolvimento.)

### 2. Inicializar um workspace```
/kunglao-agent:init ~/cases/synth-dropper --type windows

kunglao-init prepara o workspace, escreve CLAUDE.md, verifica o toolchain para o seu --type e prepara o .mcp.json. Ele rejeita de forma RÍGIDA quando uma ferramenta necessária para o seu tipo está ausente — a orientação de correção está no bloco de erro.

3. Declare a tarefa e inicie a análise```

/kunglao-agent:analysis ~/cases/synth-dropper

Goal: confirm this dropper's persistence mechanism and network endpoints; every conclusion must be reproducible from raw evidence. Verification: key findings count only if an independent verifier re-derives them blind and reaches the same answer. Constraints: static-first; never execute the sample on the host.

Escreva o briefing de modo que um revisor independente possa julgar o resultado: **objetivo da análise** (o que você precisa saber), **lógica de verificação** (o que torna uma resposta confiável — por exemplo, "a assinatura deve ser reproduzível a partir das mesmas entradas"), **restrições** (por exemplo, "sem execução no host"). Tudo é registrado em `task_spec.yaml`; a partir daí, o loop se conduz sozinho. Para saber como os pedidos comuns se transformam em declarações bem formuladas, consulte [Como declarar a tarefa](#how-to-state-the-task).

### 4. Leia o entregável```
claim-register.yaml   # every claim terminal, with verifier sign-off
facts/F<NNN>.md       # byte-anchored, reproducible, frontmatter contract
evidence/_index.json  # every fact → raw artifact (sha256 + path)
runs/                 # session audit trail

Como declarar a tarefa

O loop deriva seu critério de conclusão — o oracle — mecanicamente a partir do estado final que você declara. Uma declaração vaga produz um oracle vago, e a análise desvia para o que quer que possa ser provado em vez do que você precisava. Quatro formulações cobrem a maior parte desse desvio. Para cada uma: o que os usuários dizem, o que isso geralmente significa, uma declaração bem formulada e no que o oracle se ancora.

"我要纯算" — "apenas o algoritmo puro"

Geralmente significa: reprodução offline da rotina de assinatura/criptografia do app — um harness unidbg ou uma reescrita que roda sem dispositivo e sem app em tempo de execução. Não é "analisar o app"; o app é apenas onde o algoritmo vive.```

Sample: the v7.2 APK; behavior: the signer producing the sign header on api.example.com/v2/* requests. Criterion: a standalone reproduction (unidbg or rewrite) replays every captured (input → sign) pair byte-exact — including the withheld pairs — with no device or app at run time. Attach: captures/sign-pairs.jsonl — 20 input/output pairs captured from a live session; 10 of them withheld from the analysis.

**Âncoras do Oracle em:** replay byte a byte em cada par, incluindo os retidos — e a reprodução a correr de forma autónoma.

### "我要解密" — "Quero desencriptação"

**Normalmente significa um de dois alvos diferentes — diga qual:**

- **(a) desencriptar um corpo capturado** — uma resposta pontual sobre estes dados: "produzir o texto simples deste ficheiro de cache capturado."
- **(b) uma capacidade de desencriptação** — algoritmo + recuperação de chave, reutilizável em dados que capture amanhã.

Bem formulado (a):```
> Sample: the v7.2 APK; behavior: the local config cache
>   files/.cfg/v2.dat is encrypted at rest.
> Criterion: produce the plaintext of the captured v2.dat and validate
>   it against what the app renders (field names and values match the
>   screenshot captured alongside).

Bem formado (b):```

Sample: the v7.2 APK; behavior: request bodies on api.example.com/v2/* are encrypted with a static key. Criterion: identify the algorithm and the key, then run a canary round-trip — encrypt a known plaintext with the recovered key and match the ciphertext the device produced, byte for byte. Attach: captures/request-bodies.jsonl — ciphertext bodies captured from the device, with the requests that produced them.

**Âncoras do oráculo:** (a) o texto simples validando contra o que a aplicação renderiza; (b) algoritmo + chave identificados e o canary round-trip byte-idêntico ao ciphertext produzido pelo dispositivo. "Descriptografou uma vez" não satisfaz nenhum dos dois.

### "帮我分析这个协议" — "analise este protocolo para mim"

**Geralmente significa:** recuperação do formato de transmissão — enquadramento, semântica de campos e um codec que você possa executar.```
> Sample: the Android chat app; behavior: the TCP protocol on
>   gateway.example.com:443, as captured in gateway-session.pcap.
> Criterion: a codec that round-trips every captured frame byte-exact,
>   and decodes the held-out frame to fields matching the observed app
>   behavior.
> Attach: captures/gateway-session.pcap — 40 frames, plus 1 held-out
>   frame kept out of the analysis.

Oracle ancora em: o codec fazendo round-trip de cada frame capturado byte a byte exato, e o frame mantido de fora decodificando para campos que correspondem ao comportamento observado do app.

"这个 sign 在哪算的" — "onde esse sign é calculado?"

Geralmente significa: um local com prova. Nomear um ponto no código é barato; a resposta só é útil com evidência de que esse ponto é o ponto.```

Sample: the v7.2 APK; behavior: the sign header attached to every request. Criterion: name the class/method (or native function) where sign is computed, and hook that point to reproduce the captured sign values from the same inputs. Attach: captures/sign-session.jsonl — captured sign values with their request inputs.

**Âncoras do oráculo:** uma classe/método/função nativa nomeada, mais um hook nesse ponto reproduzindo os valores capturados.

### O que estes têm em comum

- **Nomeie a amostra e o comportamento** — qual parâmetro, entrada ou fluxo — não a categoria. "我要纯算" é uma categoria; "o assinador que produz o cabeçalho `sign` em api.example.com/v2/*" é um alvo.
- **O sucesso tem de ser dados.** Anexe pares de entrada/saída capturados; os pares retidos são o que torna a verificação honesta — uma reprodução não consegue sobreajustar-se a dados que nunca viu.
- **O oráculo é derivado do estado final que declarou.** Declaração vaga, verificação vaga, análise à deriva.
- **As restrições alteram o plano.** Apenas estático? Um dispositivo disponível? Que canal? Diga-o desde o início — decide a rota antes de o trabalho começar (ver [Traga o seu próprio ambiente](#bring-your-own-environment)).

## Subcomandos

| Comando | Usar quando | O que faz |
|---|---|---|
| `/kunglao-agent:init <workspace> [--type windows\|linux\|android\|web\|macos] [--lane malware\|algorithm\|protocol\|web\|data\|app]` | iniciar um engagement, primeiro | cria a estrutura do workspace, sonda a toolchain para o tipo, escreve `CLAUDE.md` e `.mcp.json`; rejeita de forma RÍGIDA com orientação de correção quando falta uma ferramenta necessária |
| `/kunglao-agent:analysis <workspace>` (alias `analyze`) | após o init — declare a tarefa e comece | recolhe o seu objetivo / lógica de verificação / restrições uma vez, depois executa o ciclo de convergência: ciclos de dispatch / verify até ao relatório |
| `/kunglao-agent:resume <workspace>` | após um crash, reinício, ou qualquer "onde é que eu estava?" | resumo de breakpoint apenas de leitura (saúde, claims abertas, workers em curso, cronologia do crash) mais a próxima ação da máquina de estados |
| `/kunglao-agent:upgrade <workspace> [--dry-run]` | após uma atualização do plugin, num workspace mais antigo (ou quando o prompt de upgrade diz que o stamp está desatualizado) | migra a estrutura do workspace (hooks, templates, vocabulário de eventos) para a versão atual do plugin; `--dry-run` pré-visualiza; os dados do utilizador (claims, facts, evidence) nunca são tocados — desvio de bytes recusa com RC=4 |
| `/kunglao-agent:help` | qualquer outra coisa | imprime a lista de utilização |

Ordem típica: `init` cria o workspace → `analysis` declara a tarefa e começa → (`resume` se algo correr mal) → ler o relatório na convergência → `upgrade` nos workspaces antigos após atualizações do plugin.

## Como é uma execução

*A forma de um engagement — o que escreve, o que recebe de volta, onde procurar.* Um exemplo sintético: um pequeno dropper Windows aterra em `~/cases/synth-dropper`:```bash
/kunglao-agent:init ~/cases/synth-dropper --type windows   # probes Ghidra, VM reachability
/kunglao-agent:analysis ~/cases/synth-dropper
> "What does this binary do, and where does it phone home?"

A partir daí, o loop se executa sozinho — a rota se adapta ao que a amostra se revela ser. Você pode se afastar (veja Long-horizon autonomy). Quando convergir, leia o entregável abaixo.

Cenários

Mais dois caminhos ponta a ponta — escolha o que corresponde ao seu alvo (para um binário Windows PE / Linux ELF comum, o caso prático acima é o caminho).

Android APK — o que o usuário digita, o que chega onde

```bash /kunglao-agent:init ~/cases/sample.apk --type android /kunglao-agent:analysis ~/cases/sample.apk > "Does this APK load code dynamically or fight debugging? If so, where is > the hidden logic and what does it do?" ``` - **Lands in:** `bins/` (o APK), `facts/` (grafo de classes, inventário de `.so` nativos), `evidence/` (capturas, dumps). - **Done looks like:** toda pergunta respaldada por evidência reproduzível. - **The route adapts.** Alguns APKs encerram com trabalho puramente estático de DEX; outros precisam de depuração no dispositivo — o loop decide a partir do que a amostra realmente é.

Web / JS — unpack → deobfuscate → signed-parameter replay

```bash /kunglao-agent:init ~/cases/example-site.com --type web /kunglao-agent:analysis ~/cases/example-site.com > "how is the XHR request signed, and where does the nonce come from?" ``` - **Fica em:** `evidence/` (capturas, código desofuscado), `facts/` (chave de assinatura, derivação de nonce). - **Nota:** `web` é um alvo em estágio beta — a fasquia do toolchain é deliberadamente leve; a capacidade em falta surge quando o loop realmente precisa dela, não no init.

O que obtém

Um registo de afirmações e uma base de factos onde a confiança é mecânica, não convencional:

Convergência verificada — PROVEN exige a aprovação por correspondência exata de um verificador cego independente; CONVERGED exige que todas as questões primárias sejam respondidas com prova byte a byte, zero afirmações órfãs, sem spinning.
Integridade da evidência — cada facto remonta através de evidence/_index.json a um artefacto em bruto (captura / trace / dump / binário). Os resumos derivados são excluídos por design.
Maker-checker — o worker (maker) escreve factos; o verificador redteam (checker) re-deriva-os cegamente. Agentes diferentes, sempre.

Nenhuma afirmação atinge PROVEN com base na palavra do seu autor: um verificador independente tem de a re-derivar cegamente, e um conjunto de portões mecânicos tem de passar. O design completo dos portões está em docs/design/loop-engineering.md.

Após a execução, os ficheiros respondem a diferentes perguntas:

Exemplo de facto:```yaml id: F061 status: VERIFIED-BY-W01-static-byte-recheck claim_id: C-401 provenance:

{role: sample, path: bins/}
{role: capture_log, path: runs/c329-inner-pe.bin} # via evidence/_index.json reproduce: python -c "import struct; ..." # runs against the cited artifact verifier_sign_off: {verifier: kunglao-redteam, verdict: CONFIRMED}

## Autonomia de longo horizonte

Engajamentos reais não são um chat de vinte minutos. O kunglao-agent permanece no problema sem que um humano conduza cada passo:

- **Executa por horas ou dias, sem supervisão** — um heartbeat agendado mantém o loop funcionando entre as suas visitas, e um loop travado é sinalizado em vez de morrer silenciosamente.
- **Recupera-se de falhas** — workers mortos ou travados são substituídos e suas perguntas são reenfileiradas; trabalho bloqueado se autorrecupera em vez de ficar ocioso.
- **Sobrevive a crashes e reinicializações** — `/kunglao-agent:resume <workspace>` reconstrói onde as coisas estavam a partir do estado em disco e nomeia a próxima ação.
- **Lembra em disco, não no chat** — claims, fatos, evidências e uma trilha de auditoria completa vivem no workspace, então qualquer sessão pode retomar o engajamento.

Você dá a ele um alvo e as perguntas; ele trabalha o problema por horas ou dias, recupera-se de falhas, e você lê o veredito quando ele converge.

## Obtendo bons resultados

- **Alimente-o com alvos acessíveis estaticamente.** O loop é static-first: um APK desempacotado, um bundle não ofuscado ou um binário não stripped converge muito mais rápido do que um que força trabalho dinâmico.
- **Configure a perna dinâmica antes de precisar dela.** Se suas perguntas principais exigirem execução, escolha um canal primeiro (veja [Traga seu próprio ambiente](#bring-your-own-environment)) — o init rejeita HARD uma tarefa dinâmica em `local`.
- **Distinguir "trabalhando" de "travado"** — entradas novas em `runs/` significam que o loop está vivo; um heartbeat morto ou a mesma decisão se repetindo sem novos fatos significa que não está — `/kunglao-agent:resume <workspace>` diagnostica e nomeia o próximo movimento.

## Toolchain por alvo

O `--type` que você escolhe no init trava quais ferramentas de nível HARD devem estar instaladas. A orientação está recolhida — expanda o seu alvo. **Todos os tipos exigem dois servidores MCP:** `ghidra` (`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`) e `sequential-thinking` (`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`).

<details>
<summary><strong>windows (PE32+ x86-64)</strong> — binários nativos do Windows</summary>

| Tier | Ferramenta | Instalação |
|---|---|---|
| HARD | `pefile` (Python) | `pip install pefile` |
| HARD | `die` (Detect It Easy) | env `KUNGLAO_DIE` ou no PATH — [ntinfo.com](https://ntinfo.com) |
| HARD | `floss` (FLARE FLOSS) | conforme [flare-floss docs](https://github.com/mandiant/flare-floss) |
| HARD | Ghidra ou IDA | um deles; veja [Internals](#internals) |
| HARD (T2/T3) | VMware + vmr-shell, ou um canal ssh/docker | veja [Traga seu próprio ambiente](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (renomeado, porta customizada) | binário do lado do device/VM, porta padrão 1337 |

O T3 dinâmico do Windows também usa o MCP `x64dbg`; `volatility` (forense de memória) e o MCP IDA-Pro são opcionais — veja o manifesto MCP em [Internals](#internals).

</details>

<details>
<summary><strong>linux (ELF)</strong> — binários nativos Linux / firmware / imagens de memória</summary>

| Tier | Ferramenta | Instalação |
|---|---|---|
| HARD | `file`, `readelf`, `objdump` | pacote `binutils` |
| HARD | Ghidra ou IDA | um deles |
| HARD (T2/T3) | VMware + vmr-shell, ou um plano de controle ssh/docker | veja [Traga seu próprio ambiente](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (renomeado, porta customizada) | binário do lado do device, porta 1337 |
| WARN | `gdbserver` (PATH do host), `strace`, `ltrace` | extras opcionais |

`ssh-mcp` habilita o plano de controle ssh para hosts remotos / cloud / docker.

</details>

<details>
<summary><strong>android (APK / DEX / .so nativo)</strong> — o tipo de alvo mais difícil, mais itens HARD</summary>

| Tier | Ferramenta | Instalação |
|---|---|---|
| HARD | `aapt` ou `aapt2` (ou fallback `unzip`) | Android SDK build-tools |
| HARD | `jadx` (DEX → decompilador Java) | [skylot/jadx](https://github.com/skylot/jadx) |
| HARD | `apktool` (decode/rebuild de recursos APK) | [iBotPeaches/Apktool](https://github.com/iBotPeaches/Apktool) |
| HARD | `gitnexus` (grafo pós-decompilação) | `npm i -g gitnexus` |
| HARD | Ghidra ou IDA | apenas se o APK contiver `.so` nativo |
| HARD | `adb` + **um dispositivo com root** com `ro.debuggable=1` | platform-tools + frida customizado no dispositivo |
| HARD | `frida-server` (renomeado, porta customizada 1337) | binário do lado do device |
| HARD | `android_server` (depuração remota IDA) | binário do lado do device, porta 23946 |
| WARN | `apkid` | `pip install apkid` |
| WARN | `baksmali` | de [smali releases](https://github.com/baksmali/smali/releases) |

</details>

<details>
<summary><strong>web &amp; macos (beta)</strong> — toolchains mínimas, sem itens HARD por design</summary>

| Tier | Ferramenta | Instalação |
|---|---|---|
| WARN | MCP `camoufox-reverse` (web) | Firefox anti-detect para hook / trace / captura de rede |
| WARN | `docker` (padrão do canal web) | Docker Desktop, ou defina `KUNGLAO_CHANNEL=ssh` explicitamente |
| WARN | `lipo`, `otool`, `nm`, `codesign`, `xattr` (macOS) | Xcode Command Line Tools |
| WARN | MCP `ghidra` (macOS) | recomendado — veja o manifesto em [Internals](#internals) |

Ambos são alvos em estágio beta: capacidade ausente surge quando o loop realmente precisa dela, não no init. O trabalho dinâmico no macOS usa o canal `ssh` (para um host Mac); para o caminho opcional de depuração de browser via x64dbg, instale a toolchain do Windows acima.

</details>

Fonte única de manifesto para tudo acima — faça o probe a qualquer momento: `python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos>` (exit 1 = HARD ausente).

## Traga seu próprio ambiente

A depuração dinâmica precisa de um plano de controle de execução que o agente possa dirigir. `KUNGLAO_CHANNEL` seleciona um de cinco canais de primeira classe — use o que seu ambiente já tem; nenhum é um modo degradado:

| Canal | O que ele dirige | Pré-requisitos |
|---|---|---|
| `vmr` (padrão) | VM VMware, **qualquer SO guest** — fluxos de snapshot/revert são seu valor insubstituível | skill vmr-shell; `KUNGLAO_VM_HOST` + portas 9876/1337 |
| `ssh` | Qualquer máquina alcançável por ssh: bare metal, VM na cloud, Mac, host docker remoto | autenticação por chave — o probe executa um `ssh ... true` real em BatchMode |
| `docker` | Daemon docker local ou remoto — `docker exec` é equivalente a qualquer caminho de controle | `docker version` verde; `KUNGLAO_DOCKER_CONTAINER` opcional |
| `adb` | Emulador Android ou dispositivo real | `adb devices` mostra ele; `adb forward tcp:1337 tcp:1337` para frida |
| `local` | **Análise somente estática no host** | nenhum — veja a linha vermelha |

> **Linha vermelha do `local`:** local é para trabalho **estático** apenas — nunca execute, depure ou injete a amostra no host. Qualquer requisito dinâmico muda `KUNGLAO_CHANNEL` para `vmr`/`ssh`/`docker`/`adb`; o init rejeita HARD uma tarefa dinâmica em `local`.

Os probes de canal rodam apenas para tarefas dinâmicas (tarefas somente estáticas os pulam). A execução pelo canal `ssh` flui através do plano de controle **ssh-mcp** (`npm i -g ssh-mcp`); ssh via CLI puro é o fallback. Para docker remoto sobre ssh, defina `KUNGLAO_DOCKER_CONTAINER`.

## Configuração

Quatro variáveis cobrem a maioria das configurações:

| Variável | Padrão | Significado |
|---|---|---|
| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | não definida | deve permanecer não definida ou `0` — valores truthy roteiam dispatches pelo canal de teammate e são rejeitados |
| `KUNGLAO_CHANNEL` | `vmr` | plano de controle de execução dinâmica: `vmr` \| `ssh` \| `docker` \| `adb` \| `local` — veja [Traga seu próprio ambiente](#bring-your-own-environment) |
| `KUNGLAO_VM_HOST` | não definida | VM/host para análise dinâmica (vmr-shell :9876, Frida :1337) |
| `GHIDRA_HOME` | não definida | raiz de instalação do Ghidra (deve conter `support/analyzeHeadless.bat`) |

Raramente necessárias: `KUNGLAO_DOCKER_CONTAINER` (alvo de execução docker para os canais `ssh`/`docker`), `KUNGLAO_FRIDA_PORT` (padrão 1337), `KUNGLAO_DIE` (caminho do DIE, recorre ao PATH), `KUNGLAO_CLAUDE_JSON` (override de teste para o registro MCP de nível de usuário).

## Segurança

- Amostras nunca executam no host — o hook `block_malware_exec` impõe isso; trabalho dinâmico roda apenas em VM/container/device e exige autorização por sessão.
- Hierarquia de ground truth: artefato bruto > ferramenta local > sandbox > threat intel (CTI é uma hipótese falseável, nunca verdade).
- Maker-checker: um worker nunca se autoverifica; um verificador nunca lê a conclusão do maker.
- Bins, settings e hooks nunca são commitados; segredos são excluídos dos workspaces e do repositório.

## Desenvolvimento

Contribuições são bem-vindas. Fluxo de trabalho: branch a partir de `dev`, um branch por mudança, PR de volta para `dev`.```bash
git worktree add .worktrees/<name> -b <name> dev
uv sync --locked
uv run python -m pytest -q
gh pr create --base dev

A entrada autoritativa da suíte completa é python -m pytest -q (ver .github/workflows/release-check.yml).

A documentação de design está em docs/ e specs/. Ver Licença.

Internos

Fornecimento MCP (o manifesto completo)

Fonte única de verdade: scripts/mcp_probe.py; kunglao-init cria um workspace .mcp.json quando ausente (--no-mcp ignora; um ficheiro existente nunca é sobrescrito). Sonda: python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos> — saída 1 = HARD em falta, 2 = apenas WARN em falta.

Layout do workspace

Um workspace por compromisso de amostra:

``` / ├── bins/ # the sample (gitignored) ├── task_spec.yaml # primary_questions / scope / constraints / success_criteria ├── claim-register.yaml # claims C-NN with status (OPEN/PROVEN/STAMP/...) ├── claim_deps.yaml # claim DAG ├── facts/ # byte-anchored facts F-NNN.md + _INDEX.md ├── evidence/ # raw artifacts + _index.json (eid → path + sha256) ├── runs/ # worker-status, plans, ledgers, .heartbeat.json ├── blockers/ # failure-attribution records per claim └── CLAUDE.md # workspace rules, generated by kunglao-init ``` hooks do kunglao são configurados no nível do workspace; seu `~/.claude/settings.json` global nunca é escrito.

Licença

Licenciamento duplo: AGPL-3.0 para uso pessoal, acadêmico e interno (gratuito — consulte LICENSE); uma licença comercial é necessária para uso comercial de código fechado ou SaaS — consulte LICENSE-commercial.md.

Claude Code	onde o kunglao-agent roda	conforme docs da Anthropic
Python 3.10+ (Python 2 não é suportado)	o plugin carrega um env fixado via `uv`; você não o toca	sistema ou gerenciado por `uv`
`uv`	resolvedor de env com lock	`pip install uv` ou astral.sh/uv
Ghidra ou IDA	uma suíte de análise estática para descompilação	veja Toolchain by target

Está feito?	o código de saída do loop — `CONVERGED` (0) significa que todas as questões primárias têm uma resposta verificada; estado por afirmação em `claim-register.yaml`
O que encontrou?	`facts/F<NNN>.md` — um facto ancorado em bytes por ficheiro, mapeado para afirmações por `claim-register.yaml`
Como o reproduzo?	`evidence/_index.json` — facto → artefacto em bruto (caminho + sha256); cada facto transporta um comando `reproduce:`
O que aconteceu exatamente?	`runs/` — o registo tick a tick e o estado do worker

`ghidra`	HARD	obrigatório, todos os tipos	descompilação / análise estática	`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`
`sequential-thinking`	HARD	obrigatório, todos os tipos	raciocínio estruturado	`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`
`x64dbg`	HARD	Windows T3 dinâmico	depuração dinâmica (VM remota)	`claude mcp add x64dbg -- x64dbg-automate-mcp`
`volatility`	WARN	Windows T3	forense de memória	`claude mcp add volatility -- python <path>/volatility_mcp_server.py`
`ida-pro-vm`	WARN	quando IDA escolhido	análise remota IDA	`claude mcp add --transport http ida-pro-vm <ida-mcp-url>`
`gitnexus`	HARD	construção de grafo Android	grafo de conhecimento pós-descompilação	`claude mcp add gitnexus -- gitnexus mcp`
`virustotal`	WARN	CTI	threat intel (hipóteses de atribuição de família)	`claude mcp add virustotal -- npx -y @burtthecoder/mcp-virustotal`
`ssh-mcp`	WARN	canal	plano de controlo de execução ssh	`claude mcp add ssh-mcp -- ssh-mcp`
`camoufox-reverse`	WARN	web (beta)	engenharia reversa de JS no browser (hooks / trace / captura de rede)	`claude mcp add camoufox-reverse -- python -m camoufox_reverse_mcp`

Mais Populares

kunglao-agent

kunglao-agent

Por que kunglao-agent

Início rápido

1. Instale o plugin

3. Declare a tarefa e inicie a análise```

Como declarar a tarefa

"我要纯算" — "apenas o algoritmo puro"

"这个 sign 在哪算的" — "onde esse sign é calculado?"

Cenários

O que obtém

Internos

Licença