Dark-Alex-17
4263d684e9
finding-verifier: parse gains max_attempts 2 + parse_failure capture +
fallback to a new parse_fault marker that rewrites verdicts to a single
UNVERIFIABLE PIPELINE-FAULT entry and continues to done (sentinel
preserved — the caller's verify lane degrades instead of dying);
verify_one gains a branch-local verify_fault marker normalizing the
engine failure text into a schema-conformant UNVERIFIABLE verdict.
step-runner: implement gains fallback end_failure (no retry — reruns
against a mutated tree are unsafe; STEP_FAILED renders the failure via
coder_result); independent_review gains fallback write_handoff with the
handoff instructions and route_review treating an "Agent node failed:"
review_report as review-did-not-run (fail-visible, guard ahead of the
🔴 grep); orient/edge_case_sweep/write_handoff capture their failure
text via state_updates, shrinking the bundled fallback-capture warning
baseline back to zero.
R5 tests: fault-marker normalization + crash paths (raw non-JSON
GRAPH_STATE), route_review.sh fault/critical/clean routing via bash+jq,
and structural wiring tests pinning fallbacks, sentinels, and
end_failure's initial_state-backed template keys.
finding-verifier
A graph agent that independently verifies code-review findings against the working tree. It exists because false positives kill hands-off trust faster than missed bugs do — and because an orchestrator verifying its own workers' findings inline can skip, fudge, or confirmation-bias the check. A graph can't: the structure IS the discipline.
How it works
parse (llm) ──▶ verify_each (map, max_concurrency 4) ──▶ done (end)
└─▶ verify_one (llm + fs tools) ──▶ verdict_gate (script), one CHAIN per finding
-
parse — extracts every 🔴/🟡 finding from the spawn prompt into a structured list (id, severity verbatim, path, lines, self-contained claim). Extraction only — no judging.
-
verify_each — a
mapnode fans out oneverify_onebranch per finding. Skipping a finding is structurally impossible; results collect in input order. -
verify_one — reads the cited code (greps for moved code before concluding anything) and answers ONE narrow question: does the cited code exist, and does it behave as the claim says? Verdicts:
VERIFIED— with the decisive line(s) quoted verbatim (path:line).FALSE— the code doesn't exist anywhere or provably doesn't do what the claim says. Requires PROOF, not disagreement — doubt never lands here.UNVERIFIABLE— couldn't establish either way (runtime behavior, external systems).
Each branch is a chain:
verify_one → verdict_gate. The gate machine-validates the JSON contract (verdict enum; evidence required for VERIFIED/FALSE; note for UNVERIFIABLE), stamps the authoritative id FROM the finding item (the model's echo is never trusted), rejects back toverify_oneexactly once with the reason, and on a second failure records UNVERIFIABLE — a malformed branch never sinks the map. Kept, marked unverified. -
done — a deterministic
endnode emits the raw verdict list plus the caller contract (VERIFIED = keep + paste evidence; FALSE = drop + tally; UNVERIFIABLE = keep, marked). No final LLM step that could editorialize.
What it is NOT
- Not a second opinion. It never re-judges severity, style, or whether a finding "matters" — that authority stays with the reviewers and the orchestrator's rigor rules.
- Not a reviewer. It reads only what findings cite (plus greps to locate moved code).
Caller
Spawned by code-reviewer during its Finding Verifier
pass, ONCE per review, with the full 🔴/🟡 list and project_dir. If this agent isn't
installed, code-reviewer runs the same contract inline as a fallback.
Files
graph.yaml— the agent (no tools.sh; the graph grantsfs_read/fs_cat/fs_grepper node).