kunglao-agent

kunglao-agent es un sistema autónomo de ingeniería inversa. Le entregas un objetivo y las preguntas que necesitas responder; trabaja el problema durante horas o días por su cuenta — planificando su propia ruta, recuperándose de la muerte de workers, reanudando tras fallos — y solo converge cuando cada respuesta se deriva de evidencia en bruto y supera las puertas de verificación mecánica.

English · Simplified Chinese

Actualmente se distribuye como un plugin de Claude Code — Claude Code es la interfaz con la que hablas, no lo que es el producto. El producto es el bucle: workers especialistas analizan (primero estático), un verificador independiente vuelve a derivar cada hecho a ciegas desde la evidencia en bruto, y puertas mecánicas deciden cuándo el trabajo está terminado. El entregable es una base de hechos donde cada afirmación está anclada a bytes, verificada de forma independiente e indexada por evidencia — la confianza se impone por maquinaria, no por convención.

Por qué kunglao-agent

Horizonte largo por diseño. Los trabajos se ejecutan sin supervisión durante horas y días: un heartbeat programado mantiene vivo el bucle, los workers muertos se reconcilian y sus afirmaciones se reencolan, los fallos se reanudan desde el estado en disco, las afirmaciones bloqueadas se autorrecuperan. Lees el veredicto cuando converge — no vigilas cada paso. Ver Autonomía de horizonte largo.
Respuestas en las que puedes confiar. Ningún hecho es PROVEN hasta que un verificador independiente lo vuelve a derivar a ciegas desde el artefacto en bruto; cada hecho cita un artefacto en bruto indexado por sha256 a través de evidence/_index.json.
El espectro completo de la ingeniería inversa. Binarios nativos de Windows/Linux, APKs de Android, web/JS, análisis de protocolos, emulación de firmware, contramedidas de control de riesgo — un solo sistema, no una herramienta de un único dominio.
Economía estático-primero. Una tarea que se cierra de forma estática nunca toca herramientas dinámicas; cada escalada se declara, se controla con puertas y se audita.
Reutiliza conocimiento en lugar de volver a derivarlo. Un catálogo creciente de herramientas de análisis registradas (decodificadores cripto, pipelines de desensamblado, consultas de grafos) hace que el sistema recurra a herramientas probadas antes de escribir scripts puntuales — y cada ejecución deja atrás hechos reutilizables, no una transcripción de chat que se evapora.
Se recupera en lugar de morir. Muertes de workers, desconexiones de API y fallos son eventos de primera clase: el bucle los detecta, hace una instantánea de lo que ya se produjo y reenvía para continuar desde donde se detuvo todo — no desde cero.
Tu entorno, tus reglas. VMware, ssh, docker, adb o solo estático puro — el sistema maneja el canal de ejecución que ya tengas. Nada es un modo degradado; una tarea que nunca necesita ejecución nunca pide una VM.

Inicio rápido

kunglao-agent se ejecuta dentro de Claude Code. Desde una muestra en disco hasta un veredicto:

1. Instalar el plugin

Desde cualquier directorio, en Claude Code:``` /plugin marketplace add amd2g2zz/kunglao-agent /plugin install kunglao-agent@kunglao-agent

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

### 2. Inicializar un espacio de trabajo```
/kunglao-agent:init ~/cases/synth-dropper --type windows

kunglao-init prepara el espacio de trabajo, escribe CLAUDE.md, sondea la cadena de herramientas para tu --type y prepara .mcp.json. Rechaza de forma estricta cuando falta una herramienta requerida para tu tipo — la guía de solución está en el bloque de error.

3. Indica la tarea e inicia el análisis```

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

Redacta el brief de modo que un revisor independiente pueda juzgar el resultado: **objetivo del análisis** (qué necesitas saber), **lógica de verificación** (qué hace que una respuesta sea confiable — p. ej. "la firma debe ser reproducible a partir de las mismas entradas"), **restricciones** (p. ej. "sin ejecución en el host"). Todo queda registrado en `task_spec.yaml`; a partir de ahí, el bucle se impulsa por sí solo. Para saber cómo las peticiones habituales se convierten en enunciados bien formados, consulta [Cómo enunciar la tarea](#how-to-state-the-task).

### 4. Lee el entregable```
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

Cómo enunciar la tarea

