Run any Skill in Manus with one click

path-solve

Stars0

Forks0

UpdatedMay 29, 2026 at 02:51

Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.

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

Software DevelopersComputer and Mathematical Occupations·SOC 15-1252

SKILL.md

readonly

name	path-solve
description	Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.
context	fork
agent	path-solver
user-invocable	false

Path solve

Get past the guards that left a sink unreachable.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/path-solve-prepare.mjs" --target "<repo root>" (optionally --input '{"fingerprints":["<fp>"]}' to target specific findings). If it reports no-candidates, tell the user to run /verify first (it surfaces the inconclusive findings worth solving) and stop.
Read the prep's prepPath. For each candidate, extract the path predicate between the source and sink (tree_sitter:node_at parent chain + tree_sitter:query for branch conditions across the functions on the path, using graphContext), then solve it: concolic:z3_solve for numeric/string predicates, concolic:crosshair for Python, else reason the input out (LLM). Decide reachable + a concrete solvedInput, or list the blocking guard in unsolvedGuards.
Write the { candidates: [...] } bundle to the prep's draftPath, then run the assembleCommand — it validates and attaches a pathSolution block onto each finding (no verdict change).
Report, per finding: guards extracted, backend used, reachable?, the solved input (or blocking guard). Note /verify can turn a reachable solution into a confirmed trigger and /fuzz can seed the corpus from it.

When NOT to use

Before /verify has produced inconclusive / needs-trace findings (nothing hard-to-reach) — unless you pass explicit fingerprints.
To render the exploitability verdict — that's /verify; this produces reach evidence.
For reachability that needs real symbolic execution of allocator/heap state — out of scope; this solves input predicates only.

Rationalizations to Reject

"An input was found, so it's exploitable." → That's reachable evidence at the stated confidence, not a proof; /verify + /poc adjudicate. Don't inflate confidence.
"That guard looks hard — unreachable." → Try Z3/CrossHair and a concrete assignment first; only reachable:false when a guard is genuinely unsatisfiable, and name it.
"Skip the predicate, just guess a payload." → The path predicate is the deliverable; a bare guess is what /verify already couldn't produce.

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

deep-scan

allsmog/kuzushi-security-plugin

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

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

name	path-solve
description	Concolic-lite path-constraint solving for hard-to-reach sinks. For findings /verify left inconclusive, the path-solver agent extracts the guard predicate between source and sink and solves it into a concrete reaching input — via the concolic MCP backend (Z3 / CrossHair) when installed, else by reasoning (LLM). Attaches a pathSolution block; feeds /verify and /fuzz. Heuristic, not a proof.
context	fork
agent	path-solver
user-invocable	false

Path solve

Get past the guards that left a sink unreachable.

Run node "${CLAUDE_PLUGIN_ROOT}/scripts/cmd/path-solve-prepare.mjs" --target "<repo root>" (optionally --input '{"fingerprints":["<fp>"]}' to target specific findings). If it reports no-candidates, tell the user to run /verify first (it surfaces the inconclusive findings worth solving) and stop.
Read the prep's prepPath. For each candidate, extract the path predicate between the source and sink (tree_sitter:node_at parent chain + tree_sitter:query for branch conditions across the functions on the path, using graphContext), then solve it: concolic:z3_solve for numeric/string predicates, concolic:crosshair for Python, else reason the input out (LLM). Decide reachable + a concrete solvedInput, or list the blocking guard in unsolvedGuards.
Write the { candidates: [...] } bundle to the prep's draftPath, then run the assembleCommand — it validates and attaches a pathSolution block onto each finding (no verdict change).
Report, per finding: guards extracted, backend used, reachable?, the solved input (or blocking guard). Note /verify can turn a reachable solution into a confirmed trigger and /fuzz can seed the corpus from it.

When NOT to use

Before /verify has produced inconclusive / needs-trace findings (nothing hard-to-reach) — unless you pass explicit fingerprints.
To render the exploitability verdict — that's /verify; this produces reach evidence.
For reachability that needs real symbolic execution of allocator/heap state — out of scope; this solves input predicates only.

Rationalizations to Reject

"An input was found, so it's exploitable." → That's reachable evidence at the stated confidence, not a proof; /verify + /poc adjudicate. Don't inflate confidence.
"That guard looks hard — unreachable." → Try Z3/CrossHair and a concrete assignment first; only reachable:false when a guard is genuinely unsatisfiable, and name it.
"Skip the predicate, just guess a payload." → The path predicate is the deliverable; a bare guess is what /verify already couldn't produce.