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.
64 lines
2.0 KiB
Python
64 lines
2.0 KiB
Python
#!/usr/bin/env python3
|
|
"""Fail-closed marker for a dead verify branch of the finding-verifier graph.
|
|
|
|
Reached ONLY via verify_one's `fallback:` route inside the map branch.
|
|
Grounded in engine behavior: on llm-node failure the engine writes
|
|
"LLM node failed: <chain>" into `verdict` via the node's state_updates
|
|
BEFORE routing to the fallback, so the raw failure text is already in
|
|
state. This node normalizes it into a schema-conformant UNVERIFIABLE
|
|
verdict (authoritative id stamped from the finding item, mirroring
|
|
verdict_gate.py) and the chain ends there — the map collects a valid
|
|
verdict, so a dead verifier lane never sinks the whole map or masquerades
|
|
as verified.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
|
|
MAX_DETAIL_CHARS = 500
|
|
|
|
|
|
def load_state():
|
|
if path := os.environ.get("GRAPH_STATE_FILE"):
|
|
with open(path) as f:
|
|
return json.load(f)
|
|
return json.loads(os.environ.get("GRAPH_STATE", "{}"))
|
|
|
|
|
|
def finding_id(state):
|
|
finding = state.get("finding")
|
|
if isinstance(finding, dict):
|
|
fid = finding.get("id")
|
|
if isinstance(fid, str) and fid.strip():
|
|
return fid.strip()
|
|
return "unknown"
|
|
|
|
|
|
def fault_verdict(fid, detail):
|
|
return {
|
|
"verdict": {
|
|
"id": fid,
|
|
"verdict": "UNVERIFIABLE",
|
|
"evidence": "",
|
|
"note": f"PIPELINE-FAULT: verifier lane failed after retries — {detail}",
|
|
}
|
|
}
|
|
|
|
|
|
def main():
|
|
state = load_state()
|
|
fid = finding_id(state)
|
|
raw = state.get("verdict")
|
|
detail = raw.strip().replace("\n", " ") if isinstance(raw, str) else ""
|
|
if not detail.startswith("LLM node"):
|
|
detail = "the verifier lane died without recording a failure detail"
|
|
if len(detail) > MAX_DETAIL_CHARS:
|
|
detail = detail[: MAX_DETAIL_CHARS - 1] + "…"
|
|
print(json.dumps(fault_verdict(fid, detail)))
|
|
|
|
|
|
try:
|
|
main()
|
|
except Exception as e: # noqa: BLE001 — the fault marker itself must never crash
|
|
print(json.dumps(fault_verdict("unknown", f"fault-marker script error: {e}")))
|