kunglao-agent

kunglao-agent è un sistema autonomo di reverse engineering. Gli si fornisce un target e le domande a cui si vuole risposta; lavora al problema per ore o giorni in autonomia — pianificando il proprio percorso, riprendendosi dalla morte dei worker, riprendendo dopo i crash — e converge solo quando ogni risposta è derivata da evidenze grezze e supera i gate di verifica meccanica.

English · Simplified Chinese

Attualmente viene distribuito come plugin di Claude Code — Claude Code è l'interfaccia con cui si parla, non ciò che il prodotto è. Il prodotto è il loop: worker specializzati analizzano (prima staticamente), un verificatore indipendente ri-deriva ogni fatto alla cieca dalle evidenze grezze, e gate meccanici decidono quando il lavoro è concluso. Il risultato è una base di fatti in cui ogni affermazione è ancorata a livello di byte, verificata in modo indipendente e indicizzata per evidenza — la fiducia è imposta dalla macchina, non dalla convenzione.

Perché kunglao-agent

Long-horizon by design. Gli ingaggi procedono senza supervisione per ore e giorni: un heartbeat pianificato mantiene vivo il loop, i worker morti vengono riconciliati e le loro affermazioni rimesse in coda, i crash riprendono dallo stato su disco, le affermazioni bloccate si auto-recuperano. Si legge il verdetto quando converge — non si sorveglia ogni passo. Vedi Long-horizon autonomy.
Risposte di cui ci si può fidare. Nessun fatto è PROVEN finché un verificatore indipendente non lo ri-deriva alla cieca dall'artefatto grezzo; ogni fatto cita un artefatto grezzo indicizzato con sha256 tramite evidence/_index.json.
L'intero spettro del reverse engineering. Binari nativi Windows/Linux, APK Android, web/JS, analisi di protocolli, emulazione di firmware, contromisure di risk-control — un unico sistema, non uno strumento mono-dominio.
Economia static-first. Un task che si chiude staticamente non tocca mai il tooling dinamico; ogni escalation è dichiarata, sottoposta a gate e verificata.
Riutilizza la conoscenza invece di ri-derivarla. Un catalogo crescente di strumenti di analisi registrati (decoder crypto, pipeline di disassemblaggio, query su grafi) fa sì che il sistema ricorra a tooling collaudato prima di scrivere script una tantum — e ogni esecuzione lascia dietro di sé fatti riutilizzabili, non una trascrizione di chat che evapora.
Si riprende invece di morire. Morti dei worker, disconnessioni API e crash sono eventi di prima classe: il loop li rileva, fa uno snapshot di ciò che è già stato prodotto e ri-dispaccia per continuare da dove le cose si erano fermate — non da zero.
Il tuo ambiente, le tue regole. VMware, ssh, docker, adb, o semplicemente solo statico — il sistema pilota qualunque canale di esecuzione si abbia già. Nulla è una modalità degradata; un task che non necessita mai di esecuzione non chiede mai una VM.

Avvio rapido

kunglao-agent gira all'interno di Claude Code. Da un campione su disco a un verdetto:

1. Installa il plugin

Da qualsiasi directory, in Claude Code:``` /plugin marketplace add amd2g2zz/kunglao-agent /plugin install kunglao-agent@kunglao-agent

(In alternativa: `claude --plugin-dir /path/to/kunglao-agent` per lo sviluppo.)

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

kunglao-init prepara lo spazio di lavoro, scrive CLAUDE.md, verifica la toolchain per il tuo --type e prepara .mcp.json. RIFIUTA in modo HARD quando manca uno strumento richiesto per il tuo tipo — le indicazioni per la correzione sono nel blocco di errore.

3. Dichiara l'attività e avvia l'analisi```

/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.

Scrivi il brief in modo che un revisore indipendente possa giudicare il risultato: **obiettivo dell'analisi** (cosa devi sapere), **logica di verifica** (cosa rende attendibile una risposta — ad es. "la firma deve essere riproducibile dagli stessi input"), **vincoli** (ad es. "nessuna esecuzione sull'host"). Tutto viene registrato in `task_spec.yaml`; da lì il ciclo si autoalimenta. Per capire come le richieste comuni si trasformano in affermazioni ben formulate, vedi [Come enunciare il task](#how-to-state-the-task).

