"""Offline b2-critique-revision/1.0 structural adapter; development defaults unfrozen.""" import json from pathlib import Path import re import b1_contract observation = b1_contract.observation CONTRACT = "b2-critique-revision/1.0" BASE = Path(__file__).resolve().parent.parent/"baseline-prompts" TEMPLATES = { "critique": (BASE/"b2-critique.txt", "94211f9a78516ead0837d2e6a0d8960f9ff15b891c6a7bb63c67b61acb2412bb"), "revision": (BASE/"b2-revision.txt", "e4004fce79bb54ba198730dc2190a9d743917ce9a49b1ff40f6b968d80ef5962"), } CONTEXT = b1_contract.PLACEHOLDERS def request_roles(declaration): return {a["attempt_id"]: role for pair in declaration["pairs"] for role, field in (("critique", "critique_attempts"), ("revision", "revision_attempts")) for a in pair[field]} def designated_attempts(run, declaration, worker_slots): """Use explicit pair identities; never classify text or infer request stages.""" revisions = b1_contract.continuation_attempts(run, worker_slots) critics = {a["attempt_id"]: a for a in run["attempts"] if a["phase"] == "adaptation" and a["role"] == "critic"} expected = {**critics, **revisions} pairs, members, responses = set(), {}, {} observation.require(isinstance(declaration["pairs"], list), "B2 pairs must be an array") for pair in declaration["pairs"]: observation.keys(pair, ("pair_id", "critique_attempts", "revision_attempts", "revision_coverage"), "B2 pair") pid = observation.text(pair["pair_id"], "B2 pair ID") observation.require(pid not in pairs, "duplicate B2 pair identity") pairs.add(pid) for role, field in (("critique", "critique_attempts"), ("revision", "revision_attempts")): attempts = pair[field] observation.require(isinstance(attempts, list) and (role != "critique" or attempts), "B2 pair needs explicit critique attempts") for item in attempts: fields = (("attempt_id", "response_state", "response_record_id", "response_sha256") if role == "critique" else ("attempt_id", "critique_attempt_id")) observation.keys(item, fields, "B2 "+role+" designation") aid = observation.text(item["attempt_id"], "B2 attempt ID") allowed = critics if role == "critique" else revisions observation.require(aid in allowed and aid not in members, "unknown, wrong-role or duplicate B2 attempt identity") members[aid] = (pid, role) if role == "critique": state = item["response_state"] observation.require(state in ("available", "not_produced", "unavailable"), "unsupported B2 response state") if state == "available": rid = observation.text(item["response_record_id"], "B2 response record ID") observation.require(rid not in responses or responses[rid] == pid, "B2 response record reused across pairs") responses[rid] = pid observation.require(isinstance(item["response_sha256"], str) and re.fullmatch(r"[0-9a-f]{64}", item["response_sha256"]) is not None, "invalid B2 response SHA-256") else: observation.require(item["response_record_id"] is None and item["response_sha256"] is None, "absent B2 response must have null record/hash") roots = [a for a in attempts if expected[a["attempt_id"]]["retry_of"] is None] observation.require(not attempts or len(roots) == 1, "B2 stage must contain one request root plus explicit transport retries") critiques = {a["attempt_id"]: a for a in pair["critique_attempts"]} links = set() for rev in pair["revision_attempts"]: linked = rev["critique_attempt_id"] observation.require(isinstance(linked, str) and linked in critiques, "B2 revision must link a critique attempt in its own pair") observation.require(critiques[linked]["response_state"] != "not_produced", "B2 revision cannot use a declared unproduced response") links.add(linked) observation.require(len(links) <= 1, "B2 transport revision retries must retain the same critique response link") state = pair["revision_coverage"] observation.require(state in ("attempted", "not_attempted", "unknown"), "unsupported B2 revision coverage state") observation.require(bool(pair["revision_attempts"]) == (state == "attempted"), "B2 revision coverage contradicts its explicit attempts") observation.require(set(members) == set(expected), "every archived critic and noninitial worker attempt needs a B2 pair designation, including failures/retries") for aid, attempt in expected.items(): parent = attempt["retry_of"] observation.require(parent is None or (parent in members and members[parent] == members[aid]), "B2 retry must remain in the same pair and stage") return expected def validate_input(content, bounds, task_id, public_packet_sha256, role): observation.require(role in TEMPLATES, "unsupported B2 request stage") observation.require(len(content) <= bounds["max_input_bytes"], "B2 input byte bound exceeded") path, expected = TEMPLATES[role] template = path.read_bytes() observation.require(observation.sha(template) == expected, "B2 template hash mismatch") rendered = content.decode("utf-8") observation.require(observation.MARKER.search(rendered) is None, "B2 input has unresolved placeholders") placeholders = (*CONTEXT, "CURRENT_CRITIQUE_JSON") if role == "revision" else CONTEXT parts = re.split(r"(\{\{[A-Z_]+\}\})", template.decode("utf-8")) observation.require(parts[1::2] == ["{{"+p+"}}" for p in placeholders], "unsupported B2 template placeholders") values, cursor = {}, 0 for index, name in enumerate(placeholders): prefix = parts[index*2] observation.require(rendered.startswith(prefix, cursor), "B2 input does not have the unchanged literal wrapper") cursor += len(prefix) start = cursor while cursor < len(rendered) and rendered[cursor] in " \t\r\n": cursor += 1 _, end = json.JSONDecoder().raw_decode(rendered, cursor) values[name] = observation.parse_json(rendered[start:end].encode("utf-8"), "B2 "+name) cursor = end observation.require(rendered[cursor:] == parts[-1], "B2 input does not have the unchanged literal wrapper") # Non-exported projection reuses B1's identical four-field bounded-context # validator. Raw B2 wrapper validation above is mandatory; no input is repaired. projection = b1_contract.TEMPLATE_PATH.read_bytes().decode("utf-8") for name in CONTEXT: projection = projection.replace("{{"+name+"}}", observation.canonical(values[name])) projection_bytes = projection.encode("utf-8") b1_contract.validate_input(projection_bytes, dict(bounds, max_input_bytes=max(bounds["max_input_bytes"], len(projection_bytes))), task_id, public_packet_sha256) if role == "revision": observation.require(isinstance(values["CURRENT_CRITIQUE_JSON"], str), "B2 current critique must be a JSON string") values["CURRENT_CRITIQUE_JSON"].encode("utf-8") return values def context(values): return observation.canonical({key: values[key] for key in CONTEXT}) def validate_pairs(declaration, run, records, read_record, decoded, packet_sequences): """Check sealed response identity/bytes and linked contexts; never fill gaps.""" attempts = {a["attempt_id"]: a for a in run["attempts"]} rows = [] for pair in declaration["pairs"]: responses, available, absent, no_response = {}, 0, 0, 0 critique_ids = [a["attempt_id"] for a in pair["critique_attempts"]] revision_ids = [a["attempt_id"] for a in pair["revision_attempts"]] for item in pair["critique_attempts"]: aid = item["attempt_id"] if item["response_state"] == "available": rid = item["response_record_id"] observation.require(rid in attempts[aid]["record_ids"] and rid in run["record_ids"] and rid in records, "B2 response not linked to its declared run and critic attempt") record = records[rid] observation.require(record["kind"] == "operational_record", "B2 critique response must be an operational record, never a delivered artifact") observation.require(record["sha256"] == item["response_sha256"], "B2 response hash mismatch") raw = read_record(record) observation.require(observation.sha(raw) == item["response_sha256"], "B2 archived response bytes/hash mismatch") raw.decode("utf-8") responses[aid] = raw available += 1 elif item["response_state"] == "unavailable": absent += 1 else: no_response += 1 known_contexts = [context(decoded[aid]) for aid in [*critique_ids, *revision_ids] if aid in decoded] observation.require(len(set(known_contexts)) <= 1, "B2 paired task/artifact/history context mismatch") verified = 0 for revision in pair["revision_attempts"]: aid, linked = revision["attempt_id"], revision["critique_attempt_id"] observation.require(packet_sequences[linked] < packet_sequences[aid], "B2 linked critique request must precede its revision") if aid in decoded and linked in responses: supplied = decoded[aid]["CURRENT_CRITIQUE_JSON"].encode("utf-8") observation.require(supplied == responses[linked], "B2 revision critique differs from exact linked archived response") if linked in decoded: verified += 1 missing_inputs = sum(aid not in decoded for aid in [*critique_ids, *revision_ids]) complete = missing_inputs == 0 and absent == 0 and pair["revision_coverage"] != "unknown" # An available response is never promoted to an artifact or model input. rows.append(dict(pair_id=pair["pair_id"], revision_coverage=pair["revision_coverage"], critique_attempt_count=len(critique_ids), revision_attempt_count=len(revision_ids), critique_retry_count=sum(attempts[aid]["retry_of"] is not None for aid in critique_ids), revision_retry_count=sum(attempts[aid]["retry_of"] is not None for aid in revision_ids), attempt_status_counts={s: sum(attempts[aid]["status"] == s for aid in [*critique_ids, *revision_ids]) for s in ("succeeded", "failed", "incomplete", "cancelled", "unknown")}, available_response_count=available, unavailable_response_count=absent, declared_not_produced_response_count=no_response, missing_input_count=missing_inputs, missing_critique_input_count=sum(aid not in decoded for aid in critique_ids), missing_revision_input_count=sum(aid not in decoded for aid in revision_ids), verified_revision_link_count=verified, fully_linked=bool(revision_ids) and verified == len(revision_ids) and complete, evidence_complete=complete)) return dict(pair_denominator=len(rows), pairs=rows, evidence_complete=all(r["evidence_complete"] for r in rows), fully_linked_pair_count=sum(r["fully_linked"] for r in rows), critique_without_revision_count=sum(r["revision_coverage"] == "not_attempted" for r in rows), unknown_revision_coverage_pair_count=sum(r["revision_coverage"] == "unknown" for r in rows), unavailable_response_count=sum(r["unavailable_response_count"] for r in rows), declared_not_produced_response_count=sum(r["declared_not_produced_response_count"] for r in rows), missing_input_count=sum(r["missing_input_count"] for r in rows), critique_attempt_count=sum(r["critique_attempt_count"] for r in rows), revision_attempt_count=sum(r["revision_attempt_count"] for r in rows), critique_retry_count=sum(r["critique_retry_count"] for r in rows), revision_retry_count=sum(r["revision_retry_count"] for r in rows)) def aggregate(rows): selected = [r["b2_pair_coverage"] for r in rows if "b2_pair_coverage" in r] fields = ("pair_denominator", "fully_linked_pair_count", "critique_without_revision_count", "unknown_revision_coverage_pair_count", "unavailable_response_count", "declared_not_produced_response_count", "missing_input_count", "critique_attempt_count", "revision_attempt_count", "critique_retry_count", "revision_retry_count") return dict(assigned_run_denominator=len(rows), b2_in_scope_run_count=len(selected), evidence_incomplete_run_count=sum(not r["evidence_complete"] for r in selected), **{field: sum(r[field] for r in selected) for field in fields})