El bucle deriva su criterio de finalización —el oráculo— mecánicamente del estado final que se enuncie. Un enunciado vago produce un oráculo vago, y el análisis se desvía hacia lo que sea demostrable en lugar de lo que se necesitaba. Cuatro formulaciones cubren la mayor parte de esa deriva. Para cada una: lo que dicen los usuarios, lo que suele significar, un enunciado bien formado y en qué se ancla el oráculo.

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

Normalmente significa: reproducción offline de la rutina de firma/criptografía de la app — un arnés de unidbg o una reescritura que se ejecuta sin dispositivo y sin la app en tiempo de ejecución. No es "analizar la app"; la app es solo donde vive el 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.

**Anclajes de Oracle en:** repetición byte-exacta en cada par, incluidos los retenidos — y la reproducción ejecutándose de forma independiente.

### "我要解密" — "Quiero descifrado"

**Normalmente significa uno de dos objetivos diferentes — di cuál:**

- **(a) descifrar un cuerpo capturado** — una respuesta puntual sobre estos datos: "produce el texto plano de este archivo de caché capturado."
- **(b) una capacidad de descifrado** — algoritmo + recuperación de clave, reutilizable en datos que captures mañana.

Bien 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).

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

**Oracle se ancla en:** (a) el texto plano validado contra lo que la aplicación renderiza; (b) algoritmo + clave identificados y el canary round-trip byte-idéntico al ciphertext producido por el dispositivo. "Se descifró una vez" no satisface ninguno de los dos.

### "帮我分析这个协议" — "analiza este protocolo para mí"

**Normalmente significa:** recuperación del formato de cable — framing, semántica de campos y un códec que puedas ejecutar.```
> 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.

Anclajes de Oracle: el códec que hace round-trip de cada fotograma capturado byte a byte, y el fotograma reservado que se decodifica a campos que coinciden con el comportamiento observado de la aplicación.

"这个 sign 在哪算的" — "¿dónde se calcula este sign?"

Normalmente significa: una ubicación con prueba. Nombrar un punto en el código es barato; la respuesta solo es útil con evidencia de que este punto es el 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.

**Anclas de Oracle:** una clase/método/función nativa con nombre, más un hook en ese punto que reproduce los valores capturados.

### Qué tienen en común

- **Nombrar la muestra y el comportamiento** — qué parámetro, entrada o flujo — no la categoría. "我要纯算" es una categoría; "el firmante que produce el encabezado `sign` en api.example.com/v2/*" es un objetivo.
- **El éxito debe ser datos.** Adjuntar pares de entrada/salida capturados; los pares retenidos son lo que hace honesta la verificación — una reproducción no puede sobreajustarse a datos que nunca vio.
- **El oracle se deriva de tu estado final declarado.** Declaración vaga, verificación vaga, análisis a la deriva.
- **Las restricciones cambian el plan.** ¿Solo estático? ¿Un dispositivo disponible? ¿Qué canal? Dilo desde el principio — decide la ruta antes de que empiece el trabajo (ver [Trae tu propio entorno](#trae-tu-propio-entorno)).

## Subcomandos

| Comando | Úsalo cuando | Qué hace |
|---|---|---|
| `/kunglao-agent:init <workspace> [--type windows\|linux\|android\|web\|macos] [--lane malware\|algorithm\|protocol\|web\|data\|app]` | al iniciar un engagement, primero | genera el andamiaje del workspace, sondea la cadena de herramientas para el tipo, escribe `CLAUDE.md` y `.mcp.json`; RECHAZA en duro con guía de corrección cuando falta una herramienta requerida |
| `/kunglao-agent:analysis <workspace>` (alias `analyze`) | después de init — declara la tarea y comienza | recopila tu objetivo / lógica de verificación / restricciones una vez, luego ejecuta el bucle de convergencia: ciclos de dispatch / verify hasta el informe |
| `/kunglao-agent:resume <workspace>` | después de un crash, reinicio, o cualquier "¿dónde estaba?" | resumen de punto de interrupción de solo lectura (salud, afirmaciones abiertas, workers en vuelo, línea temporal de crashes) más la siguiente acción de la máquina de estados |
| `/kunglao-agent:upgrade <workspace> [--dry-run]` | después de una actualización del plugin, en un workspace antiguo (o cuando el prompt de actualización dice que el sello está atrasado) | migra el andamiaje del workspace (hooks, plantillas, vocabulario de eventos) a la versión actual del plugin; `--dry-run` previsualiza; los datos de usuario (afirmaciones, hechos, evidencia) nunca se tocan — la deriva de bytes rechaza con RC=4 |
| `/kunglao-agent:help` | cualquier otra cosa | imprime la lista de uso |

Orden típico: `init` crea el workspace → `analysis` declara la tarea y comienza → (`resume` si algo se desvía) → leer el informe en la convergencia → `upgrade` los workspaces antiguos después de actualizaciones del plugin.

## Cómo se ve una ejecución

*La forma de un engagement — qué escribes, qué vuelve, dónde mirar.* Un ejemplo sintético: un pequeño dropper de Windows aterriza en `~/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 de ahí, el bucle se ejecuta por sí solo — la ruta se adapta a lo que resulte ser la muestra. Puedes alejarte (consulta Long-horizon autonomy). Cuando converja, lee el entregable a continuación.