### 4. Leggi il deliverable```
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

Come enunciare il task

Il loop deriva il suo criterio di completamento — l'oracolo — meccanicamente dallo stato finale che enunci. Un enunciato vago produce un oracolo vago, e l'analisi deriva verso ciò che può essere dimostrato invece di ciò che ti serviva. Quattro formulazioni coprono la maggior parte di quella deriva. Per ciascuna: cosa dicono gli utenti, cosa significa di solito, un enunciato ben formato, e su cosa si ancora l'oracolo.

"我要纯算" — "solo il puro algoritmo"

Di solito significa: riproduzione offline della routine di firma/crittografia dell'app — un harness unidbg o una riscrittura che gira senza dispositivo e senza app a run time. Non "analizzare l'app"; l'app è solo dove vive l'algoritmo.```

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.

**Oracle si ancora a:** replay byte-exact su ogni coppia, incluse quelle trattenute — e la riproduzione eseguita in modo autonomo.

### "我要解密" — "Voglio la decifratura"

**Di solito significa uno di due obiettivi diversi — specifica quale:**

- **(a) decifrare un corpo catturato** — una risposta una tantum su questi dati: "produci il plaintext di questo file di cache catturato."
- **(b) una capacità di decifratura** — algoritmo + recupero della chiave, riutilizzabile sui dati che catturerai domani.

Ben formulato (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).

