lattice rung 13: detector-driven Evidence-DAG disintegration loop

[mattmre]

Summary

Phase II rung 13 (disintegration loop) — the genuine detector-driven Evidence-DAG edge prune the
ROADMAP exit criteria name. isomer_detector (per-query isomer strength) and convergence_monitor
(per-cluster stability summary) score Evidence-DAG edge fitness; low-fitness edges are pruned with a
transactional re-anneal path and a before/after fitness artifact. Closes rung 13 (was PARTIAL:
post-bank prune only, not the isomer/convergence → DAG prune the criteria require).

Stacked on #292 (base = lattice/phase2-continue-20260713); this PR's own diff is the two rung-13
commits. Retarget to main once #292 merges.

What it does

• evidence_dag_disintegration.py — maps real detector outputs to edge fitness: IsomerDetector
  strength → fitness = 1 − strength (exact query-node join); ConvergenceMonitor.get_summary() →
  1 − epochs_without_improvement/patience (per cluster). Deterministic, pure.
• EvidenceDAG.prune_edges(scorer, threshold, dry_run=…) + reanneal_edges(...) + a pruned-edge
  ledger, in evidence_dag.py. Never removes nodes; preserves validate_evidence_dag.
• write_disintegration_artifact(...) — fitness before/after + detector provenance.
• docs/rung13-disintegration-loop.md.

Fail-closed design (load-bearing)

Missing / unmatched / immature detector signals → neutral fitness 1.0, so absent evidence can never
prune; an all-healthy DAG prune is a verified no-op. prune_edges scores over a snapshot and
rejects a scorer that mutates the DAG mid-pass (RuntimeError) rather than dropping unledgered
edges. prune_edges/reanneal_edges are transactional (state restored on a scorer exception). The
1 − strength map is sedimentation-specific, so a non-sedimentation isomer mode is rejected
(chelation high-strength can mean the correction worked, not that the edge is unfit).

Adversarial review

First-cut Grok Tier B scored 94 (MEDIUM: fail-closed untested; LOW: mutating-scorer drop; LOW nits).
All four gaps fixed (dedicated fail-closed tests, snapshot + mutation reject, mode guard, plateau
assert); a fresh Grok Tier B re-scored the amended commit 100 / severity none, running the suite
itself (27 tests OK, DAG valid after prune/reanneal).

EVIDENCE: evidence_dag_disintegration.py (real IsomerDetector/ConvergenceMonitor field mapping) + evidence_dag.py prune_edges/reanneal ledger + write_disintegration_artifact + docs/rung13-disintegration-loop.md
SMOKE: python -m unittest test_evidence_dag_disintegration test_evidence_dag -> Ran 27 tests OK (chair-run, offline); ruff clean; validate_evidence_dag empty after prune and after reanneal
BHS_SELF_DRAFT: 100
BHS_SELF_DRAFT_AGENT: Fable-5 (chair / implementer)
BHS_TIER_B: 100
BHS_TIER_B_AGENT: grok-4.5 (fresh adversarial reviewer, independent of implementer; re-scored the amended commit after fixes)
BHS_TIER_B_SEVERITY: none
BHS_OFFICIAL: 100
CARRY_FORWARD: none
DEFERRED_SCOPE: engine-side auto-prune cadence (a live prune frequency needs a campaign to justify); optional harden of the mode=None isomer-input edge case (production detectors always set mode)
LOOP_ITERATIONS: 2
OPERATOR_OVERRIDE: none

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request implements Phase II Step 13 (Disintegration loop) of the roadmap, introducing detector-driven Evidence-DAG disintegration and re-annealing. It adds the prune_edges method to EvidenceDAG to remove low-fitness edges, implements reanneal_edges to restore recovered edges, and provides utility functions to map IsomerDetector and ConvergenceMonitor outputs to edge fitness. Comprehensive unit tests and documentation are also added. The review feedback suggests two key improvements: validating the DAG at the start of reanneal_edges to avoid silent failures if the DAG is already invalid, and comparing the full edge list rather than just its length to robustly detect scorer mutations during pruning.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

If the EvidenceDAG is already invalid before calling reanneal_edges, validate_evidence_dag(dag) will fail for every edge attempt inside the loop. This causes all edges to be silently skipped and marked as skip_invalid with misleading violations, even if the edges themselves are perfectly valid. We should validate the DAG at the start of reanneal_edges and raise a ValueError if it is already invalid, consistent with prune_edges.

Suggested change

	threshold = _bounded_float(threshold, "threshold")
	before = len(dag.edges)
	threshold = _bounded_float(threshold, "threshold")
	violations = validate_evidence_dag(dag)
	if violations:
	raise ValueError("cannot re-anneal on an invalid EvidenceDAG: " + "; ".join(violations))
	before = len(dag.edges)

[gemini-code-assist]

Comparing only the length of self._edges and edge_snapshot is not sufficient to detect if the scorer mutated the list (e.g., by replacing elements or changing their order while keeping the length identical). Comparing the lists directly with self._edges != edge_snapshot is a more robust way to detect any mutation.

Suggested change

	if len(self._edges) != len(edge_snapshot):
	raise RuntimeError(
	"scorer mutated the DAG edge set during prune_edges; refusing to apply "
	"a prune computed over a stale snapshot"
	)
	if self._edges != edge_snapshot:
	raise RuntimeError(
	"scorer mutated the DAG edge set during prune_edges; refusing to apply "
	"a prune computed over a stale snapshot"
	)