"""Offline b4-feedback-descent/1.0 audit; development defaults unfrozen. Checks recorded decisions and buffers only; not a verified paper reproduction. """ import json from pathlib import Path import re import initial_contract observation = initial_contract.observation CONTRACT = "b4-feedback-descent/1.0" BASE = Path(__file__).resolve().parent.parent/"baseline-prompts"/"b4-feedback-descent" TEMPLATES = { "proposal": ("proposal.txt", "e05bf187df85f3385c6c4c8845bdf10e7a2a2add7263c883c2abfc594322fb69", ("TASK_PACKET_JSON", "INCUMBENT_ARTIFACT_JSON", "FEEDBACK_HISTORY_JSON")), "comparison": ("comparison-rationale.txt", "c73969745a2aaaee7983c248a616b7c84e413be0290bb595e2bcfee9d3dd3d64", ("TASK_PACKET_JSON", "ARTIFACT_A_JSON", "ARTIFACT_B_JSON")), "acceptance": ("acceptance.txt", "11cd3054592152a5a63f6cd2864d877576e5f07787175e4c2dd8738f8a2d94cd", ("INCUMBENT_ID_JSON", "CANDIDATE_ID_JSON", "COMPARISON_RECORDS_JSON")), } RECORD = ("attempt", "order", "a_id", "b_id", "preference", "rationale") RESULT = ("incumbent_id", "candidate_id", "action", "selected_id", "comparison_complete", "decisive_attempt", "history_action", "reason") RESPONSE = ("attempt_id", "response_state", "response_record_id", "response_sha256") def fingerprint(value): return observation.sha(observation.canonical(value).encode("utf-8")) def check(value, expected, label): observation.require(fingerprint(value) == fingerprint(expected), "B4 "+label+" mismatch") def decode_input(raw, stage, bounds): observation.require(len(raw) <= bounds["max_input_bytes"], "B4 input byte bound exceeded") filename, sha, names = TEMPLATES[stage] template = (BASE/filename).read_bytes() observation.require(observation.sha(template) == sha, "B4 template hash mismatch") text = raw.decode("utf-8") observation.require(observation.MARKER.search(text) is None, "B4 unresolved placeholders") parts = re.split(r"(\{\{[A-Z_]+\}\})", template.decode()) observation.require(parts[1::2] == ["{{"+n+"}}" for n in names], "unsupported B4 placeholders") values, cursor = {}, 0 for index, name in enumerate(names): prefix = parts[index*2] observation.require(text.startswith(prefix, cursor), "B4 altered literal wrapper") cursor += len(prefix) start = cursor while cursor < len(text) and text[cursor] in " \t\r\n": cursor += 1 _, end = json.JSONDecoder().raw_decode(text, cursor) values[name] = observation.parse_json(text[start:end].encode(), "B4 "+name) cursor = end observation.require(text[cursor:] == parts[-1], "B4 altered literal wrapper") return values def preference(raw): """Retain malformed outputs as failures, never repair them into preferences.""" try: value = observation.parse_json(raw, "B4 comparator response") observation.keys(value, ("preference", "rationale"), "B4 comparator response") observation.require(value["preference"] in ("A", "B"), "invalid B4 preference") observation.text(value["rationale"], "B4 rationale") return value except (ValueError, TypeError): return None def _rule(records, inc, cand): action, reason, complete, decisive, history = "keep_incumbent", "invalid_records", False, None, "unchanged" valid = isinstance(records, list) and len(records) in (2, 4, 6) first = None for index in range(0, len(records), 2): pair = records[index:index+2] if len(pair) != 2: valid = False break winners = [] for order, record in enumerate(pair, 1): good = isinstance(record, dict) and set(record) == set(RECORD) good = good and type(record["attempt"]) is int and record["attempt"] == index//2+1 and type(record["order"]) is int and record["order"] == order good = good and (record["a_id"], record["b_id"]) in ((inc, cand), (cand, inc)) and record["preference"] in ("A", "B") good = good and isinstance(record["rationale"], str) and bool(record["rationale"].strip()) if not good: valid = False continue winners.append(record["a_id"] if record["preference"] == "A" else record["b_id"]) if len(winners) == 2: if (pair[0]["a_id"], pair[0]["b_id"]) != (pair[1]["b_id"], pair[1]["a_id"]): valid = False if winners[0] == winners[1] and first is None: first = (index//2+1, winners[0]) if first is not None and first[0]*2 != len(records): valid = False if valid: if first is not None: decisive, winner = first complete = True if winner == cand: action, reason, history = "accept_candidate", "candidate_consensus", "clear" else: reason, history = "incumbent_consensus", "append_proposal_feedback" elif len(records) == 6: complete, reason, history = True, "no_consensus", "append_proposal_feedback" else: action, reason = "compare_again", "awaiting_consensus" return dict(incumbent_id=inc, candidate_id=cand, action=action, selected_id=cand if action == "accept_candidate" else inc, comparison_complete=complete, decisive_attempt=decisive, history_action=history, reason=reason) def acceptance_consistent(records, recorded, inc, cand): observation.require(isinstance(records, list), "B4 records must be an array") observation.keys(recorded, RESULT, "B4 recorded acceptance") check(recorded, _rule(records, inc, cand), "recorded first-consistent-pair rule") def history(value, cap): observation.require(isinstance(value, list) and len(value) <= cap, "B4 feedback buffer bound/type exceeded; no truncation") for entry in value: observation.keys(entry, ("candidate_artifact", "incumbent_id", "comparisons", "outcome"), "B4 feedback entry") artifact = entry["candidate_artifact"] observation.keys(artifact, ("artifact_id", "text"), "B4 feedback artifact") cand, inc = observation.text(artifact["artifact_id"], "B4 feedback artifact ID"), observation.text(entry["incumbent_id"], "B4 feedback incumbent") observation.require(cand != inc and isinstance(artifact["text"], str), "B4 feedback artifact identity/text invalid") artifact["text"].encode("utf-8") records = entry["comparisons"] observation.require(isinstance(records, list), "B4 feedback comparisons must be an array") for record in records: observation.keys(record, RECORD, "B4 feedback comparison") observation.text(record["rationale"], "B4 preserved rationale") outcome = _rule(records, inc, cand) observation.require(outcome["comparison_complete"] and outcome["reason"] in ("incumbent_consensus", "no_consensus") and entry["outcome"] == outcome["reason"], "B4 feedback may contain only complete rejection/no-consensus records") def attempt_map(row): result = {a["attempt_id"]: "initialization" for a in row["initialization"]["worker_attempts"]} for it in row["iterations"]: result.update({a["attempt_id"]: "proposal" for a in it["proposal_attempts"]}) for pair in it["comparison_pairs"]: for order in pair["orders"]: result.update({a["attempt_id"]: "comparison" for a in order["attempts"]}) result.update({a["attempt_id"]: "acceptance" for a in pair["acceptance"]["serializer_attempts"]}) return result def validate_native(row, run, records, read_record, bounds, task_id, public_hash, identity_fields): observation.keys(row, (*identity_fields, "archive_id", "seal_record_id", "audit_scope", "contract", "packet_inventory_complete", "feedback_entry_cap", "states", "initialization", "iterations", "final_state_id", "packets"), "B4 native run") observation.require(row["contract"] == CONTRACT and row["audit_scope"] == "b4-native", "unsupported B4 contract/scope") observation.require(type(row["packet_inventory_complete"]) is bool, "B4 inventory completeness must be Boolean") cap = observation.integer(row["feedback_entry_cap"], 0, "B4 feedback entry cap") observation.require(cap <= 9, "B4 version 1.0 supports at most nine complete feedback entries") source = {a["attempt_id"]: a for a in run["attempts"]} designated, stages, groups, outputs, artifacts, states, state_bytes = {}, {}, {}, {}, {}, {}, {} def payload(rid, sha, kind, aid=None): observation.require(rid in records and rid in run["record_ids"], "B4 unknown/cross-run record") record = records[rid] observation.require(record["kind"] == kind and record["sha256"] == sha, "B4 record kind/hash mismatch") if aid is not None: observation.require(rid in source[aid]["record_ids"], "B4 record not linked to declared attempt") raw = read_record(record) observation.require(observation.sha(raw) == sha, "B4 source hash mismatch") raw.decode("utf-8") return raw def artifact(aid, sha, producer=None): if sha is None: return None observation.text(aid, "B4 artifact identity") return payload(aid, sha, "artifact", producer) def register(items, stage, group, role, worker=False): observation.require(isinstance(items, list), "B4 attempts must be an array") for item in items: observation.keys(item, ("attempt_id", "artifact_id", "artifact_sha256") if worker else RESPONSE, "B4 "+stage+" attempt") aid = observation.text(item["attempt_id"], "B4 attempt ID") observation.require(aid in source and aid not in designated and source[aid]["phase"] == "adaptation" and source[aid]["role"] == role, "B4 unknown/duplicate attempt or wrong role") designated[aid], stages[aid], groups[aid] = item, stage, group if worker: if item["artifact_id"] is None: observation.require(item["artifact_sha256"] is None, "B4 missing artifact requires null hash") else: observation.text(item["artifact_id"], "B4 artifact ID") artifacts[aid] = artifact(item["artifact_id"], item["artifact_sha256"], aid) else: observation.require(item["response_state"] in ("available", "not_produced", "unavailable"), "B4 unsupported response state") if item["response_state"] == "available": outputs[aid] = payload(item["response_record_id"], item["response_sha256"], "operational_record", aid) else: observation.require(item["response_record_id"] is None and item["response_sha256"] is None, "B4 absent response requires null record/hash") roots = [a for a in items if source[a["attempt_id"]]["retry_of"] is None] observation.require(not items or len(roots) == 1, "B4 stage/order needs one root plus transport retries") observation.require(isinstance(row["states"], list), "B4 states must be an array") for state in row["states"]: observation.keys(state, ("state_id", "incumbent_id", "incumbent_sha256", "feedback_history"), "B4 state") sid = observation.text(state["state_id"], "B4 state ID") observation.require(sid not in states, "duplicate B4 state identity") observation.text(state["incumbent_id"], "B4 incumbent artifact ID") if state["feedback_history"] is not None: history(state["feedback_history"], cap) states[sid], state_bytes[sid] = state, artifact(state["incumbent_id"], state["incumbent_sha256"]) init = row["initialization"] observation.keys(init, ("contract", "state_id", "worker_attempts", "artifact_attempt_id"), "B4 initialization") observation.require(init["contract"] == initial_contract.CONTRACT and init["state_id"] in states, "unsupported/missing B4 common-initial declaration") register(init["worker_attempts"], "initialization", "initialization", "worker", True) observation.require(isinstance(row["iterations"], list) and len(row["iterations"]) <= 9, "B4 version 1.0 permits at most nine proposals") used, seen_iterations, seen_candidates, last = {init["state_id"]}, set(), {states[init["state_id"]]["incumbent_id"]}, 0 for it in row["iterations"]: observation.keys(it, ("iteration_id", "sequence", "incumbent_state_id", "candidate_id", "candidate_sha256", "proposal_attempts", "artifact_attempt_id", "comparison_pairs", "next_state_id"), "B4 iteration") iid = observation.text(it["iteration_id"], "B4 iteration ID") sequence = observation.integer(it["sequence"], 1, "B4 iteration sequence") observation.require(iid not in seen_iterations and sequence > last, "duplicate/reversed B4 iteration") seen_iterations.add(iid) last = sequence observation.require(it["incumbent_state_id"] in used, "B4 unknown incumbent state link") observation.text(it["candidate_id"], "B4 candidate artifact ID") observation.require(it["candidate_id"] not in seen_candidates, "B4 candidate artifact identities must be new per proposal") seen_candidates.add(it["candidate_id"]) observation.require(it["candidate_id"] != states[it["incumbent_state_id"]]["incumbent_id"], "B4 candidate and incumbent artifact IDs must differ") if it["next_state_id"] is not None: observation.require(it["next_state_id"] in states, "B4 unknown next state") used.add(it["next_state_id"]) register(it["proposal_attempts"], "proposal", (iid, "proposal"), "worker", True) observation.require(isinstance(it["comparison_pairs"], list) and len(it["comparison_pairs"]) == 3, "B4 requires three explicit planned-pair slots") for index, pair in enumerate(it["comparison_pairs"], 1): observation.keys(pair, ("pair_id", "attempt", "state", "orders", "acceptance"), "B4 planned pair") observation.text(pair["pair_id"], "B4 pair ID") observation.require(type(pair["attempt"]) is int and pair["attempt"] == index and pair["state"] in ("performed", "not_attempted", "unknown"), "B4 invalid planned attempt sequence/state") observation.require(len({p["pair_id"] for p in it["comparison_pairs"]}) == 3, "duplicate B4 planned pair ID") observation.require(isinstance(pair["orders"], list) and len(pair["orders"]) == 2, "B4 pair requires two explicit order slots") for n, order in enumerate(pair["orders"], 1): observation.keys(order, ("order", "a_id", "b_id", "attempts", "result_attempt_id"), "B4 comparison order") observation.require(type(order["order"]) is int and order["order"] == n, "B4 invalid comparison order") inc, cand = states[it["incumbent_state_id"]]["incumbent_id"], it["candidate_id"] observation.require((order["a_id"], order["b_id"]) in ((inc, cand), (cand, inc)), "B4 invalid declared A/B mapping") register(order["attempts"], "comparison", (iid, pair["pair_id"], n), "comparator") ids = {a["attempt_id"] for a in order["attempts"]} observation.require(order["result_attempt_id"] in ids if ids else order["result_attempt_id"] is None, "B4 missing/foreign comparison result link") first, second = pair["orders"] check((first["a_id"], first["b_id"]), (second["b_id"], second["a_id"]), "orders must be swapped") acc = pair["acceptance"] observation.keys(acc, ("state", "record_id", "sha256", "serializer_attempts", "result_attempt_id"), "B4 acceptance descriptor") observation.require(acc["state"] in ("available", "not_executed", "unavailable"), "B4 invalid acceptance state") if acc["state"] != "available": observation.require(acc["record_id"] is None and acc["sha256"] is None, "B4 absent acceptance requires null record/hash") register(acc["serializer_attempts"], "acceptance", (iid, pair["pair_id"], "acceptance"), "selector") ids = {a["attempt_id"] for a in acc["serializer_attempts"]} observation.require(acc["result_attempt_id"] in ids if ids else acc["result_attempt_id"] is None, "B4 missing/foreign acceptance serializer link") if pair["state"] != "performed": observation.require(not any(o["attempts"] for o in pair["orders"]) and not acc["serializer_attempts"] and acc["state"] != "available", "B4 unperformed pair cannot contain calls/acceptance") else: observation.require(any(o["attempts"] for o in pair["orders"]) or acc["serializer_attempts"], "B4 performed pair needs explicit calls; use unknown/not_attempted otherwise") observation.require(used == set(states), "B4 unreferenced state declaration") expected = {a["attempt_id"] for a in run["attempts"] if a["phase"] == "adaptation" and a["role"] in ("worker", "comparator", "selector", "optimizer", "critic", "planner", "scorer")} observation.require(set(designated) == expected, "every B4 worker/comparator/selector attempt needs an explicit stage, including failures/retries") for aid in designated: parent = source[aid]["retry_of"] observation.require(parent is None or (parent in groups and groups[parent] == groups[aid]), "B4 transport retry crosses planned pair/order/stage") contents, decoded, raw_inputs, sequences, pids = {}, {}, {}, {}, set() last = 0 for packet in row["packets"]: observation.keys(packet, ("input_scope", "packet_id", "attempt_id", "sequence", "record_id", "sha256"), "B4 packet") aid, pid = packet["attempt_id"], observation.text(packet["packet_id"], "B4 packet ID") observation.require(packet["input_scope"] == "native" and aid in designated and aid not in sequences and pid not in pids, "B4 duplicate/unknown packet identity/scope") seq = observation.integer(packet["sequence"], 1, "B4 request sequence") observation.require(seq > last, "B4 reversed request chronology") sequences[aid], last = seq, seq pids.add(pid) if packet["record_id"] is None: observation.require(packet["sha256"] is None, "B4 missing input requires null hash") continue rid = packet["record_id"] observation.require(rid in records and records[rid]["kind"] in ("submitted_prompt", "operational_record"), "B4 invalid input record kind") raw = payload(rid, packet["sha256"], records[rid]["kind"], aid) if stages[aid] == "initialization": initial_contract.validate_input(raw, bounds, task_id, public_hash) else: decoded[aid] = decode_input(raw, stages[aid], bounds) raw_inputs[aid], contents[pid] = raw, raw observation.require(set(sequences) == set(designated), "B4 missing request slot; retain explicit null inputs") for aid in designated: parent = source[aid]["retry_of"] if parent in raw_inputs and aid in raw_inputs: observation.require(raw_inputs[parent] == raw_inputs[aid], "B4 transport retry must repeat identical request bytes") unknown = len(designated)-len(raw_inputs)+sum(a.get("response_state") == "unavailable" for a in designated.values()) def public(value): observation.text(value, "B4 complete public packet") observation.require(observation.sha(value.encode()) == public_hash, "B4 immutable public packet hash mismatch") observation.task_identifiers(value, task_id) def bound_worker(items, selected, wanted_id, wanted_sha): nonlocal unknown observation.require(selected is None or selected in {a["attempt_id"] for a in items}, "B4 foreign artifact-producing attempt") if selected is None or artifacts.get(selected) is None or wanted_sha is None: unknown += 1 return False item = designated[selected] check((item["artifact_id"], item["artifact_sha256"]), (wanted_id, wanted_sha), "proposal/initial artifact binding") return True initial_state = states[init["state_id"]] bound_worker(init["worker_attempts"], init["artifact_attempt_id"], initial_state["incumbent_id"], initial_state["incumbent_sha256"]) if initial_state["feedback_history"] is None: unknown += 1 else: check(initial_state["feedback_history"], [], "initial feedback buffer") previous, iterations = init["state_id"], [] producers = {initial_state["incumbent_id"]: init["artifact_attempt_id"]} for it in row["iterations"]: iid, sid = it["iteration_id"], it["incumbent_state_id"] if previous is None: unknown += 1 else: check(sid, previous, "incumbent state continuity") old = states[sid] inc, cand = old["incumbent_id"], it["candidate_id"] candidate_bytes = artifact(cand, it["candidate_sha256"]) candidate_bound = bound_worker(it["proposal_attempts"], it["artifact_attempt_id"], cand, it["candidate_sha256"]) for item in it["proposal_attempts"]: aid = item["attempt_id"] if aid in decoded: value = decoded[aid] public(value["TASK_PACKET_JSON"]) observation.keys(value["INCUMBENT_ARTIFACT_JSON"], ("artifact_id", "text"), "B4 proposal incumbent") observation.text(value["INCUMBENT_ARTIFACT_JSON"]["artifact_id"], "B4 incumbent ID") observation.require(isinstance(value["INCUMBENT_ARTIFACT_JSON"]["text"], str), "B4 incumbent text must be a string") value["INCUMBENT_ARTIFACT_JSON"]["text"].encode("utf-8") history(value["FEEDBACK_HISTORY_JSON"], cap) if state_bytes[sid] is None or old["feedback_history"] is None: unknown += 1 else: check(value["INCUMBENT_ARTIFACT_JSON"], dict(artifact_id=inc, text=state_bytes[sid].decode()), "proposal incumbent") check(value["FEEDBACK_HISTORY_JSON"], old["feedback_history"], "proposal native feedback buffer") if producers.get(inc) is not None: observation.require(sequences[producers[inc]] < sequences[aid], "B4 incumbent must precede proposal") producers[cand] = it["artifact_attempt_id"] terminal, decision, final_records, uncertain, stopped = False, None, None, False, False comparison_invalid, pair_unknown, performed, pair_rows = 0, 0, 0, [] pair_sources = {} for pair in it["comparison_pairs"]: n = pair["attempt"] if pair["state"] == "unknown": unknown += 1 pair_unknown += 1 if pair["state"] != "performed": if pair["state"] == "not_attempted": stopped = True continue observation.require(not terminal and not stopped, "B4 comparison continued after first consensus or incomplete pair") performed += 1 parsed_orders, winners, known_invalid = {}, [], False for order in pair["orders"]: chosen = order["result_attempt_id"] for item in order["attempts"]: aid = item["attempt_id"] if aid in decoded: value = decoded[aid] public(value["TASK_PACKET_JSON"]) for side in ("A", "B"): object_value = value["ARTIFACT_"+side+"_JSON"] observation.keys(object_value, ("text",), "B4 anonymous comparison artifact") observation.require(isinstance(object_value["text"], str), "B4 anonymous text must be a string") object_value["text"].encode("utf-8") data = state_bytes[sid] if order[side.lower()+"_id"] == inc else candidate_bytes if data is None: unknown += 1 else: check(object_value["text"], data.decode(), "anonymous swapped-order mapping") if it["artifact_attempt_id"] is not None: observation.require(sequences[it["artifact_attempt_id"]] < sequences[aid], "B4 proposal must precede comparison") if chosen is None: result = None known_invalid = True elif chosen in outputs: result = preference(outputs[chosen]) known_invalid |= result is None comparison_invalid += result is None elif designated[chosen]["response_state"] == "not_produced": result = None known_invalid = True else: result = "unknown" uncertain = True parsed_orders[order["order"]] = result pair_sources[(n, order["order"])] = (order, result) if isinstance(result, dict): winners.append(order["a_id"] if result["preference"] == "A" else order["b_id"]) consensus_known = len(winners) == 2 and winners[0] == winners[1] acc = pair["acceptance"] result, record_list, verified = None, None, False for item in acc["serializer_attempts"]: aid = item["attempt_id"] if aid in decoded: value = decoded[aid] check((value["INCUMBENT_ID_JSON"], value["CANDIDATE_ID_JSON"]), (inc, cand), "acceptance serializer pair IDs") observation.require(isinstance(value["COMPARISON_RECORDS_JSON"], list) and all(isinstance(r, dict) and set(r) == set(RECORD) for r in value["COMPARISON_RECORDS_JSON"]), "B4 acceptance serializer unsupported record fields") for order in pair["orders"]: if order["result_attempt_id"] is not None: observation.require(sequences[order["result_attempt_id"]] < sequences[aid], "B4 judgments must precede acceptance serializer") if acc["state"] == "available": envelope = observation.parse_json(payload(acc["record_id"], acc["sha256"], "operational_record"), "B4 recorded acceptance") observation.keys(envelope, ("acceptance_record_version", "records", "result"), "B4 acceptance envelope") observation.require(envelope["acceptance_record_version"] == "1.0", "unsupported B4 acceptance record version") record_list, result = envelope["records"], envelope["result"] acceptance_consistent(record_list, result, inc, cand) verified = True for record in record_list: if isinstance(record, dict) and type(record.get("attempt")) is int and type(record.get("order")) is int: key = (record["attempt"], record["order"]) observation.require(key in pair_sources, "B4 acceptance record refers to unperformed/future comparison") mapping, parsed = pair_sources[key] if "a_id" in record and "b_id" in record: check((record["a_id"], record["b_id"]), (mapping["a_id"], mapping["b_id"]), "acceptance record A/B mapping") if parsed == "unknown": verified = False else: check((record.get("preference"), record.get("rationale")), (None, None) if parsed is None else (parsed["preference"], parsed["rationale"]), "exact archived preference/rationale") for item in acc["serializer_attempts"]: aid = item["attempt_id"] if aid in decoded: check(decoded[aid]["COMPARISON_RECORDS_JSON"], record_list, "serializer recorded prefix") chosen = acc["result_attempt_id"] if chosen is not None: if chosen in outputs: check(observation.parse_json(outputs[chosen], "B4 acceptance serializer output"), result, "acceptance serializer result") else: unknown += 1 verified = False decision, final_records = result, record_list if result["action"] != "compare_again": terminal = True elif acc["state"] == "not_executed": stopped = True decision, final_records = None, None else: unknown += 1 uncertain = True decision, final_records = None, None if known_invalid or consensus_known: terminal = True pair_rows.append(dict(pair_id=pair["pair_id"], attempt=n, acceptance_verified=verified, recorded_action=None if result is None else result["action"], recorded_reason=None if result is None else result["reason"], known_invalid_comparison=known_invalid)) # A stopped/awaiting/invalid iteration never appends partial feedback. expected_id, expected_history = inc, old["feedback_history"] transition_known = not uncertain and pair_unknown == 0 complete = bool(decision is not None and decision["comparison_complete"] and candidate_bound) if decision is not None and decision["comparison_complete"]: expected_id = decision["selected_id"] if decision["history_action"] == "clear": expected_history = [] elif candidate_bytes is None or old["feedback_history"] is None: transition_known = False else: expected_history = [*old["feedback_history"], dict(candidate_artifact=dict(artifact_id=cand, text=candidate_bytes.decode()), incumbent_id=inc, comparisons=final_records, outcome=decision["reason"])] if not transition_known: unknown += 1 next_id = it["next_state_id"] transition_verified = False if next_id is None: unknown += 1 else: target = states[next_id] if transition_known: check(target["incumbent_id"], expected_id, "recorded acceptance/incumbent continuity") if expected_history is None or target["feedback_history"] is None: unknown += 1 else: check(target["feedback_history"], expected_history, "native feedback append/clear/unchanged") if state_bytes[next_id] is None: unknown += 1 else: transition_verified = True iteration_attempts = [aid for aid in designated if isinstance(groups[aid], tuple) and groups[aid][0] == iid] missing_iteration_inputs = sum(aid not in raw_inputs for aid in iteration_attempts) unavailable_iteration_responses = sum(designated[aid].get("response_state") == "unavailable" for aid in iteration_attempts) iterations.append(dict(iteration_id=iid, planned_pair_limit=3, performed_pair_count=performed, pairs=pair_rows, unknown_pair_count=pair_unknown, comparison_invalid_response_count=comparison_invalid, iteration_complete=complete and transition_verified and missing_iteration_inputs == 0 and unavailable_iteration_responses == 0, recorded_reason=None if decision is None else decision["reason"], transition_verified=transition_verified, missing_input_count=missing_iteration_inputs, unavailable_response_count=unavailable_iteration_responses, feedback_action="unchanged" if decision is None else decision["history_action"])) previous = next_id final = row["final_state_id"] observation.require(final is None or final in states, "B4 unknown final state") if final is None or previous is None: unknown += 1 else: check(final, previous, "final state continuity") if state_bytes[final] is None or run["endpoint_selection"]["artifact_id"] is None: unknown += 1 else: check(run["endpoint_selection"]["artifact_id"], states[final]["incumbent_id"], "prescribed endpoint/incumbent") coverage = dict(evidence_complete=unknown == 0, evidence_gap_count=unknown, initialization_contract=init["contract"], initialization_attempt_count=len(init["worker_attempts"]), iteration_denominator=len(iterations), iterations=iterations, incomplete_iteration_count=sum(not i["iteration_complete"] for i in iterations), performed_pair_count=sum(i["performed_pair_count"] for i in iterations), unknown_pair_count=sum(i["unknown_pair_count"] for i in iterations), missing_input_count=len(designated)-len(raw_inputs), unavailable_response_count=sum(a.get("response_state") == "unavailable" for a in designated.values()), transport_retry_count=sum(source[aid]["retry_of"] is not None for aid in designated), planned_additional_pair_count=sum(max(0, i["performed_pair_count"]-1) for i in iterations), stage_attempt_counts={stage: sum(s == stage for s in stages.values()) for stage in ("initialization", "proposal", "comparison", "acceptance")}, attempt_status_counts={s: sum(source[aid]["status"] == s for aid in designated) for s in ("succeeded", "failed", "incomplete", "cancelled", "unknown")}) return coverage, contents def scope_coverage(run, judgment): ids = {a["attempt_id"] for a in run["initialization"]["worker_attempts"]} packets = [p for p in run["packets"] if p["attempt_id"] in ids] available = {p["packet_id"] for p in packets if p["record_id"] is not None} reviewed = set() if judgment is None else set(judgment["reviewed_packet_ids"]) empty = dict(in_scope=False, contract=None, declared_attempt_count=0, missing_packet_count=0, available_packet_count=0, reviewed_packet_count=0, available_unreviewed_packet_count=0, packet_inventory_complete=None, judgment_available=False, review_coverage_complete=False) initial = dict(in_scope=True, contract=initial_contract.CONTRACT, declared_attempt_count=len(packets), missing_packet_count=len(packets)-len(available), available_packet_count=len(available), reviewed_packet_count=len(available & reviewed), available_unreviewed_packet_count=len(available-reviewed), packet_inventory_complete=run["packet_inventory_complete"], judgment_available=judgment is not None and judgment["violation"] is not None, review_coverage_complete=run["packet_inventory_complete"] and len(available) == len(packets) and available <= reviewed and judgment is not None and judgment["violation"] is not None) return dict(initial=initial, continuation=empty) def aggregate(rows): values = [r["b4_native_coverage"] for r in rows if "b4_native_coverage" in r] fields = ("initialization_attempt_count", "iteration_denominator", "incomplete_iteration_count", "performed_pair_count", "unknown_pair_count", "missing_input_count", "unavailable_response_count", "transport_retry_count", "planned_additional_pair_count") return dict(assigned_run_denominator=len(rows), b4_native_run_count=len(values), evidence_incomplete_run_count=sum(not v["evidence_complete"] for v in values), **{field: sum(v[field] for v in values) for field in fields})