Run any Skill in Manus with one click

deep-scan

Stars0

Forks0

UpdatedJune 11, 2026 at 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").

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

allsmog

allsmog/kuzushi-security-plugin

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Information Security AnalystsComputer and Mathematical Occupations·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.

More from this repository

same repository

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.