codereview-loop 0.13.0__py3-none-any.whl

codereview/__init__.py

@@ -0,0 +1,6 @@
+"""codereview — multi-model code review with a deterministic gate."""
+
+from .core import VERSION, run_review, run_verification
+
+__all__ = ["VERSION", "run_review", "run_verification"]
+__version__ = VERSION

codereview/__main__.py

@@ -0,0 +1,4 @@
+from .cli import console_main
+
+if __name__ == "__main__":
+    raise SystemExit(console_main())

codereview/acceptance.py

@@ -0,0 +1,649 @@
+"""Tech Lead acceptance runner (refutation-process solution
+§6, owner-adopted 2026-11-04): run the SHADOW Tech Lead over
+the known-answer corpus at ~/workspace/codereview-acceptance/
+and score the adopted gates M1–M6.
+
+The corpus is the contract: case sets, scoring rules and
+thresholds are read from the corpus's scorecard.json, never
+hardcoded here. Scoring follows the scorecard's
+scored-decision definition — probes are NOT executed (probe
+results ship inside the cases and are presented as context);
+a needs_probe outcome scores as escalate; a decision whose
+deciding quote does not validate scores as escalate (the
+shadow draw machinery already enforces that normalization).
+
+The machinery stratum's isolation rule is honoured by
+construction: shadow adjudication never consults the
+precedent store, and every (case, variant) run uses a fresh
+decision cache.
+
+Protocol v2 (`run_acceptance_v2`) scores the redesigned
+adjudicator (techlead.adjudicate) through the SAME scorer
+and the SAME metric computation (`_scorecard_metrics`) —
+M1 is counted by scored decision over the scorecard's
+real-finding set, exactly as the scorecard's
+counting_rules define a false dismissal; the per-case
+`false_dismissal` flag score_case returns is never set
+by the scorer and is not used (it disagreed with the M1
+metric in the v1 run record — the metric follows the
+scorecard, the flag is vestigial). The two adjudication
+paths are reported separately in the v2 record, never
+blended: deterministic-path cases are decided by the
+probe, so they take no verdict draws and fall outside
+M6's measured set, which is stated on the record.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+from . import core
+from . import techlead
+
+
+def load_corpus(corpus_dir):
+    def read(name):
+        with open(os.path.join(corpus_dir, name),
+                  encoding="utf-8") as fh:
+            return json.load(fh)
+
+    index = read("index.json")
+    cases = {}
+    for item in index["cases"]:
+        cid = item["case_id"]
+        cases[cid] = read(os.path.join("cases", f"{cid}.json"))
+    return {"index": index, "scorecard": read("scorecard.json"),
+            "mutations": read("mutations.json"), "cases": cases}
+
+
+def _independence(seat_family, raiser_fam, refuter_fam):
+    if seat_family in (raiser_fam, refuter_fam, "unknown", None):
+        return "reduced"
+    return "independent"
+
+
+def case_inputs(case, seat_family, *, family_swap=False,
+                vendor_strip=False, paraphrase=None):
+    """Map a corpus case to (finding, dispute, region,
+    independence) for shadow_adjudicate, applying the
+    requested mutation to the PRESENTED inputs only — quotes
+    and the code region are never mutated."""
+    f0 = case["finding"]
+    r0 = case["refutation"]
+    evidence = f0.get("evidence") or f0.get("claim") or ""
+    reason = r0.get("reason") or ""
+    if paraphrase is not None:
+        evidence, reason = paraphrase
+    if vendor_strip:
+        evidence = core._scrub_vendor(evidence)
+        reason = core._scrub_vendor(reason)
+    raiser_fam = f0.get("raised_by_family")
+    refuter_fam = r0.get("by_family")
+    if family_swap:
+        raiser_fam, refuter_fam = refuter_fam, raiser_fam
+    finding = {
+        "id": case["case_id"],
+        "file": f0.get("file"), "line": f0.get("line"),
+        "severity": f0.get("severity_as_raised"),
+        "title": f0.get("claim") or "",
+        "evidence": evidence,
+        "evidence_quote": f0.get("evidence_quote") or ""}
+    # Cited-line discipline at input-build time (P06): a
+    # stored region that does not contain the finding's cited
+    # line marks the input region_unverified, so the produced
+    # record says loudly that the presented region may not be
+    # the finding's site — instead of the seat silently
+    # judging a sibling call site.
+    if core.region_unverified_for(
+            case.get("code_region"), f0.get("line"),
+            f0.get("evidence_quote") or ""):
+        finding["region_unverified"] = True
+    dispute = {
+        "by": "refuter", "family": refuter_fam,
+        "raiser_family": raiser_fam,
+        "evidence_quote": r0.get("quote") or "",
+        "reason": reason}
+    region = (case.get("code_region") or {}).get("text") or ""
+    return finding, dispute, region, _independence(
+        seat_family, raiser_fam, refuter_fam)
+
+
+def scored_decision(entry):
+    """The scored decision per scorecard.json: the entry's
+    final decision, with every non-decision state normalized
+    to escalate."""
+    decision = (entry or {}).get("decision")
+    if decision in ("sustain_finding", "sustain_refutation"):
+        return decision
+    return "escalate"
+
+
+def scored_severity(entry):
+    return ((entry or {}).get("severity_after_rubric") or {}
+            ).get("level")
+
+
+def score_case(case, entry):
+    """Score one baseline entry under the case's own scoring
+    rule. Returns {"correct", "false_dismissal",
+    "scored_decision"}."""
+    expected = case.get("expected") or {}
+    rule = expected.get("scoring") or "exact"
+    scored = scored_decision(entry)
+    out = {"correct": False, "false_dismissal": False,
+           "scored_decision": scored, "rule": rule}
+    if rule == "dismissal_evidence_rule":
+        if scored == "escalate":
+            out["correct"] = True
+        elif scored == "sustain_refutation":
+            quote = ((entry.get("deciding_evidence") or {})
+                     .get("quote") or "")
+            region = (case.get("code_region") or {}).get(
+                "text") or ""
+            refuter_quote = (case.get("refutation") or {}).get(
+                "quote") or ""
+            f0 = case.get("finding") or {}
+            claim_text = (str(f0.get("claim") or "") + "\n"
+                          + str(f0.get("evidence") or ""))
+            # The same dismissal-evidence rule the draw
+            # machinery enforces (L06): grounded, distinct
+            # from the refuter's quote, and relevant to the
+            # claim — scored here independently so a record
+            # produced by any path is judged by the full rule.
+            out["correct"] = bool(
+                quote
+                and core._quote_grounded(quote, region)
+                and core._dismissal_quote_check(
+                    quote, refuter_quote,
+                    claim_text)["eligible"])
+        return out
+    if rule == "machinery_two_field":
+        want = expected.get("decision")
+        if want == "refutation_rejected":
+            decision_ok = scored == "sustain_finding"
+        else:
+            decision_ok = scored == want
+        validity = expected.get("reasoning_validity") or {}
+        assess = entry.get("reasoning_assessment") or {}
+        claim_ok = ("true" if assess.get("claim_valid")
+                    else "false") == validity.get("claim")
+        refutation_ok = assess.get(
+            "refutation_validity") == validity.get("refutation")
+        out["correct"] = bool(
+            decision_ok and claim_ok and refutation_ok)
+        out["reasoning_match"] = {
+            "claim": claim_ok, "refutation": refutation_ok}
+        return out
+    # exact
+    if scored != expected.get("decision"):
+        return out
+    want_sev = expected.get("severity_after")
+    if want_sev is not None \
+            and scored_severity(entry) != want_sev:
+        return out
+    out["correct"] = True
+    return out
+
+
+_PARAPHRASE_PROMPT = (
+    "Paraphrase the following text, preserving every factual "
+    "claim and its direction exactly, changing only the "
+    "wording. Return ONLY the paraphrased text.\n\n{text}")
+
+
+def _paraphrase(seat_fn, text, timeout):
+    """One paraphrase call through the seat itself (the
+    mutation protocol allows an LLM paraphrase under a
+    semantics-preserving instruction). Plain-text call — the
+    JSON job machinery does not apply; the seat's own
+    transport timeout bounds it. A failed paraphrase keeps
+    the original text and the case is scored as-is."""
+    if not text:
+        return text
+    try:
+        out = seat_fn(_PARAPHRASE_PROMPT.format(text=text[:4000]))
+    except Exception:  # noqa: BLE001
+        return text
+    return str(out).strip() or text
+
+
+def _scorecard_metrics(cases, baseline, scores, scorecard,
+                       *, flips, do_mutations, log):
+    """The M1–M6 measurements against the scorecard's own
+    sets and thresholds — the single counting implementation
+    both protocol runners share, so a v1 and a v2 record can
+    never drift apart in what the numbers mean. M1 counts
+    false dismissals BY SCORED DECISION over the scorecard's
+    real-finding set (the scorecard's counting_rules), never
+    by score_case's per-case false_dismissal flag, which the
+    scorer never sets. With do_mutations False, M4 is
+    measured None and passes False: an unmeasured gate does
+    not pass."""
+    metrics_spec = {m["id"]: m
+                    for m in scorecard.get("metrics") or []}
+
+    def metric_set(mid):
+        spec = metrics_spec.get(mid) or {}
+        s = spec.get("set")
+        if isinstance(s, list):
+            return s
+        return sorted(cases)
+
+    def threshold(mid):
+        spec = metrics_spec.get(mid) or {}
+        return spec.get("threshold") or {}
+
+    def passes(value, mid):
+        th = threshold(mid)
+        op, want = th.get("op"), th.get("value")
+        if op == "==":
+            return value == want
+        if op == ">=":
+            return value >= want
+        if op == "<=":
+            return value <= want
+        return False
+
+    def present(mid, ids, table):
+        """The scorecard's metric set restricted to case ids
+        this run actually produced. An explicit set naming
+        cases absent from the corpus (mismatch, or an empty
+        corpus under the shipped scorecard) must score over
+        what exists — with the gap logged — never die on a
+        bare KeyError (633acb885291)."""
+        kept = [cid for cid in ids if cid in table]
+        if len(kept) != len(ids):
+            log(f"scorecard {mid}: {len(ids) - len(kept)} "
+                f"set case id(s) absent from the corpus — "
+                f"scored over {len(kept)} present case(s)")
+        return kept
+
+    # M1: false dismissals on the real-finding set.
+    m1_set = present("M1_false_dismissals_on_real_findings",
+                     metric_set(
+                         "M1_false_dismissals_on_real_findings"),
+                     baseline)
+    m1 = sum(1 for cid in m1_set
+             if scored_decision(baseline[cid])
+             == "sustain_refutation")
+    # M2: accuracy on the probe-settled set.
+    m2_set = present("M2_probe_settled_accuracy",
+                     metric_set("M2_probe_settled_accuracy"),
+                     scores)
+    m2 = (sum(1 for cid in m2_set if scores[cid]["correct"])
+          / len(m2_set)) if m2_set else 0.0
+    # M3: overall accuracy — guarded like M2/M5: an empty
+    # corpus measures 0.0, it does not divide by zero.
+    m3 = (sum(1 for c in scores.values() if c["correct"])
+          / len(scores)) if scores else 0.0
+    # M4: mutation flip rate.
+    total_flips = sum(len(v) for v in flips.values())
+    denom = len(cases) * len(flips) if do_mutations else 0
+    m4 = (total_flips / denom) if denom else None
+    # M5: protected + insufficient all escalated.
+    m5_set = present(
+        "M5_protected_and_insufficient_escalated",
+        metric_set("M5_protected_and_insufficient_escalated"),
+        baseline)
+    m5 = (sum(1 for cid in m5_set
+              if scored_decision(baseline[cid]) == "escalate")
+          / len(m5_set)) if m5_set else 0.0
+    # M6: double-draw agreement on majors.
+    major_ids = [cid for cid, c in cases.items()
+                 if (c["finding"].get("severity_as_raised")
+                     in ("blocker", "major"))]
+    agreed = [cid for cid in major_ids
+              if baseline[cid].get("draws_agree") is True]
+    measured = [cid for cid in major_ids
+                if baseline[cid].get("draws_agree") is not None]
+    m6 = (len(agreed) / len(measured)) if measured else None
+
+    metrics = {
+        "M1_false_dismissals_on_real_findings": {
+            "measured": m1, "threshold": threshold(
+                "M1_false_dismissals_on_real_findings"),
+            "pass": passes(
+                m1, "M1_false_dismissals_on_real_findings"),
+            "set_size": len(m1_set)},
+        "M2_probe_settled_accuracy": {
+            "measured": m2, "threshold": threshold(
+                "M2_probe_settled_accuracy"),
+            "pass": passes(m2, "M2_probe_settled_accuracy"),
+            "set_size": len(m2_set)},
+        "M3_overall_accuracy": {
+            "measured": m3,
+            "threshold": threshold("M3_overall_accuracy"),
+            "pass": passes(m3, "M3_overall_accuracy"),
+            "set_size": len(scores)},
+        "M4_mutation_flip_rate": {
+            "measured": m4,
+            "threshold": threshold("M4_mutation_flip_rate"),
+            "pass": bool(do_mutations) and m4 is not None
+            and passes(m4, "M4_mutation_flip_rate"),
+            "flips": flips, "denominator": denom},
+        "M5_protected_and_insufficient_escalated": {
+            "measured": m5, "threshold": threshold(
+                "M5_protected_and_insufficient_escalated"),
+            "pass": passes(
+                m5, "M5_protected_and_insufficient_escalated"),
+            "set_size": len(m5_set)},
+        "M6_double_draw_agreement_on_majors": {
+            "measured": m6, "threshold": threshold(
+                "M6_double_draw_agreement_on_majors"),
+            "pass": m6 is not None and passes(
+                m6, "M6_double_draw_agreement_on_majors"),
+            "majors": len(major_ids),
+            "measured_cases": len(measured),
+            "agreed_cases": len(agreed)},
+    }
+    return metrics
+
+
+def run_acceptance(corpus_dir, seat_fn, *, seat_family,
+                   seat_name="acceptance-tech-lead",
+                   do_mutations=True, timeout=180, log=None):
+    """Run the full acceptance protocol and return the run
+    record: per-case entries and scores, mutation flips, and
+    the M1–M6 measurements against the scorecard's own
+    thresholds. The unlock verdict requires EVERY gate metric
+    to pass on this single run."""
+    log = log or (lambda _msg: None)
+    corpus = load_corpus(corpus_dir)
+    cases = corpus["cases"]
+    scorecard = corpus["scorecard"]
+    metrics_spec = {m["id"]: m
+                    for m in scorecard.get("metrics") or []}
+
+    def adjudicate(case, **kw):
+        finding, dispute, region, indep = case_inputs(
+            case, seat_family, **kw)
+        return core.shadow_adjudicate(
+            seat_fn, finding, region, dispute,
+            seat_name=seat_name, seat_family=seat_family,
+            independence=indep, probe_fn=None,
+            probe_context=case.get("probe"), cache={},
+            timeout=timeout)
+
+    baseline = {}
+    scores = {}
+    for cid in sorted(cases):
+        entry = adjudicate(cases[cid])
+        baseline[cid] = entry
+        scores[cid] = score_case(cases[cid], entry)
+        log(f"baseline {cid}: {scored_decision(entry)} "
+            f"(correct={scores[cid]['correct']})")
+
+    mutation_ids = [m["id"] for m in
+                    (corpus["mutations"].get("mutations") or [])]
+    flips = {mid: [] for mid in mutation_ids}
+    paraphrases = {}
+    if do_mutations:
+        for cid in sorted(cases):
+            case = cases[cid]
+            base = (scored_decision(baseline[cid]),
+                    scored_severity(baseline[cid]))
+            for mid in mutation_ids:
+                if mid == "position_swap":
+                    # Force the opposite A/B order relative to
+                    # the baseline draw for this case.
+                    finding, dispute, region, indep = \
+                        case_inputs(case, seat_family)
+                    entry = core.shadow_adjudicate(
+                        seat_fn, finding, region, dispute,
+                        seat_name=seat_name,
+                        seat_family=seat_family,
+                        independence=indep, probe_fn=None,
+                        probe_context=case.get("probe"),
+                        cache={}, timeout=timeout,
+                        force_swap=True)
+                elif mid == "family_swap":
+                    entry = adjudicate(case, family_swap=True)
+                elif mid == "vendor_strip":
+                    entry = adjudicate(case, vendor_strip=True)
+                elif mid == "reason_paraphrase":
+                    pair = (
+                        _paraphrase(
+                            seat_fn,
+                            case["finding"].get("evidence")
+                            or case["finding"].get("claim")
+                            or "", timeout),
+                        _paraphrase(
+                            seat_fn,
+                            case["refutation"].get("reason")
+                            or "", timeout))
+                    paraphrases[cid] = {
+                        "evidence": pair[0], "reason": pair[1]}
+                    entry = adjudicate(case, paraphrase=pair)
+                else:
+                    continue
+                now = (scored_decision(entry),
+                       scored_severity(entry))
+                if now != base:
+                    flips[mid].append(cid)
+                log(f"mutation {mid} {cid}: {now[0]} "
+                    f"(flip={now != base})")
+
+    metrics = _scorecard_metrics(
+        cases, baseline, scores, scorecard,
+        flips=flips, do_mutations=do_mutations,
+        log=log)
+    # An empty corpus unlocks nothing, whatever the vacuous
+    # metrics say (633acb885291).
+    unlock = bool(cases) and all(
+        m["pass"] for m in metrics.values())
+    return {
+        "seat_family": seat_family, "seat_name": seat_name,
+        "corpus": corpus_dir,
+        "protocol_version": core.ADJUDICATION_PROTOCOL_VERSION,
+        "rubric_version": core.RUBRIC_VERSION,
+        "cases": {cid: {"entry": baseline[cid],
+                        "score": scores[cid]}
+                  for cid in sorted(cases)},
+        "paraphrases": paraphrases,
+        "metrics": metrics,
+        "unlock_all_gates_pass": unlock}
+
+
+# ------------------------------------------------------- protocol v2
+
+def adapt_v2_entry(entry):
+    """Map one protocol-v2 entry (techlead.adjudicate) onto
+    the shape score_case / _scorecard_metrics consume. The
+    mapping is field-for-field and invents nothing:
+
+      decision             <- entry decision (None unless the
+                              harness decided; the scorer
+                              normalises non-decisions to
+                              "escalate", as in v1)
+      severity_after_rubric<- entry severity_after_rubric
+      deciding_evidence    <- entry deciding_evidence (the
+                              dismissal-evidence scoring rule
+                              reads its quote)
+      draws_agree          <- entry draws_agree (None on the
+                              deterministic path and on
+                              routing escalations: those cases
+                              take no verdict draws)
+      reasoning_assessment <- entry reasoning_assessment —
+                              the seat's OWN two-field grading,
+                              recorded from the canonical draw.
+                              A v2 entry without one (the
+                              deterministic path takes no
+                              verdict draw) adapts to
+                              claim_valid False /
+                              refutation_validity None, which
+                              the two-field rule scores as a
+                              mismatch: the adapter reports the
+                              absence, it does not paper over it.
+
+    Every other v2 field (path, escalation rules, probe
+    adequacy, stage, draws) rides along untouched, so the run
+    record keeps the full v2 evidence next to the scores."""
+    out = dict(entry or {})
+    out["decision"] = out.get("decision")
+    sev = out.get("severity_after_rubric")
+    if not isinstance(sev, dict) or "level" not in sev:
+        out["severity_after_rubric"] = {
+            "level": None, "rubric_clause": None}
+    de = out.get("deciding_evidence")
+    if not isinstance(de, dict):
+        out["deciding_evidence"] = {"quote": ""}
+    assess = out.get("reasoning_assessment")
+    if not isinstance(assess, dict):
+        out["reasoning_assessment"] = {
+            "claim_valid": False, "refutation_validity": None}
+    else:
+        out["reasoning_assessment"] = {
+            "claim_valid": bool(assess.get("claim_valid")),
+            "refutation_validity":
+                assess.get("refutation_validity")}
+    return out
+
+
+def _path_metrics(cases, baseline, scores, scorecard):
+    """Per-path results for a v2 run record — reported
+    SEPARATELY, never blended (§3.3.2): the deterministic
+    path's numbers describe probe settlement + adequacy
+    grading; the model path's describe seat judgement.
+    Entries whose path is neither (protected-class and
+    independence routing escalations, seat unavailable) are
+    counted in their own bucket so the two path totals plus
+    the bucket reconcile to the corpus size."""
+    metrics_spec = {m["id"]: m
+                    for m in scorecard.get("metrics") or []}
+    spec = metrics_spec.get(
+        "M1_false_dismissals_on_real_findings") or {}
+    m1_set = spec.get("set")
+    if not isinstance(m1_set, list):
+        m1_set = []
+    out = {}
+    raw = [baseline[cid] for cid in sorted(baseline)]
+    for path in ("deterministic_probe", "model"):
+        sel = [cid for cid in sorted(baseline)
+               if baseline[cid].get("path") == path]
+        rules = {}
+        for cid in sel:
+            for rule in baseline[cid].get(
+                    "escalation_rules") or []:
+                rules[rule] = rules.get(rule, 0) + 1
+        out[path] = {
+            "total": len(sel),
+            "correct": sum(
+                1 for cid in sel if scores[cid]["correct"]),
+            "accuracy": (
+                sum(1 for cid in sel if scores[cid]["correct"])
+                / len(sel)) if sel else None,
+            "false_dismissals_on_m1_set": sum(
+                1 for cid in sel if cid in m1_set
+                and scored_decision(baseline[cid])
+                == "sustain_refutation"),
+            "escalated": sum(
+                1 for cid in sel
+                if scored_decision(baseline[cid])
+                == "escalate"),
+            "escalation_rules_fired": rules,
+            "cases": sel,
+        }
+    other = [cid for cid in sorted(baseline)
+             if baseline[cid].get("path")
+             not in ("deterministic_probe", "model")]
+    out["routing_or_unavailable"] = {
+        "total": len(other),
+        "correct": sum(
+            1 for cid in other if scores[cid]["correct"]),
+        "accuracy": (
+            sum(1 for cid in other if scores[cid]["correct"])
+            / len(other)) if other else None,
+        "cases": other,
+    }
+    out["summary"] = techlead.summarise_paths(raw)
+    return out
+
+
+def run_acceptance_v2(corpus_dir, seat_fn, *, seat_family,
+                      seat_name="acceptance-tech-lead-v2",
+                      confidence_threshold=(
+                          techlead.CONFIDENCE_THRESHOLD_DEFAULT),
+                      timeout=180, log=None):
+    """Run the acceptance corpus under adjudication protocol
+    v2 (techlead.adjudicate, evaluation mode: every model-path
+    case takes both A/B draws) and score it with the SAME
+    scorer and metric computation as the v1 runner.
+
+    Protocol differences from v1, all stated on the record:
+    corpus probe results are HARNESS-EXECUTED inputs here —
+    a settling probe decides deterministically (the seat only
+    grades its adequacy), where v1 presented probes as
+    context to the seat; protected-class cases are routed
+    by the harness before any seat call (the corpus owns the
+    tag); M4 is not run (mutations belong to the final
+    candidate's evaluation, not to baseline scoring — and
+    vendor-strip / family-swap are invariant by construction
+    under canonicalised packets), so M4 is measured None and
+    the unlock verdict is False on any v2 baseline run."""
+    log = log or (lambda _msg: None)
+    corpus = load_corpus(corpus_dir)
+    cases = corpus["cases"]
+    scorecard = corpus["scorecard"]
+
+    baseline = {}
+    scores = {}
+    for cid in sorted(cases):
+        case = cases[cid]
+        finding, dispute, region, _indep = case_inputs(
+            case, seat_family)
+        protected = \
+            case.get("case_class") == "protected_class"
+        reason = case.get("protected_class")
+        entry = techlead.adjudicate(
+            seat_fn, finding, region, dispute,
+            seat_name=seat_name, seat_family=seat_family,
+            probe_result=case.get("probe"),
+            protected=protected,
+            protected_reason=reason if isinstance(
+                reason, str) else None,
+            confidence_threshold=confidence_threshold,
+            evaluation_mode=True, timeout=timeout)
+        adapted = adapt_v2_entry(entry)
+        baseline[cid] = adapted
+        scores[cid] = score_case(case, adapted)
+        log(f"baseline {cid}: {scored_decision(adapted)} "
+            f"path={adapted.get('path')} "
+            f"(correct={scores[cid]['correct']})")
+
+    metrics = _scorecard_metrics(
+        cases, baseline, scores, scorecard,
+        flips={}, do_mutations=False, log=log)
+    # An empty corpus unlocks nothing, and an unmeasured M4
+    # passes nothing (633acb885291, as in v1).
+    unlock = bool(cases) and all(
+        m["pass"] for m in metrics.values())
+    return {
+        "seat_family": seat_family, "seat_name": seat_name,
+        "corpus": corpus_dir,
+        "protocol": "v2",
+        "protocol_version": techlead.TL_PROTOCOL_VERSION,
+        "rubric_version": techlead.TL_RUBRIC_VERSION,
+        "confidence_threshold": confidence_threshold,
+        "evaluation_mode": True,
+        "cases": {cid: {"entry": baseline[cid],
+                        "score": scores[cid]}
+                  for cid in sorted(cases)},
+        "metrics": metrics,
+        "paths": _path_metrics(
+            cases, baseline, scores, scorecard),
+        "counting_rules_note": (
+            "M1 counted by scored decision over the "
+            "scorecard's real-finding set (the scorecard's "
+            "counting_rules.false_dismissal); score_case's "
+            "per-case false_dismissal flag is never set by "
+            "the scorer and was NOT used — in the v1 run "
+            "record the flag read false on cases the M1 "
+            "metric counted. M6 is measured over majors "
+            "with two verdict draws (the model path in "
+            "evaluation mode); deterministic-path majors "
+            "are decided by their probe, take no draws, and "
+            "are outside M6's measured set — see the "
+            "per-path report. M4 not run in v2 baseline "
+            "mode (measured None, pass False)."),
+        "unlock_all_gates_pass": unlock}