Ejecuta cualquier Skill en Manus
con un clic

Ejecuta cualquier Skill en Manus con un clic

deep-scan

Estrellas0

Forks0

Actualizado11 de junio de 2026 a las 20:08

Whole-file deep reader — finds bugs by READING risk-ranked files in full and reasoning from first principles, not by grepping for known patterns. Catches the long tail (project-specific wrappers, business logic, cross-function flaws) that pattern-gated producers structurally miss. Token-expensive; budget-bounded and risk-ranked. Promotes leads into .kuzushi/findings.json (source "deep-scan").

Instalación

Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.

Ejecutar en Manus

Fuente

allsmog

allsmog/kuzushi-security-plugin

Abrir repositorio de GitHub Ver repositorios del creador

Descarga

Ejecutar en Manus

Ocupaciones relacionadasSOC

Basado en la clasificación ocupacional SOC

Analistas de seguridad de la informaciónOcupaciones informáticas y matemáticas·SOC 15-1212

SKILL.md

readonly

name	deep-scan
description	Whole-file deep reader — finds bugs by READING risk-ranked files in full and reasoning from first principles, not by grepping for known patterns. Catches the long tail (project-specific wrappers, business logic, cross-function flaws) that pattern-gated producers structurally miss. Token-expensive; budget-bounded and risk-ranked. Promotes leads into .kuzushi/findings.json (source "deep-scan").
context	command
runner	scripts/cmd/deep-scan-run.mjs
user-invocable	false

Deep scan

Find the bugs the pattern scanners can't see. Every other producer starts from a ripgrep hit; this one starts from the files. It reads the highest-risk files in full and reasons about what could actually go wrong — the way a human auditor finds the bug that doesn't look like any CVE.

Prefer the provider-neutral command: KUZUSHI_MODEL="${KUZUSHI_MODEL:-openai-codex:gpt-5.5}" node "<plugin root>/scripts/cmd/deep-scan-run.mjs" --target "<repo root>". It performs prepare -> configured LLM bridge -> finalize without depending on a Claude subagent runtime. To go wider, pass --input '{"maxFiles":50}'; to scope a subtree, '{"scopeDir":"src/api"}'.
Manual fallback only when the runner is unavailable: run node "<plugin root>/scripts/cmd/deep-scan-prepare.mjs" --target "<repo root>", read each listed file in full, write { candidates: [...] } to draftPath, then run the returned assembleCommand.
For each file, emit hypotheses: verdict (finding / candidate / rejected), a rationale (the trusted assumption that breaks + the attacker path), cwe, and evidenceAnchors.
Pipeline to verification — use the panel by default. Deep-read findings are strong leads but were not gated by a deterministic rule, so they carry the highest false-positive risk. Run /verify --input '{"panel":3}' on them: the multi-lens majority (reachability / guard-bypass / impact) is what keeps the extra recall from arriving as noise. Single-pass /verify is fine for pattern-gated findings; for deep-scan leads the panel is the default, not the exception.
Report the findings, and explicitly state the unreadCount so coverage stays honest — offer a follow-up /deep-scan over the remainder if it's non-zero.

When NOT to use

For a fast, cheap pass over known bug-classes — use the pattern producers (/taint-analysis, /authz, /logic-hunt, /crypto-review, /systems-hunt). Deep-scan is for depth and the long tail, and it costs real tokens.
On a tiny diff — use /diff-review. On a single known file — read it directly.
To confirm an existing finding — that's /verify / /poc.

Rationalizations to Reject

"The pattern scanners already ran, so the repo's covered." → They only saw lines a regex matched. The whole point of deep-scan is the bugs no pattern names; running it is how you find them, not a duplicate pass.
"maxFiles covered the important stuff, ignore unreadCount." → unreadCount > 0 means the repo is not fully read. Report it and offer the follow-up pass; never imply full coverage you didn't achieve.
"Reading every file is too expensive." → That's why it's risk-ranked and budgeted. The trade is tokens-for-recall, made explicitly — not skipped silently.
"It looks like normal framework code." → Framework-shaped code with a custom wrapper is exactly where the pattern tools fail and deep reading wins. Judge the behavior.

Más de este repositorio

mismo repositorio

deep-hunt

allsmog/kuzushi-security-plugin

Interprocedural, hypothesis-driven hunt — finds the multi-file source→sink bugs that pattern-gating and same-file taint miss. Ranks trace anchors (entry points + dangerous sinks), then the deep-hunter agent walks each flow ACROSS files (forward/backward call-graph CLIs) over multiple rounds, confirming propagation and defeating guards, and promotes confirmed cross-file flows into findings.json with the path stored as evidenceGraph. Token-expensive, budget-bounded. Part of the HUNT phase (run via /sweep --deep, or ask for it); leads flow to /verify (panel).

2026-06-110

taint-analysis