Escenarios

Dos rutas de extremo a extremo más — elige la que coincida con tu objetivo (para un binario simple Windows PE / Linux ELF, el caso práctico anterior es la ruta).

Android APK — lo que el usuario escribe, lo que acaba dónde

```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?" ``` - **Termina en:** `bins/` (el APK), `facts/` (grafo de clases, inventario de `.so` nativos), `evidence/` (capturas, volcados). - **Terminado se ve así:** cada pregunta respaldada por evidencia reproducible. - **La ruta se adapta.** Algunos APK se cierran con trabajo puramente estático de DEX; otros necesitan depuración en el dispositivo — el bucle decide a partir de lo que el sample realmente es.

Web / JS — desempaquetar → desofuscar → replay de parámetros firmados

```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?" ``` - **Aterriza en:** `evidence/` (capturas, código desofuscado), `facts/` (clave de firma, derivación de nonce). - **Nota:** `web` es un objetivo en etapa beta — el listón del toolchain es deliberadamente ligero; la capacidad faltante aflora cuando el bucle realmente la necesita, no en el init.

Qué obtienes

Un registro de afirmaciones y una base de hechos donde la confianza es mecánica, no convencional:

Convergencia verificada — PROVEN requiere la aprobación por coincidencia exacta de un verificador ciego independiente; CONVERGED requiere que cada pregunta primaria esté respondida con prueba a nivel de byte, cero afirmaciones huérfanas, sin spinning.
Integridad de la evidencia — cada hecho se remonta a través de evidence/_index.json hasta un artefacto en bruto (captura / traza / volcado / binario). Los resúmenes derivados quedan excluidos por diseño.
Maker-checker — el worker (maker) escribe hechos; el verificador de redteam (checker) los re-deriva a ciegas. Agentes distintos, siempre.

Ninguna afirmación alcanza PROVEN por la palabra de su autor: un verificador independiente debe re-derivarla a ciegas, y un conjunto de puertas mecánicas debe pasar. El diseño completo de las puertas vive en docs/design/loop-engineering.md.

Tras la ejecución, los archivos responden a preguntas distintas:

Hecho de ejemplo:```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}

## Autonomía de largo horizonte

Los compromisos reales no son una conversación de veinte minutos. kunglao-agent se mantiene en el problema sin que un humano guíe cada paso:

- **Se ejecuta durante horas o días, sin supervisión** — un latido programado mantiene el bucle funcionando entre tus visitas, y un bucle estancado se señala en lugar de morir silenciosamente.
- **Se recupera de fallos** — los workers muertos o atascados se reemplazan y sus preguntas se vuelven a encolar; el trabajo bloqueado se autorrecupera en lugar de quedar inactivo.
- **Sobrevive a caídas y reinicios** — `/kunglao-agent:resume <workspace>` reconstruye dónde quedaron las cosas a partir del estado en disco y nombra la siguiente acción.
- **Recuerda en disco, no en el chat** — las afirmaciones, hechos, evidencia y un rastro de auditoría completo viven en el workspace, de modo que cualquier sesión puede retomar el compromiso.

Le das un objetivo y las preguntas; trabaja el problema durante horas o días, se recupera de fallos, y tú lees el veredicto cuando converge.

## Obtener buenos resultados

- **Aliméntalo con objetivos de acceso estático.** El bucle es estático primero: un APK desempaquetado, un bundle sin ofuscar o un binario sin strip converge mucho más rápido que uno que fuerce trabajo dinámico.
- **Configura la pata dinámica antes de necesitarla.** Si tus preguntas principales requerirán ejecución, elige un canal primero (ver [Trae tu propio entorno](#bring-your-own-environment)) — init RECHAZA de forma dura una tarea dinámica en `local`.
- **Distinguir "trabajando" de "atascado"** — entradas nuevas en `runs/` significan que el bucle está vivo; un latido muerto o la misma decisión repitiéndose sin nuevos hechos significa que no lo está — `/kunglao-agent:resume <workspace>` diagnostica y nombra el siguiente movimiento.

## Cadena de herramientas por objetivo

El `--type` que eliges en init fija qué herramientas de nivel HARD deben estar instaladas. La guía está colapsada — expande tu objetivo. **Todos los tipos requieren dos servidores MCP:** `ghidra` (`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`) y `sequential-thinking` (`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`).

<details>
<summary><strong>windows (PE32+ x86-64)</strong> — binarios nativos de Windows</summary>

| Nivel | Herramienta | Instalación |
|---|---|---|
| HARD | `pefile` (Python) | `pip install pefile` |
| HARD | `die` (Detect It Easy) | env `KUNGLAO_DIE` o en PATH — [ntinfo.com](https://ntinfo.com) |
| HARD | `floss` (FLARE FLOSS) | según [flare-floss docs](https://github.com/mandiant/flare-floss) |
| HARD | Ghidra o IDA | uno de ellos; ver [Internals](#internals) |
| HARD (T2/T3) | VMware + vmr-shell, o un canal ssh/docker | ver [Trae tu propio entorno](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (renombrado, puerto personalizado) | binario del lado del dispositivo/VM, puerto por defecto 1337 |

Windows T3 dinámico también usa el MCP `x64dbg`; `volatility` (forense de memoria) y el MCP de IDA-Pro son opcionales — ver el manifiesto MCP en [Internals](#internals).

</details>

<details>
<summary><strong>linux (ELF)</strong> — binarios nativos de Linux / firmware / imágenes de memoria</summary>

| Nivel | Herramienta | Instalación |
|---|---|---|
| HARD | `file`, `readelf`, `objdump` | paquete `binutils` |
| HARD | Ghidra o IDA | uno de ellos |
| HARD (T2/T3) | VMware + vmr-shell, o un plano de control ssh/docker | ver [Trae tu propio entorno](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (renombrado, puerto personalizado) | binario del lado del dispositivo, puerto 1337 |
| WARN | `gdbserver` (PATH del lado del host), `strace`, `ltrace` | extras opcionales |

`ssh-mcp` habilita el plano de control ssh para hosts remotos / en la nube / docker.

</details>

<details>
<summary><strong>android (APK / DEX / .so nativo)</strong> — el tipo de objetivo más difícil, la mayor cantidad de elementos HARD</summary>

| Nivel | Herramienta | Instalación |
|---|---|---|
| HARD | `aapt` o `aapt2` (o `unzip` como respaldo) | Android SDK build-tools |
| HARD | `jadx` (descompilador DEX → Java) | [skylot/jadx](https://github.com/skylot/jadx) |
| HARD | `apktool` (decodificación/reconstrucción de recursos APK) | [iBotPeaches/Apktool](https://github.com/iBotPeaches/Apktool) |
| HARD | `gitnexus` (grafo post-descompilación) | `npm i -g gitnexus` |
| HARD | Ghidra o IDA | solo si el APK contiene `.so` nativo |
| HARD | `adb` + **un dispositivo rooteado** con `ro.debuggable=1` | platform-tools + frida personalizado en el dispositivo |
| HARD | `frida-server` (renombrado, puerto personalizado 1337) | binario del lado del dispositivo |
| HARD | `android_server` (depuración remota de IDA) | binario del lado del dispositivo, puerto 23946 |
| WARN | `apkid` | `pip install apkid` |
| WARN | `baksmali` | desde [smali releases](https://github.com/baksmali/smali/releases) |

</details>

<details>
<summary><strong>web &amp; macos (beta)</strong> — cadenas de herramientas mínimas, sin elementos HARD por diseño</summary>

| Nivel | Herramienta | Instalación |
|---|---|---|
| WARN | MCP `camoufox-reverse` (web) | Firefox anti-detección para hook / trace / captura de red |
| WARN | `docker` (canal web por defecto) | Docker Desktop, o establece `KUNGLAO_CHANNEL=ssh` explícitamente |
| WARN | `lipo`, `otool`, `nm`, `codesign`, `xattr` (macOS) | Xcode Command Line Tools |
| WARN | MCP `ghidra` (macOS) | recomendado — ver el manifiesto en [Internals](#internals) |

Ambos son objetivos en etapa beta: la capacidad faltante se manifiesta cuando el bucle realmente la necesita, no en init. El trabajo dinámico de macOS usa el canal `ssh` (hacia un host Mac); para la ruta opcional de depuración de navegador con x64dbg, instala la cadena de herramientas de Windows de arriba.

</details>

Fuente única de manifiesto para todo lo anterior — sondeala en cualquier momento: `python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos>` (exit 1 = HARD faltante).

## Trae tu propio entorno

La depuración dinámica necesita un plano de control de ejecución que el agente pueda manejar. `KUNGLAO_CHANNEL` selecciona uno de cinco canales de primera clase — usa lo que tu entorno ya tenga; ninguno es un modo degradado:

| Canal | Qué maneja | Requisitos previos |
|---|---|---|
| `vmr` (por defecto) | VM de VMware, **cualquier SO invitado** — los flujos de trabajo de snapshot/revert son su valor irremplazable | skill vmr-shell; `KUNGLAO_VM_HOST` + puertos 9876/1337 |
| `ssh` | Cualquier máquina alcanzable por ssh: bare metal, VM en la nube, Mac, host docker remoto | autenticación por clave — el sondeo ejecuta un `ssh ... true` real en BatchMode |
| `docker` | Demonio docker local o remoto — `docker exec` es equivalente a cualquier ruta de control | `docker version` en verde; `KUNGLAO_DOCKER_CONTAINER` opcional |
| `adb` | Emulador de Android o dispositivo real | `adb devices` lo muestra; `adb forward tcp:1337 tcp:1337` para frida |
| `local` | **Análisis solo estático en el host** | ninguno — ver la línea roja |

> **Línea roja de `local`:** local es solo para trabajo **estático** — nunca ejecutes, depures o inyectes la muestra en el host. Cualquier requisito dinámico cambia `KUNGLAO_CHANNEL` a `vmr`/`ssh`/`docker`/`adb`; init RECHAZA de forma dura una tarea dinámica en `local`.

Los sondeos de canal se ejecutan solo para tareas dinámicas (las tareas solo estáticas los omiten). La ejecución del canal `ssh` fluye a través del plano de control **ssh-mcp** (`npm i -g ssh-mcp`); el ssh de CLI simple es el respaldo. Para docker remoto sobre ssh, establece `KUNGLAO_DOCKER_CONTAINER`.

## Configuración

Cuatro variables cubren la mayoría de las configuraciones:

| Variable | Por defecto | Significado |
|---|---|---|
| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | sin establecer | debe permanecer sin establecer o en `0` — los valores truthy enrutan los despachos a través del canal de compañeros de equipo y son rechazados |
| `KUNGLAO_CHANNEL` | `vmr` | plano de control de ejecución dinámica: `vmr` \| `ssh` \| `docker` \| `adb` \| `local` — ver [Trae tu propio entorno](#bring-your-own-environment) |
| `KUNGLAO_VM_HOST` | sin establecer | VM/host para análisis dinámico (vmr-shell :9876, Frida :1337) |
| `GHIDRA_HOME` | sin establecer | raíz de instalación de Ghidra (debe contener `support/analyzeHeadless.bat`) |

Rara vez necesarias: `KUNGLAO_DOCKER_CONTAINER` (objetivo de ejecución docker para los canales `ssh`/`docker`), `KUNGLAO_FRIDA_PORT` (por defecto 1337), `KUNGLAO_DIE` (ruta de DIE, recurre a PATH), `KUNGLAO_CLAUDE_JSON` (anulación de prueba para el registro MCP a nivel de usuario).

## Seguridad

- Las muestras nunca se ejecutan en el host — el hook `block_malware_exec` lo impone; el trabajo dinámico se ejecuta solo en VM/contenedor/dispositivo y requiere autorización por sesión.
- Jerarquía de verdad fundamental: artefacto sin procesar > herramienta local > sandbox > threat intel (CTI es una hipótesis falsable, nunca la verdad).
- Maker-checker: un worker nunca se autoverifica; un verificador nunca lee la conclusión del maker.
- Los bins, ajustes y hooks nunca se confirman; los secretos se excluyen de los workspaces y del repositorio.

## Desarrollo

Las contribuciones son bienvenidas. Flujo de trabajo: rama desde `dev`, una rama por cambio, PR de vuelta a `dev`.```bash
git worktree add .worktrees/<name> -b <name> dev
uv sync --locked
uv run python -m pytest -q
gh pr create --base dev

