"""Offline b3-spo-native/1.0 audit; development defaults unfrozen, no SPO reproduction claim. Validate recorded decisions only. Never execute requests, judge quality, repair responses, or export a newly selected incumbent. """ import json from pathlib import Path import re import xml.etree.ElementTree as ET import initial_contract observation = initial_contract.observation CONTRACT = "b3-spo-native/1.0" BASE = Path(__file__).resolve().parent.parent/"baseline-prompts"/"b3-spo" TEMPLATES = { "generation": ("candidate-generation.txt", "689d4db599e4674d398dff8c978eaaaf866fd8c1ce34034e00eafc9be3798f53", ("TASK_PACKET_JSON", "INCUMBENT_PROMPT_JSON", "INCUMBENT_ARTIFACT_JSON")), "worker": ("candidate-worker.txt", "39e030fb29452b66185c5909858c5a1a5f7f5bfe687924b0143fe15583502587", ("CANDIDATE_PROMPT_JSON", "TASK_PACKET_JSON")), "comparison": ("comparison.txt", "5ee7396951630f46662d135bdc10f9b3db3eebd2e588d0631b4f7b33ef7f688b", ("PUBLIC_TASKS_JSON", "OUTPUTS_A_JSON", "OUTPUTS_B_JSON")), "selection": ("selection.txt", "a6be8e65ac96d3288836fad7c20cea58d6fb98a00155b86c7b44d3931bb335f4", ("INCUMBENT_ID_JSON", "CANDIDATE_ID_JSON", "COMPARISON_RECORDS_JSON")), } RESPONSE = ("attempt_id", "response_state", "response_record_id", "response_sha256") DECISION = ("incumbent_id", "candidate_id", "comparison_complete", "incumbent_votes", "candidate_votes", "accept_candidate", "selected_id", "reason") def fingerprint(value): return observation.sha(observation.canonical(value).encode()) def decode_input(raw, stage, bounds): observation.require(len(raw) <= bounds["max_input_bytes"], "B3 input byte bound exceeded") name, expected, names = TEMPLATES[stage] template = (BASE/name).read_bytes() observation.require(observation.sha(template) == expected, "B3 template hash mismatch") text = raw.decode("utf-8") observation.require(observation.MARKER.search(text) is None, "B3 unresolved placeholders") parts = re.split(r"(\{\{[A-Z_]+\}\})", template.decode()) observation.require(parts[1::2] == ["{{"+n+"}}" for n in names], "unsupported B3 placeholders") cursor, result = 0, {} for index, key in enumerate(names): prefix = parts[index*2] observation.require(text.startswith(prefix, cursor), "B3 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) result[key] = observation.parse_json(text[start:end].encode(), "B3 "+key) cursor = end observation.require(text[cursor:] == parts[-1], "B3 altered literal wrapper") return result def xml_response(raw, stage): """Malformed recorded output is a retained failure, not a synthesized vote.""" text = raw.decode("utf-8") if ""+text+"") except ET.ParseError: return None names = ("analyse", "modification", "prompt") if stage == "generation" else ("analyse", "choose") if (root.text or "").strip() or [e.tag for e in root] != list(names): return None if any(e.attrib or list(e) or (e.tail or "").strip() or not (e.text or "").strip() for e in root): return None result = {e.tag: e.text for e in root} if stage == "comparison" and result["choose"] not in ("A", "B"): return None return result def selection_consistent(records, recorded, incumbent, candidate): """Check a supplied record against the fixed four-vote rule; return validity only.""" observation.keys(recorded, DECISION, "B3 recorded selection result") complete, rounds, winners = isinstance(records, list) and len(records) == 4, set(), [] for row in records: valid = isinstance(row, dict) and set(row) == {"round", "a_id", "b_id", "choice"} valid = valid and type(row["round"]) is int and row["round"] in (1, 2, 3, 4) and row["round"] not in rounds valid = valid and ((row["a_id"], row["b_id"]) in ((incumbent, candidate), (candidate, incumbent))) and row["choice"] in ("A", "B") complete = complete and valid if valid: rounds.add(row["round"]) winners.append(row["a_id"] if row["choice"] == "A" else row["b_id"]) complete = complete and rounds == {1, 2, 3, 4} inc = winners.count(incumbent) if complete else None cand = winners.count(candidate) if complete else None accept = complete and cand > inc reason = ("incomplete_keep_incumbent" if not complete else "candidate_majority" if accept else "tie_keep_incumbent" if cand == inc else "incumbent_majority") expected = dict(incumbent_id=incumbent, candidate_id=candidate, comparison_complete=complete, incumbent_votes=inc, candidate_votes=cand, accept_candidate=accept, selected_id=candidate if accept else incumbent, reason=reason) observation.require(fingerprint(recorded) == fingerprint(expected), "B3 recorded selection contradicts fixed four-vote rule") return complete def attempt_map(row): """Explicit graph membership, never text/order inference.""" result = {a["attempt_id"]: "initialization" for a in row["initialization"]["worker_attempts"]} for iteration in row["iterations"]: for stage, field in (("generation", "generation_attempts"), ("worker", "worker_attempts")): result.update({a["attempt_id"]: stage for a in iteration[field]}) for rnd in iteration["comparisons"]: result.update({a["attempt_id"]: "comparison" for a in rnd["attempts"]}) result.update({a["attempt_id"]: "selection" for a in iteration["selection"]["selector_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", "states", "initialization", "iterations", "final_incumbent_id", "packets"), "B3 native run") observation.require(row["contract"] == CONTRACT and row["audit_scope"] == "b3-native", "unsupported B3 native contract/scope") observation.require(type(row["packet_inventory_complete"]) is bool, "B3 inventory completeness must be Boolean") archived_attempts = {a["attempt_id"]: a for a in run["attempts"]} designated, stages, groups, responses, artifacts = {}, {}, {}, {}, {} state_data, states = {}, {} def payload(rid, sha, kind, aid=None): observation.require(rid in records and rid in run["record_ids"], "B3 unknown/cross-run record") rec = records[rid] observation.require(rec["kind"] == kind and rec["sha256"] == sha, "B3 record kind/hash mismatch") if aid is not None: observation.require(rid in archived_attempts[aid]["record_ids"], "B3 record not linked to declared attempt") raw = read_record(rec) observation.require(observation.sha(raw) == sha, "B3 source hash mismatch") raw.decode("utf-8") return raw def optional_artifact(item, aid=None): rid, sha = item["artifact_record_id"], item["artifact_sha256"] if rid is None: observation.require(sha is None, "B3 missing artifact must have null hash") return None observation.text(rid, "B3 artifact ID") return payload(rid, sha, "artifact", aid) def register(items, stage, group, role, worker=False): observation.require(isinstance(items, list), "B3 attempts must be an array") for item in items: fields = ("attempt_id", "artifact_record_id", "artifact_sha256") if worker else RESPONSE observation.keys(item, fields, "B3 "+stage+" attempt") aid = observation.text(item["attempt_id"], "B3 attempt ID") observation.require(aid in archived_attempts and aid not in designated, "B3 unknown/duplicate attempt") source = archived_attempts[aid] observation.require(source["phase"] == "adaptation" and source["role"] == role, "B3 wrong request phase/role") designated[aid], stages[aid], groups[aid] = item, stage, group if worker: artifacts[aid] = optional_artifact(item, aid) else: status = item["response_state"] observation.require(status in ("available", "not_produced", "unavailable"), "B3 invalid response state") if status == "available": responses[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, "B3 absent response requires null record/hash") roots = [a for a in items if archived_attempts[a["attempt_id"]]["retry_of"] is None] observation.require(not items or len(roots) == 1, "B3 stage requires one original request plus transport retries") observation.require(isinstance(row["states"], list), "B3 states must be an array") for state in row["states"]: observation.keys(state, ("state_id", "prompt", "artifact_record_id", "artifact_sha256"), "B3 state") sid = observation.text(state["state_id"], "B3 state ID") observation.require(sid not in states, "duplicate B3 state identity") if state["prompt"] is not None: observation.text(state["prompt"], "B3 directive") states[sid] = state state_data[sid] = optional_artifact(state) init = row["initialization"] observation.keys(init, ("state_id", "worker_attempts", "artifact_attempt_id"), "B3 initialization") observation.require(init["state_id"] in states, "B3 unknown initial state") register(init["worker_attempts"], "initialization", "initialization", "worker", worker=True) observation.require(isinstance(row["iterations"], list), "B3 iterations must be an array") seen_iterations, used_states, last = set(), {init["state_id"]}, 0 for it in row["iterations"]: observation.keys(it, ("iteration_id", "sequence", "incumbent_id", "candidate_id", "generation_attempts", "generation_attempt_id", "worker_attempts", "artifact_attempt_id", "comparisons", "selection", "next_incumbent_id"), "B3 iteration") iid = observation.text(it["iteration_id"], "B3 iteration ID") observation.require(iid not in seen_iterations, "duplicate B3 iteration identity") seen_iterations.add(iid) seq = observation.integer(it["sequence"], 1, "B3 iteration sequence") observation.require(seq > last, "reversed B3 iteration chronology") last = seq inc, cand = it["incumbent_id"], it["candidate_id"] observation.require(inc in used_states and cand in states and cand not in used_states, "B3 invalid incumbent/candidate state link") used_states.add(cand) register(it["generation_attempts"], "generation", (iid, "generation"), "optimizer") register(it["worker_attempts"], "worker", (iid, "worker"), "worker", worker=True) observation.require(isinstance(it["comparisons"], list) and len(it["comparisons"]) == 4, "B3 requires four explicit round slots") rounds = set() for rnd in it["comparisons"]: observation.keys(rnd, ("round", "a_id", "b_id", "attempts", "vote_attempt_id"), "B3 comparison round") n = observation.integer(rnd["round"], 1, "B3 round") observation.require(n in (1, 2, 3, 4) and n not in rounds, "B3 duplicate/invalid round") rounds.add(n) observation.require((rnd["a_id"], rnd["b_id"]) in ((inc, cand), (cand, inc)), "B3 invalid declared A/B mapping") register(rnd["attempts"], "comparison", (iid, n), "comparator") ids = {a["attempt_id"] for a in rnd["attempts"]} observation.require(rnd["vote_attempt_id"] in ids if ids else rnd["vote_attempt_id"] is None, "B3 missing/foreign vote attempt designation") selection = it["selection"] observation.keys(selection, ("state", "record_id", "sha256", "selector_attempts", "result_attempt_id"), "B3 selection descriptor") observation.require(selection["state"] in ("available", "not_executed", "unavailable"), "B3 invalid selection state") if selection["state"] != "available": observation.require(selection["record_id"] is None and selection["sha256"] is None, "B3 absent selection requires null record/hash") register(selection["selector_attempts"], "selection", (iid, "selection"), "selector") ids = {a["attempt_id"] for a in selection["selector_attempts"]} observation.require(selection["result_attempt_id"] in ids if ids else selection["result_attempt_id"] is None, "B3 missing/foreign selector result link") observation.require(it["next_incumbent_id"] is None or it["next_incumbent_id"] in (inc, cand), "B3 invalid next incumbent") observation.require(used_states == set(states), "B3 unreferenced state declaration") expected = {a["attempt_id"] for a in run["attempts"] if a["phase"] == "adaptation" and a["role"] in ("worker", "optimizer", "comparator", "selector")} observation.require(set(designated) == expected, "every archived B3 worker/optimizer/comparator/selector attempt needs an explicit stage, including failures/retries") for aid in designated: parent = archived_attempts[aid]["retry_of"] observation.require(parent is None or (parent in designated and groups[parent] == groups[aid]), "B3 retry crosses iteration/stage/round") contents, decoded, sequences, packet_ids = {}, {}, {}, set() observation.require(isinstance(row["packets"], list), "B3 packet slots must be an array") last = 0 for packet in row["packets"]: observation.keys(packet, ("input_scope", "packet_id", "attempt_id", "sequence", "record_id", "sha256"), "B3 packet") pid, aid = observation.text(packet["packet_id"], "B3 packet ID"), packet["attempt_id"] observation.require(packet["input_scope"] == "native" and pid not in packet_ids and aid in designated and aid not in sequences, "B3 duplicate/unknown packet identity or scope") packet_ids.add(pid) seq = observation.integer(packet["sequence"], 1, "B3 request sequence") observation.require(seq > last, "B3 reversed packet chronology") last, sequences[aid] = seq, seq if packet["record_id"] is None: observation.require(packet["sha256"] is None, "B3 missing input requires null hash") else: rid = packet["record_id"] observation.require(rid in records and records[rid]["kind"] in ("submitted_prompt", "operational_record"), "B3 invalid request record kind") raw = payload(rid, packet["sha256"], records[rid]["kind"], aid) stage = "worker" if stages[aid] == "initialization" else stages[aid] decoded[aid] = decode_input(raw, stage, bounds) contents[pid] = raw observation.require(set(sequences) == set(designated), "B3 missing request slot; use explicit null record/hash") unknown = len(designated)-len(decoded)+sum(a.get("response_state") == "unavailable" for a in designated.values()) def check(value, expected_value, label): observation.require(fingerprint(value) == fingerprint(expected_value), "B3 "+label+" mismatch") def public(value): observation.text(value, "B3 complete public packet") observation.require(observation.sha(value.encode()) == public_hash, "B3 immutable public packet hash mismatch") observation.task_identifiers(value, task_id) def worker_state(items, selected, sid): nonlocal unknown state = states[sid] ids = {a["attempt_id"] for a in items} observation.require(selected in ids if selected is not None else True, "B3 foreign artifact-producing attempt") if selected is None or artifacts.get(selected) is None or state_data[sid] is None: unknown += 1 else: item = designated[selected] check((state["artifact_record_id"], state["artifact_sha256"]), (item["artifact_record_id"], item["artifact_sha256"]), "state artifact binding") for item in items: aid = item["attempt_id"] if aid in decoded: public(decoded[aid]["TASK_PACKET_JSON"]) observation.text(decoded[aid]["CANDIDATE_PROMPT_JSON"], "B3 worker directive") if state["prompt"] is None: unknown += 1 else: check(decoded[aid]["CANDIDATE_PROMPT_JSON"], state["prompt"], "worker directive/state") return selected is not None and artifacts.get(selected) is not None and state_data[sid] is not None and selected in decoded and state["prompt"] is not None initial_template = initial_contract.TEMPLATE_PATH.read_bytes() observation.require(observation.sha(initial_template) == initial_contract.TEMPLATE_SHA256, "B3 initial directive source hash mismatch") p0 = initial_template.decode().split("IMMUTABLE_TASK_PACKET_JSON\n", 1)[0].rstrip("\r\n") if states[init["state_id"]]["prompt"] is not None: check(states[init["state_id"]]["prompt"], p0, "native initial directive") else: unknown += 1 worker_state(init["worker_attempts"], init["artifact_attempt_id"], init["state_id"]) producers = {init["state_id"]: init["artifact_attempt_id"]} previous, iteration_rows = init["state_id"], [] for it in row["iterations"]: inc, cand = it["incumbent_id"], it["candidate_id"] if previous is None: unknown += 1 else: check(inc, previous, "next declared incumbent chain") before = unknown proposals, invalid_proposals = {}, 0 for item in it["generation_attempts"]: aid = item["attempt_id"] if aid in decoded: value = decoded[aid] public(value["TASK_PACKET_JSON"]) observation.text(value["INCUMBENT_PROMPT_JSON"], "B3 incumbent directive") observation.keys(value["INCUMBENT_ARTIFACT_JSON"], ("artifact_id", "text"), "B3 incumbent artifact") observation.text(value["INCUMBENT_ARTIFACT_JSON"]["artifact_id"], "B3 incumbent artifact ID") observation.require(isinstance(value["INCUMBENT_ARTIFACT_JSON"]["text"], str), "B3 incumbent artifact text must be a string") value["INCUMBENT_ARTIFACT_JSON"]["text"].encode("utf-8") if producers.get(inc) is not None: observation.require(sequences[producers[inc]] < sequences[aid], "B3 incumbent worker must precede generation") if states[inc]["prompt"] is None or state_data[inc] is None: unknown += 1 else: check(value["INCUMBENT_PROMPT_JSON"], states[inc]["prompt"], "generation incumbent prompt") check(value["INCUMBENT_ARTIFACT_JSON"], dict(artifact_id=states[inc]["artifact_record_id"], text=state_data[inc].decode()), "generation incumbent artifact") if aid in responses: proposal = xml_response(responses[aid], "generation") if proposal is not None and proposal["prompt"] != states[inc]["prompt"]: proposals[aid] = proposal["prompt"] else: invalid_proposals += 1 chosen = it["generation_attempt_id"] gen_ids = {a["attempt_id"] for a in it["generation_attempts"]} observation.require(chosen in gen_ids if chosen is not None else not it["worker_attempts"], "B3 missing/foreign generation response link") if chosen in proposals: if states[cand]["prompt"] is None: unknown += 1 else: check(states[cand]["prompt"], proposals[chosen], "XML-decoded candidate prompt") elif chosen is not None: observation.require(chosen not in responses or not it["worker_attempts"], "B3 invalid generation response used for execution") observation.require(designated[chosen]["response_state"] != "not_produced" or not it["worker_attempts"], "B3 unproduced generation response cannot supply worker directive") unknown += chosen not in responses candidate_bound = worker_state(it["worker_attempts"], it["artifact_attempt_id"], cand) producers[cand] = it["artifact_attempt_id"] if chosen is not None: for worker in it["worker_attempts"]: observation.require(sequences[chosen] < sequences[worker["attempt_id"]], "B3 generation must precede linked worker request") choices, round_map, comparison_missing, invalid_comparisons = {}, {}, 0, 0 for rnd in it["comparisons"]: round_map[rnd["round"]] = rnd if not rnd["attempts"]: comparison_missing += 1 for item in rnd["attempts"]: aid = item["attempt_id"] if aid in decoded: for sid in (inc, cand): if producers.get(sid) is not None: observation.require(sequences[producers[sid]] < sequences[aid], "B3 output worker must precede comparison") value = decoded[aid] tasks = value["PUBLIC_TASKS_JSON"] observation.require(isinstance(tasks, list) and len(tasks) == 1, "B3 supports exactly one public task") observation.keys(tasks[0], ("task_id", "task_packet"), "B3 public comparison task") check(tasks[0]["task_id"], task_id, "comparison task ID") public(tasks[0]["task_packet"]) for side in ("A", "B"): bundle = value["OUTPUTS_"+side+"_JSON"] observation.require(isinstance(bundle, list) and len(bundle) == 1, "B3 comparison bundle must contain one output") observation.keys(bundle[0], ("task_id", "text"), "B3 anonymous output") check(bundle[0]["task_id"], task_id, "anonymous output task ID") observation.require(isinstance(bundle[0]["text"], str), "B3 output text must be a string") data = state_data[rnd[side.lower()+"_id"]] if data is None: unknown += 1 else: check(bundle[0]["text"], data.decode(), "anonymous A/B mapping") if aid in responses: vote = xml_response(responses[aid], "comparison") choices[aid] = None if vote is None else vote["choose"] invalid_comparisons += vote is None elif item["response_state"] == "not_produced": choices[aid] = None sel = it["selection"] verified, comparison_complete = False, False for item in sel["selector_attempts"]: aid = item["attempt_id"] if aid in decoded: value = decoded[aid] check((value["INCUMBENT_ID_JSON"], value["CANDIDATE_ID_JSON"]), (inc, cand), "selector pair identities") selector_records = value["COMPARISON_RECORDS_JSON"] observation.require(isinstance(selector_records, list) and all(isinstance(r, dict) and set(r) == {"round", "a_id", "b_id", "choice"} for r in selector_records), "B3 model-selector records contain unsupported fields") if sel["state"] == "available": envelope = observation.parse_json(payload(sel["record_id"], sel["sha256"], "operational_record"), "B3 deterministic selection record") observation.keys(envelope, ("selection_record_version", "records", "result"), "B3 selection record") observation.require(envelope["selection_record_version"] == "1.0" and isinstance(envelope["records"], list), "unsupported B3 selection record") comparison_complete = selection_consistent(envelope["records"], envelope["result"], inc, cand) verified = True for record in envelope["records"]: if isinstance(record, dict) and type(record.get("round")) is int and record["round"] in round_map: rnd = round_map[record["round"]] if "a_id" in record and "b_id" in record: check((record["a_id"], record["b_id"]), (rnd["a_id"], rnd["b_id"]), "selection record/declared A/B mapping") if record.get("a_id") == rnd["a_id"] and record.get("b_id") == rnd["b_id"]: source = rnd["vote_attempt_id"] if source is None: check(record.get("choice"), None, "missing round cannot supply a vote") elif source in choices: check(record.get("choice"), choices[source], "recorded vote/source response") else: unknown += 1 verified = False if it["next_incumbent_id"] is None: unknown += 1 else: check(it["next_incumbent_id"], envelope["result"]["selected_id"], "recorded selection/next incumbent") for item in sel["selector_attempts"]: aid = item["attempt_id"] if aid in decoded: check(decoded[aid], dict(INCUMBENT_ID_JSON=inc, CANDIDATE_ID_JSON=cand, COMPARISON_RECORDS_JSON=envelope["records"]), "selector permitted input") observation.require(all(isinstance(r, dict) and set(r) == {"round", "a_id", "b_id", "choice"} for r in envelope["records"]), "B3 model-selector records contain unsupported fields") for rnd in it["comparisons"]: if rnd["vote_attempt_id"] is not None: observation.require(sequences[rnd["vote_attempt_id"]] < sequences[aid], "B3 comparison must precede selector") selected = sel["result_attempt_id"] if selected is not None: if selected in responses: check(observation.parse_json(responses[selected], "B3 selector response"), envelope["result"], "selector output/record") else: unknown += 1 verified = False elif sel["state"] == "not_executed": if it["next_incumbent_id"] is None: unknown += 1 else: check(it["next_incumbent_id"], inc, "interrupted iteration must retain incumbent") else: unknown += 1 iteration_attempts = [aid for aid in designated if isinstance(groups[aid], tuple) and groups[aid][0] == it["iteration_id"]] missing_iteration_inputs = sum(aid not in decoded for aid in iteration_attempts) unavailable_iteration_responses = sum(designated[aid].get("response_state") == "unavailable" for aid in iteration_attempts) iteration_rows.append(dict(iteration_id=it["iteration_id"], selection_verified=verified, comparison_complete=comparison_complete, iteration_complete=bool(chosen in proposals and chosen in decoded and candidate_bound and comparison_complete and verified and missing_iteration_inputs == 0 and unavailable_iteration_responses == 0 and unknown == before), rejected_candidate=verified and comparison_complete and it["next_incumbent_id"] == inc, retained_due_incomplete_comparison=verified and not comparison_complete, generation_invalid_response_count=invalid_proposals, comparison_invalid_response_count=invalid_comparisons, not_attempted_comparison_count=comparison_missing, selection_state=sel["state"], evidence_gap_count=unknown-before, missing_input_count=missing_iteration_inputs, unavailable_response_count=unavailable_iteration_responses)) previous = it["next_incumbent_id"] if previous is not None and row["final_incumbent_id"] is not None: check(row["final_incumbent_id"], previous, "final incumbent chain") else: unknown += 1 final = row["final_incumbent_id"] observation.require(final is None or final in states, "B3 unknown final incumbent") if final is not None and state_data[final] is not None: if run["endpoint_selection"]["artifact_id"] is None: unknown += 1 else: check(run["endpoint_selection"]["artifact_id"], states[final]["artifact_record_id"], "prescribed endpoint/incumbent artifact") else: unknown += 1 coverage = dict(evidence_complete=unknown == 0, evidence_gap_count=unknown, initialization="native candidate-worker wrapper with common directive P0", initialization_attempt_count=len(init["worker_attempts"]), iteration_denominator=len(iteration_rows), iterations=iteration_rows, incomplete_iteration_count=sum(not x["iteration_complete"] for x in iteration_rows), rejected_candidate_count=sum(x["rejected_candidate"] for x in iteration_rows), incomplete_selection_retention_count=sum(x["retained_due_incomplete_comparison"] for x in iteration_rows), missing_input_count=len(designated)-len(decoded), unavailable_response_count=sum(a.get("response_state") == "unavailable" for a in designated.values()), not_produced_response_count=sum(a.get("response_state") == "not_produced" for a in designated.values()), retry_attempt_count=sum(archived_attempts[aid]["retry_of"] is not None for aid in designated), stage_attempt_counts={s: sum(stage == s for stage in stages.values()) for s in ("initialization", "generation", "worker", "comparison", "selection")}, attempt_status_counts={s: sum(archived_attempts[aid]["status"] == s for aid in designated) for s in ("succeeded", "failed", "cancelled", "incomplete", "unknown")}) return coverage, contents def scope_coverage(run, judgment): 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) return {"initial": dict(empty), "continuation": dict(empty)} def aggregate(rows): values = [r["b3_native_coverage"] for r in rows if "b3_native_coverage" in r] fields = ("initialization_attempt_count", "iteration_denominator", "incomplete_iteration_count", "rejected_candidate_count", "incomplete_selection_retention_count", "missing_input_count", "unavailable_response_count", "not_produced_response_count", "retry_attempt_count") return dict(assigned_run_denominator=len(rows), b3_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})