allsmog/kuzushi-security-plugin

IRIS-style source→sink taint hunt. Ranks a typed CWE catalog for the repo, then drives subagents to label dangerous sinks, label sources of user input, run Joern/CodeQL dataflow queries (or same-file linking) to connect them, and triage each flow as finding/candidate/rejected. Promotes verdicts into .kuzushi/findings.json. Benefits from a prebuilt CodeQL DB / Joern CPG but degrades gracefully.

2026-06-110

threat-hunt

allsmog/kuzushi-security-plugin

Adversarial per-threat review (Carlini doctrine). For each threat in .kuzushi/threat-model.json, state attacker capabilities, walk source→sink, attempt to bypass every guard, and assign a verdict with evidence. Promotes findings into .kuzushi/findings.json. Requires /threat-model first.

2026-06-110

partition

allsmog/kuzushi-security-plugin

Split the attack surface into parallel-discovery partitions so fan-out hunters explore different subsystems instead of converging on the same shallow bug. Deterministic grouping of /x-ray entry points by component → .kuzushi/partitions.json, which a hunt coordinator hands to one subagent per partition. Run /x-ray first.

2026-06-100

poc

allsmog/kuzushi-security-plugin

Empirical proof-of-concept for the PoC-ready findings. For each finding /verify marked confirmed-exploitable or inconclusive, synthesize a minimal harness that triggers the bug; a host script then runs it in a sandbox (Docker --network none when present, else a gated local run) and classifies the crash into a proof verdict. Attaches a poc block onto each finding. Requires /verify first.

2026-06-100

benchmark

allsmog/kuzushi-security-plugin

Measure recall / precision / false-proof rate of the pipeline against a ground-truth manifest. Scores either the bundled planted-vulnerability corpus (regression) or a live run's findings.json against a manifest you supply. Deterministic — no agent, no network. Use to prove a change to the producers helps rather than hurts.

2026-06-100

name	deep-scan
description	Whole-file deep reader — finds bugs by READING risk-ranked files in full and reasoning from first principles, not by grepping for known patterns. Catches the long tail (project-specific wrappers, business logic, cross-function flaws) that pattern-gated producers structurally miss. Token-expensive; budget-bounded and risk-ranked. Promotes leads into .kuzushi/findings.json (source "deep-scan").
context	command
runner	scripts/cmd/deep-scan-run.mjs
user-invocable	false

Deep scan

Prefer the provider-neutral command: KUZUSHI_MODEL="${KUZUSHI_MODEL:-openai-codex:gpt-5.5}" node "<plugin root>/scripts/cmd/deep-scan-run.mjs" --target "<repo root>". It performs prepare -> configured LLM bridge -> finalize without depending on a Claude subagent runtime. To go wider, pass --input '{"maxFiles":50}'; to scope a subtree, '{"scopeDir":"src/api"}'.
Manual fallback only when the runner is unavailable: run node "<plugin root>/scripts/cmd/deep-scan-prepare.mjs" --target "<repo root>", read each listed file in full, write { candidates: [...] } to draftPath, then run the returned assembleCommand.
For each file, emit hypotheses: verdict (finding / candidate / rejected), a rationale (the trusted assumption that breaks + the attacker path), cwe, and evidenceAnchors.
Pipeline to verification — use the panel by default. Deep-read findings are strong leads but were not gated by a deterministic rule, so they carry the highest false-positive risk. Run /verify --input '{"panel":3}' on them: the multi-lens majority (reachability / guard-bypass / impact) is what keeps the extra recall from arriving as noise. Single-pass /verify is fine for pattern-gated findings; for deep-scan leads the panel is the default, not the exception.
Report the findings, and explicitly state the unreadCount so coverage stays honest — offer a follow-up /deep-scan over the remainder if it's non-zero.

When NOT to use

For a fast, cheap pass over known bug-classes — use the pattern producers (/taint-analysis, /authz, /logic-hunt, /crypto-review, /systems-hunt). Deep-scan is for depth and the long tail, and it costs real tokens.
On a tiny diff — use /diff-review. On a single known file — read it directly.
To confirm an existing finding — that's /verify / /poc.

Rationalizations to Reject

"The pattern scanners already ran, so the repo's covered." → They only saw lines a regex matched. The whole point of deep-scan is the bugs no pattern names; running it is how you find them, not a duplicate pass.
"maxFiles covered the important stuff, ignore unreadCount." → unreadCount > 0 means the repo is not fully read. Report it and offer the follow-up pass; never imply full coverage you didn't achieve.
"Reading every file is too expensive." → That's why it's risk-ranked and budgeted. The trade is tokens-for-recall, made explicitly — not skipped silently.
"It looks like normal framework code." → Framework-shaped code with a custom wrapper is exactly where the pattern tools fail and deep reading wins. Judge the behavior.