Ben formato (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.

**Oracle si basa su:** (a) il testo in chiaro che convalida ciò che l'app visualizza; (b) algoritmo + chiave identificati e il round-trip del canary byte-identico al ciphertext prodotto dal dispositivo. "Ha decifrato una volta" non soddisfa nessuno dei due.

### "帮我分析这个协议" — "analizza questo protocollo per me"

**Di solito significa:** recupero del formato wire — framing, semantica dei campi e un codec che puoi eseguire.```
> 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 si ancora a: il codec che fa round-trip di ogni frame catturato byte per byte, e il frame tenuto da parte che decodifica in campi che corrispondono al comportamento osservato dell'app.

"这个 sign 在哪算的" — "dove viene calcolato questo sign?"

Di solito significa: una posizione con prova. Indicare un punto nel codice è facile; la risposta è utile solo con l'evidenza che questo punto sia il punto.```

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.

**Oracle ancorato su:** una classe/metodo/funzione nativa denominata, più un hook in quel punto che riproduce i valori catturati.

### Cosa hanno in comune

- **Nomina il campione e il comportamento** — quale parametro, entry point o flusso — non la categoria. "我要纯算" è una categoria; "il signer che produce l'header `sign` su api.example.com/v2/*" è un target.
- **Il successo deve essere dato.** Allega coppie input/output catturate; le coppie tenute nascoste sono ciò che rende onesta la verifica — una riproduzione non può fare overfitting su dati che non ha mai visto.
- **L'oracle deriva dallo stato finale che hai dichiarato.** Affermazione vaga, verifica vaga, analisi alla deriva.
- **I vincoli cambiano il piano.** Solo statico? Un dispositivo disponibile? Quale canale? Dillo subito — decide il percorso prima che il lavoro inizi (vedi [Bring your own environment](#bring-your-own-environment)).

## Sottocomandi

| Comando | Usalo quando | Cosa fa |
|---|---|---|
| `/kunglao-agent:init <workspace> [--type windows\|linux\|android\|web\|macos] [--lane malware\|algorithm\|protocol\|web\|data\|app]` | inizi un ingaggio, per primo | prepara lo scaffold del workspace, sonda la toolchain per il tipo, scrive `CLAUDE.md` e `.mcp.json`; rifiuta in modo HARD con indicazioni di correzione quando manca uno strumento richiesto |
| `/kunglao-agent:analysis <workspace>` (alias `analyze`) | dopo init — dichiara il task e avvia | raccoglie una volta il tuo obiettivo / logica di verifica / vincoli, poi esegue il ciclo di convergenza: cicli dispatch / verify fino al report |
| `/kunglao-agent:resume <workspace>` | dopo un crash, un riavvio o qualsiasi "a che punto ero?" | brief di breakpoint in sola lettura (stato di salute, claim aperti, worker in corso, timeline del crash) più l'azione successiva dalla macchina a stati |
| `/kunglao-agent:upgrade <workspace> [--dry-run]` | dopo un aggiornamento del plugin, su un workspace più vecchio (o quando il prompt di upgrade dice che lo stamp è indietro) | migra lo scaffold del workspace (hook, template, vocabolario degli eventi) alla versione corrente del plugin; `--dry-run` mostra l'anteprima; i dati utente (claim, fact, evidence) non vengono mai toccati — il drift dei byte rifiuta con RC=4 |
| `/kunglao-agent:help` | qualsiasi altra cosa | stampa la lista d'uso |

Ordine tipico: `init` crea il workspace → `analysis` dichiara il task e avvia → (`resume` se qualcosa va storto) → leggi il report a convergenza → `upgrade` dei workspace vecchi dopo gli aggiornamenti del plugin.

## Come si presenta un'esecuzione

*La forma di un ingaggio — cosa digiti, cosa ritorna, dove guardare.* Un esempio sintetico: un piccolo dropper Windows atterra in `~/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?"

Da lì il ciclo si esegue da solo — il percorso si adatta a ciò che il campione si rivela essere. Puoi allontanarti (vedi Long-horizon autonomy). Quando converge, leggi il deliverable qui sotto.

Scenari

Altri due percorsi end-to-end — scegli quello che corrisponde al tuo target (per un semplice binario Windows PE / Linux ELF, il caso pratico sopra è il percorso).

Android APK — cosa digita l'utente, cosa arriva dove

```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/` (l'APK), `facts/` (grafo delle classi, inventario dei `.so` nativi), `evidence/` (catture, dump). - **Done looks like:** ogni domanda supportata da evidenze riproducibili. - **The route adapts.** Alcuni APK si chiudono con puro lavoro statico sul DEX; altri richiedono debug sul dispositivo — il loop decide in base a ciò che il campione effettivamente è.

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?" ``` - **Lands in:** `evidence/` (captures, deobfuscated code), `facts/` (signing key, nonce derivation). - **Note:** `web` è un target in fase beta — l'asticella della toolchain è volutamente bassa; la capacità mancante emerge quando il loop ne ha effettivamente bisogno, non all'init.

Cosa ottieni

Un registro delle claim e una base di fatti in cui la fiducia è meccanica, non convenzionale:

Convergenza verificata — PROVEN richiede l'approvazione per corrispondenza esatta di un verificatore indipendente cieco; CONVERGED richiede che ogni domanda primaria abbia risposta con prova byte-per-byte, zero claim orfane, nessun spinning.
Integrità delle evidenze — ogni fatto risale attraverso evidence/_index.json a un artefatto grezzo (capture / trace / dump / binary). I riassunti derivati sono esclusi per design.
Maker-checker — il worker (maker) scrive i fatti; il verificatore redteam (checker) li ri-deriva in cieco. Agenti diversi, sempre.

Nessuna claim raggiunge PROVEN sulla parola del suo autore: un verificatore indipendente deve ri-derivarla in cieco, e una serie di gate meccanici deve superare il controllo. Il design completo dei gate è in docs/design/loop-engineering.md.

Dopo l'esecuzione, i file rispondono a domande diverse:

Esempio di fatto:```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 a lungo termine

Gli ingaggi reali non sono una chiacchierata di venti minuti. kunglao-agent resta sul problema senza che un umano guidi ogni passo:

- **Funziona per ore o giorni, senza supervisione** — un heartbeat pianificato mantiene il loop attivo tra le tue visite, e un loop bloccato viene segnalato invece di morire silenziosamente.
- **Si riprende dai fallimenti** — i worker morti o bloccati vengono sostituiti e le loro domande rimesse in coda; il lavoro bloccato si auto-recupera invece di restare inattivo.
- **Sopravvive a crash e riavvii** — `/kunglao-agent:resume <workspace>` ricostruisce lo stato delle cose dallo stato su disco e indica l'azione successiva.
- **Ricorda su disco, non in chat** — claim, fatti, evidenze e una traccia di audit completa risiedono nel workspace, così qualsiasi sessione può riprendere l'ingaggio.

Gli dai un target e le domande; lavora sul problema per ore o giorni, si riprende dai fallimenti, e tu leggi il verdetto quando converge.

## Ottenere buoni risultati

- **Fornisci target accessibili staticamente.** Il loop è static-first: un APK decompresso, un bundle non offuscato o un binario non strippato converge molto più velocemente di uno che forza il lavoro dinamico.
- **Configura la parte dinamica prima di averne bisogno.** Se le tue domande principali richiederanno l'esecuzione, scegli prima un canale (vedi [Bring your own environment](#bring-your-own-environment)) — init rifiuta HARD un task dinamico su `local`.
- **Distinguere "in esecuzione" da "bloccato"** — nuove voci in `runs/` significano che il loop è vivo; un heartbeat morto o la stessa decisione ripetuta senza nuovi fatti significa che non lo è — `/kunglao-agent:resume <workspace>` diagnostica e indica la prossima mossa.

## Toolchain per target

Il `--type` che scegli all'init blocca quali tool di livello HARD devono essere installati. Le indicazioni sono compresse — espandi il tuo target. **Tutti i tipi richiedono due server 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> — binari Windows nativi</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `pefile` (Python) | `pip install pefile` |
| HARD | `die` (Detect It Easy) | env `KUNGLAO_DIE` o nel PATH — [ntinfo.com](https://ntinfo.com) |
| HARD | `floss` (FLARE FLOSS) | secondo la [documentazione flare-floss](https://github.com/mandiant/flare-floss) |
| HARD | Ghidra o IDA | uno dei due; vedi [Internals](#internals) |
| HARD (T2/T3) | VMware + vmr-shell, o un canale ssh/docker | vedi [Bring your own environment](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (rinominato, porta personalizzata) | binario lato device/VM, porta predefinita 1337 |

Il dinamico Windows T3 usa anche l'MCP `x64dbg`; `volatility` (memory forensics) e l'MCP IDA-Pro sono opzionali — vedi il manifest MCP sotto [Internals](#internals).

</details>

<details>
<summary><strong>linux (ELF)</strong> — binari Linux nativi / firmware / immagini di memoria</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `file`, `readelf`, `objdump` | pacchetto `binutils` |
| HARD | Ghidra o IDA | uno dei due |
| HARD (T2/T3) | VMware + vmr-shell, o un control plane ssh/docker | vedi [Bring your own environment](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (rinominato, porta personalizzata) | binario lato device, porta 1337 |
| WARN | `gdbserver` (PATH lato host), `strace`, `ltrace` | extra opzionali |

`ssh-mcp` abilita il control plane ssh per host remoti / cloud / docker.

</details>

<details>
<summary><strong>android (APK / DEX / .so nativi)</strong> — il tipo di target più difficile, la maggior parte degli elementi HARD</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `aapt` o `aapt2` (o fallback `unzip`) | Android SDK build-tools |
| HARD | `jadx` (decompilatore DEX → Java) | [skylot/jadx](https://github.com/skylot/jadx) |
| HARD | `apktool` (decode/rebuild risorse APK) | [iBotPeaches/Apktool](https://github.com/iBotPeaches/Apktool) |
| HARD | `gitnexus` (grafo post-decompilazione) | `npm i -g gitnexus` |
| HARD | Ghidra o IDA | solo se l'APK contiene `.so` nativi |
| HARD | `adb` + **un device rooted** con `ro.debuggable=1` | platform-tools + frida personalizzato sul device |
| HARD | `frida-server` (rinominato, porta personalizzata 1337) | binario lato device |
| HARD | `android_server` (debug remoto IDA) | binario lato device, porta 23946 |
| WARN | `apkid` | `pip install apkid` |
| WARN | `baksmali` | dalle [release di smali](https://github.com/baksmali/smali/releases) |

</details>

<details>
<summary><strong>web &amp; macos (beta)</strong> — toolchain minimali, nessun elemento HARD per design</summary>

| Tier | Tool | Install |
|---|---|---|
| WARN | MCP `camoufox-reverse` (web) | Firefox anti-detect per hook / trace / cattura di rete |
| WARN | `docker` (predefinito canale web) | Docker Desktop, oppure imposta esplicitamente `KUNGLAO_CHANNEL=ssh` |
| WARN | `lipo`, `otool`, `nm`, `codesign`, `xattr` (macOS) | Xcode Command Line Tools |
| WARN | MCP `ghidra` (macOS) | consigliato — vedi il manifest sotto [Internals](#internals) |

Entrambi sono target in fase beta: le capacità mancanti emergono quando il loop ne ha effettivamente bisogno, non all'init. Il lavoro dinamico su macOS usa il canale `ssh` (verso un host Mac); per il percorso opzionale di debug browser x64dbg, installa la toolchain Windows sopra.

</details>

Un'unica fonte manifest per tutto quanto sopra — interrogala in qualsiasi momento: `python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos>` (exit 1 = HARD mancante).

## Bring your own environment

Il debug dinamico necessita di un control plane di esecuzione che l'agente possa pilotare. `KUNGLAO_CHANNEL` seleziona uno tra cinque canali di prima classe — usa quello che il tuo ambiente già possiede; nessuno è una modalità degradata:

| Channel | What it drives | Prerequisites |
|---|---|---|
| `vmr` (predefinito) | VM VMware, **qualsiasi OS guest** — i workflow snapshot/revert sono il suo valore insostituibile | skill vmr-shell; `KUNGLAO_VM_HOST` + porte 9876/1337 |
| `ssh` | Qualsiasi macchina raggiungibile via ssh: bare metal, VM cloud, Mac, host docker remoto | autenticazione con chiave — la probe esegue un vero `ssh ... true` in BatchMode |
| `docker` | Daemon docker locale o remoto — `docker exec` è equivalente a qualsiasi percorso di controllo | `docker version` verde; `KUNGLAO_DOCKER_CONTAINER` opzionale |
| `adb` | Emulatore Android o device reale | `adb devices` lo mostra; `adb forward tcp:1337 tcp:1337` per frida |
| `local` | **Analisi solo statica sull'host** | nessuno — vedi la linea rossa |

> **Linea rossa di `local`:** local è solo per lavoro **statico** — non eseguire, debuggare o iniettare mai il campione sull'host. Qualsiasi requisito dinamico commuta `KUNGLAO_CHANNEL` su `vmr`/`ssh`/`docker`/`adb`; init rifiuta HARD un task dinamico su `local`.

Le probe dei canali vengono eseguite solo per i task dinamici (i task solo statici le saltano). L'esecuzione sul canale `ssh` passa attraverso il control plane **ssh-mcp** (`npm i -g ssh-mcp`); la CLI ssh semplice è il fallback. Per docker remoto su ssh, imposta `KUNGLAO_DOCKER_CONTAINER`.

## Configurazione

Quattro variabili coprono la maggior parte delle configurazioni:

| Variable | Default | Meaning |
|---|---|---|
| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | non impostata | deve restare non impostata o `0` — valori truthy instradano i dispatch attraverso il canale teammate e vengono rifiutati |
| `KUNGLAO_CHANNEL` | `vmr` | control plane di esecuzione dinamica: `vmr` \| `ssh` \| `docker` \| `adb` \| `local` — vedi [Bring your own environment](#bring-your-own-environment) |
| `KUNGLAO_VM_HOST` | non impostata | VM/host per l'analisi dinamica (vmr-shell :9876, Frida :1337) |
| `GHIDRA_HOME` | non impostata | root di installazione di Ghidra (deve contenere `support/analyzeHeadless.bat`) |

Raramente necessarie: `KUNGLAO_DOCKER_CONTAINER` (target di esecuzione docker per i canali `ssh`/`docker`), `KUNGLAO_FRIDA_PORT` (predefinita 1337), `KUNGLAO_DIE` (percorso DIE, fallback su PATH), `KUNGLAO_CLAUDE_JSON` (override di test per il registro MCP a livello utente).

## Sicurezza

- I campioni non vengono mai eseguiti sull'host — l'hook `block_malware_exec` lo impone; il lavoro dinamico gira solo su VM/container/device e richiede autorizzazione per sessione.
- Gerarchia della ground truth: artefatto grezzo > tool locale > sandbox > threat intel (la CTI è un'ipotesi falsificabile, mai verità).
- Maker-checker: un worker non si auto-verifica mai; un verificatore non legge mai la conclusione del maker.
- Bin, impostazioni e hook non vengono mai committati; i segreti sono esclusi dai workspace e dal repo.

## Sviluppo

I contributi sono benvenuti. Workflow: branch da `dev`, un branch per modifica, PR di ritorno su `dev`.```bash
git worktree add .worktrees/<name> -b <name> dev
uv sync --locked
uv run python -m pytest -q
gh pr create --base dev

L'entry point autorevole per l'intera suite è python -m pytest -q (vedi .github/workflows/release-check.yml).

La documentazione di progettazione si trova in docs/ e specs/. Vedi License.

Internals

MCP supply (il manifest completo)

Fonte unica di verità: scripts/mcp_probe.py; kunglao-init crea un workspace .mcp.json quando manca (--no-mcp lo salta; un file esistente non viene mai sovrascritto). Probe: python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos> — exit 1 = HARD mancante, 2 = solo WARN mancante.

Workspace layout

Un workspace per ogni engagement su un campione:``` / ├── 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

Gli hook di kunglao sono configurati a livello di workspace; il tuo `~/.claude/settings.json` globale non viene mai scritto.

</details>

---

## Licenza

Doppia licenza: **AGPL-3.0** per uso personale, accademico e interno (gratuito — vedi [LICENSE](https://github.com/amd2g2zz/kunglao-agent/blob/master/LICENSE)); è richiesta una **licenza commerciale** per uso commerciale closed-source o SaaS — vedi [LICENSE-commercial.md](https://github.com/amd2g2zz/kunglao-agent/blob/master/LICENSE-commercial.md).

Claude Code	dove gira kunglao-agent	secondo la documentazione di Anthropic
Python 3.10+ (Python 2 non è supportato)	il plugin porta con sé un env bloccato tramite `uv`; non lo si tocca	di sistema o gestito da `uv`
`uv`	resolver di env bloccato	`pip install uv` o astral.sh/uv
Ghidra o IDA	una suite di analisi statica per la decompilazione	vedi Toolchain by target

È fatto?	l'exit code del loop — `CONVERGED` (0) significa che ogni domanda primaria ha una risposta verificata; stato per-claim in `claim-register.yaml`
Cosa ha trovato?	`facts/F<NNN>.md` — un fatto ancorato ai byte per file, mappato alle claim da `claim-register.yaml`
Come lo riproduco?	`evidence/_index.json` — fatto → artefatto grezzo (path + sha256); ogni fatto porta un comando `reproduce:`
Cosa è successo esattamente?	`runs/` — il registro tick-by-tick e lo stato del worker

`ghidra`	HARD	required, all types	decompilation / static analysis	`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`
`sequential-thinking`	HARD	required, all types	structured reasoning	`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`
`x64dbg`	HARD	Windows T3 dynamic	dynamic debugging (VM remote)	`claude mcp add x64dbg -- x64dbg-automate-mcp`
`volatility`	WARN	Windows T3	memory forensics	`claude mcp add volatility -- python <path>/volatility_mcp_server.py`
`ida-pro-vm`	WARN	when IDA chosen	remote IDA analysis	`claude mcp add --transport http ida-pro-vm <ida-mcp-url>`
`gitnexus`	HARD	Android graph building	post-decompile knowledge graph	`claude mcp add gitnexus -- gitnexus mcp`
`virustotal`	WARN	CTI	threat intel (family-attribution hypotheses)	`claude mcp add virustotal -- npx -y @burtthecoder/mcp-virustotal`
`ssh-mcp`	WARN	channel	ssh execution control plane	`claude mcp add ssh-mcp -- ssh-mcp`
`camoufox-reverse`	WARN	web (beta)	browser JS reversing (hooks / trace / network capture)	`claude mcp add camoufox-reverse -- python -m camoufox_reverse_mcp`

Più Popolari

kunglao-agent

kunglao-agent

Perché kunglao-agent

Avvio rapido

1. Installa il plugin

3. Dichiara l'attività e avvia l'analisi```

Come enunciare il task

"我要纯算" — "solo il puro algoritmo"

"这个 sign 在哪算的" — "dove viene calcolato questo sign?"

Scenari

Cosa ottieni

Internals