La entrada autoritativa de la suite completa es python -m pytest -q (véase .github/workflows/release-check.yml).

La documentación de diseño se encuentra en docs/ y specs/. Véase License.

Internals

MCP supply (the full manifest)

Fuente única de verdad: scripts/mcp_probe.py; kunglao-init genera un .mcp.json de espacio de trabajo cuando falta (--no-mcp lo omite; un archivo existente nunca se sobrescribe). Sonda: python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos> — salida 1 = HARD faltante, 2 = solo WARN faltante.

Workspace layout

Un espacio de trabajo por compromiso de muestra:

``` / ├── 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 ``` Los hooks de kunglao están conectados a nivel de workspace; tu `~/.claude/settings.json` global nunca se escribe.

Licencia

Con doble licencia: AGPL-3.0 para uso personal, académico e interno (gratis — consulta LICENSE); se requiere una licencia comercial para uso comercial de código cerrado o SaaS — consulta LICENSE-commercial.md.

Claude Code	donde se ejecuta kunglao-agent	según la documentación de Anthropic
Python 3.10+ (Python 2 no es compatible)	el plugin incluye un entorno fijado mediante `uv`; tú no lo tocas	del sistema o gestionado por `uv`
`uv`	resolvedor de entorno bloqueado	`pip install uv` o astral.sh/uv
Ghidra o IDA	una suite de análisis estático para descompilación	ver Toolchain por objetivo

