""" Digital Mycelium Trinity Assay v0.4-full runner. Core law: A scar is not a defect in the receipt. The scar is what prevents false return. Safety boundary: This runner consumes synthetic structured evidence only. It does not execute payloads, scan files, analyze malware, interact with networks, or perform offensive security tasks. """ from __future__ import annotations import json from typing import Any, Dict, Mapping, Tuple THRESHOLD = 0.90 IDENTITY_SIMILARITY_MIN = 0.80 EDGE_WEIGHT = 0.60 EDIT_WEIGHT = 0.40 class TrinityInputError(ValueError): """Raised when the v0.4-full runner input is malformed.""" def _require_mapping(data: Mapping[str, Any], key: str) -> Mapping[str, Any]: value = data.get(key) if not isinstance(value, Mapping): raise TrinityInputError(f"Missing or invalid object: {key}") return value def _bool_field(data: Mapping[str, Any], key: str, default: bool = False) -> bool: value = data.get(key, default) if not isinstance(value, bool): raise TrinityInputError(f"Expected boolean field evidence.{key}, got {type(value).__name__}") return value def _float_field(data: Mapping[str, Any], key: str, default: float) -> float: value = data.get(key, default) if not isinstance(value, (int, float)): raise TrinityInputError(f"Expected numeric field {key}, got {type(value).__name__}") value = float(value) if value < 0.0 or value > 1.0: raise TrinityInputError(f"Expected {key} in [0.0, 1.0], got {value}") return value def compute_final_isomorphism(edge_overlap: float, edit_retention: float) -> float: return round((edge_overlap * EDGE_WEIGHT) + (edit_retention * EDIT_WEIGHT), 3) def infer_repair_type(evidence: Mapping[str, Any]) -> str: has_scar_node = _bool_field(evidence, "scar_node_present") damage_receipt_present = _bool_field(evidence, "damage_receipt_present") trace_ids_preserved = _bool_field(evidence, "trace_ids_preserved") reset_marker = _bool_field(evidence, "reset_marker_present") quarantine_claimed = _bool_field(evidence, "quarantine_claimed") contamination_connected = _bool_field(evidence, "contamination_connected") identity_similarity = _float_field(evidence, "identity_similarity", 1.0) if reset_marker and not has_scar_node: return "silent_reset" if quarantine_claimed and contamination_connected: return "fake_quarantine" if identity_similarity < IDENTITY_SIMILARITY_MIN: return "overrepair_identity_swap" if not trace_ids_preserved and damage_receipt_present: return "trace_erasing" if has_scar_node and damage_receipt_present and trace_ids_preserved and not reset_marker: return "honest_scar" return "unknown_or_below_threshold" def mycelium_v04_full_runner(raw_input: str | Mapping[str, Any]) -> Dict[str, Any]: """ Run the v0.4-full Trinity Assay on structured evidence. Input must contain: - evidence: scar/trace/reset/quarantine/identity fields - graph_delta: edge_overlap and edit_retention fields The runner does not accept declared repair_type as authority. """ if isinstance(raw_input, str): data = json.loads(raw_input) elif isinstance(raw_input, Mapping): data = raw_input else: raise TrinityInputError("Input must be JSON string or mapping") evidence = _require_mapping(data, "evidence") graph_delta = _require_mapping(data, "graph_delta") has_scar_node = _bool_field(evidence, "scar_node_present") damage_receipt_present = _bool_field(evidence, "damage_receipt_present") trace_ids_preserved = _bool_field(evidence, "trace_ids_preserved") reset_marker = _bool_field(evidence, "reset_marker_present") quarantine_claimed = _bool_field(evidence, "quarantine_claimed") contamination_connected = _bool_field(evidence, "contamination_connected") identity_similarity = _float_field(evidence, "identity_similarity", 1.0) edge_overlap = _float_field(graph_delta, "edge_overlap", 0.0) edit_retention = _float_field(graph_delta, "edit_retention", 0.0) final_iso = compute_final_isomorphism(edge_overlap, edit_retention) derived_repair = infer_repair_type(evidence) scar_preserved = ( has_scar_node and damage_receipt_present and trace_ids_preserved and not reset_marker ) trace_erased = not trace_ids_preserved reset_to_clean_baseline = reset_marker fake_quarantine = quarantine_claimed and contamination_connected identity_swap_risk = identity_similarity < IDENTITY_SIMILARITY_MIN false_return_detected = reset_to_clean_baseline or trace_erased or fake_quarantine resonance_earned = ( final_iso >= THRESHOLD and scar_preserved and not trace_erased and not reset_to_clean_baseline and not fake_quarantine and not identity_swap_risk ) if resonance_earned: classification = "PASS_HONEST_SCAR_REPAIR" elif identity_swap_risk: classification = "HELD_IDENTITY_SWAP_RISK" elif false_return_detected: classification = "FALSE_RETURN_OR_FAIL" else: classification = "HELD_BELOW_RESONANCE_THRESHOLD" return { "version": "v0.4-full", "derived_repair_type": derived_repair, "classification": classification, "scar_preserved": scar_preserved, "trace_erased": trace_erased, "reset_to_clean_baseline": reset_to_clean_baseline, "fake_quarantine": fake_quarantine, "identity_swap_risk": identity_swap_risk, "false_return_detected": false_return_detected, "edge_overlap": edge_overlap, "edit_retention": edit_retention, "final_isomorphism": final_iso, "threshold": THRESHOLD, "resonance_earned": resonance_earned, "enforcement": "repair_type_inferred_from_structured_evidence", "computational_law": ( "resonance_earned only if final_iso>=0.90, scar_preserved=true, " "trace_erased=false, reset_to_clean_baseline=false, fake_quarantine=false, " "identity_swap_risk=false" ), "core_law": "A scar is not a defect in the receipt. The scar is what prevents false return.", "status": "LOCKED_FULLY_ENFORCING" } def run_battery(fixtures: list[Mapping[str, Any]]) -> Tuple[list[Dict[str, Any]], Dict[str, Any]]: rows = [] passed = 0 for fixture in fixtures: case = fixture["case"] expected = fixture["expected"] output = mycelium_v04_full_runner(fixture["runner_input"]) actual = output["classification"] ok = actual == expected passed += int(ok) rows.append({ "case": case, "expected": expected, "actual": actual, "passed": ok, "reason": fixture.get("reason", ""), "final_isomorphism": output["final_isomorphism"], "resonance_earned": output["resonance_earned"], "derived_repair_type": output["derived_repair_type"] }) summary = { "total": len(fixtures), "passed": passed, "failed": len(fixtures) - passed, "status": "PASS" if passed == len(fixtures) else "FAIL" } return rows, summary if __name__ == "__main__": import argparse from pathlib import Path parser = argparse.ArgumentParser(description="Run Digital Mycelium Trinity Assay v0.4-full.") parser.add_argument("input", nargs="?", default="battery_fixtures.json", help="Path to fixture JSON or single runner input JSON") args = parser.parse_args() payload = json.loads(Path(args.input).read_text(encoding="utf-8")) if isinstance(payload, list): rows, summary = run_battery(payload) print(json.dumps({"rows": rows, "summary": summary}, indent=2)) else: print(json.dumps(mycelium_v04_full_runner(payload), indent=2))