¿Está hecho?	el código de salida del bucle — `CONVERGED` (0) significa que cada pregunta primaria tiene una respuesta verificada; el estado por afirmación en `claim-register.yaml`
¿Qué encontró?	`facts/F<NNN>.md` — un hecho anclado a bytes por archivo, mapeado a afirmaciones mediante `claim-register.yaml`
¿Cómo lo reproduzco?	`evidence/_index.json` — hecho → artefacto en bruto (ruta + sha256); cada hecho lleva un comando `reproduce:`
¿Qué ocurrió exactamente?	`runs/` — el registro tick a tick y el estado del worker

`ghidra`	HARD	requerido, todos los tipos	descompilación / análisis estático	`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`
`sequential-thinking`	HARD	requerido, todos los tipos	razonamiento estructurado	`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`
`x64dbg`	HARD	Windows T3 dinámico	depuración dinámica (VM remota)	`claude mcp add x64dbg -- x64dbg-automate-mcp`
`volatility`	WARN	Windows T3	análisis forense de memoria	`claude mcp add volatility -- python <path>/volatility_mcp_server.py`
`ida-pro-vm`	WARN	cuando se elige IDA	análisis remoto de IDA	`claude mcp add --transport http ida-pro-vm <ida-mcp-url>`
`gitnexus`	HARD	construcción de grafos de Android	grafo de conocimiento post-descompilación	`claude mcp add gitnexus -- gitnexus mcp`
`virustotal`	WARN	CTI	inteligencia de amenazas (hipótesis de atribución de familia)	`claude mcp add virustotal -- npx -y @burtthecoder/mcp-virustotal`
`ssh-mcp`	WARN	canal	plano de control de ejecución ssh	`claude mcp add ssh-mcp -- ssh-mcp`
`camoufox-reverse`	WARN	web (beta)	ingeniería inversa de JS en navegador (hooks / trace / captura de red)	`claude mcp add camoufox-reverse -- python -m camoufox_reverse_mcp`

Más Populares

kunglao-agent

kunglao-agent

Por qué kunglao-agent

Inicio rápido

1. Instalar el plugin

3. Indica la tarea e inicia el análisis```

Cómo enunciar la tarea

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

"这个 sign 在哪算的" — "¿dónde se calcula este sign?"

Escenarios

Qué obtienes

Internals

Licencia