"""Audit the completeness of an invented AI architecture review packet. The result is a local evidence-readiness signal, not architecture approval, deployment authorization, certification, or a substitute for accountable review. """ from dataclasses import asdict, dataclass, fields import hashlib import json import math DIMENSION_IDS = ( "system-boundary", "workload-and-slos", "model-data-evaluation", "security-safety-governance", "infrastructure-cost-reliability", "migration-and-operations", ) DIMENSION_STATUSES = ("PASS", "GAP") def identity(value, *, maximum=160): if type(value) is not str or not value or value != value.strip(): raise ValueError("exact non-empty identity required") if len(value) > maximum or any(ord(character) < 32 for character in value): raise ValueError("bounded printable identity required") return value def sha256_text(value): identity(value, maximum=64) if len(value) != 64 or any(character not in "0123456789abcdef" for character in value): raise ValueError("lowercase sha256 digest required") return value def integer(value, lower, upper): if type(value) is not int or not lower <= value <= upper: raise ValueError("bounded non-boolean integer required") return value def finite_float(value, lower, upper): if type(value) is not float or not math.isfinite(value): raise ValueError("exact finite float required") if not lower <= value <= upper: raise ValueError("bounded finite float required") return value def exact_bool(value): if type(value) is not bool: raise ValueError("exact boolean required") return value def bounded_sequence(value, lower, upper): if type(value) not in (tuple, list): raise ValueError("bounded tuple or list required") integer(len(value), lower, upper) return tuple(value) def identity_tuple(value, lower, upper): result = bounded_sequence(value, lower, upper) for item in result: identity(item) if len(result) != len(set(result)): raise ValueError("duplicate identity") return result def digest(value): try: encoded = json.dumps( value, sort_keys=True, separators=(",", ":"), allow_nan=False ).encode() except (TypeError, ValueError, OverflowError) as error: raise ValueError("canonical JSON value required") from error return hashlib.sha256(encoded).hexdigest() def token(label): identity(label) return hashlib.sha256(label.encode()).hexdigest() def seal(record): if type(record.content_id) is not str: raise ValueError("content digest requires exact string") data = asdict(record) data.pop("content_id") return digest(data) def validate_record(record, cls): if type(record) is not cls: raise ValueError("concrete frozen record required") try: rebuilt = cls( **{field.name: getattr(record, field.name) for field in fields(cls)} ) except (AttributeError, TypeError, ValueError, OverflowError) as error: raise ValueError("malformed record") from error if record != rebuilt or record.content_id != rebuilt.content_id: raise ValueError("noncanonical or modified record") return rebuilt def scope_tuple(value): return identity_tuple(value, 6, 6) @dataclass(frozen=True) class ArchitectureContract: scope: tuple = ( "business-context-v1", "architecture-review-v1", "evaluation-policy-v1", "risk-policy-v1", "operating-envelope-v1", "fixture-v1", ) required_dimensions: tuple = DIMENSION_IDS minimum_alternatives: int = 2 maximum_evidence_age_days: int = 30 minimum_failure_scenarios: int = 6 minimum_capacity_headroom_fraction: float = 0.20 maximum_open_high_risks: int = 0 require_named_owners: bool = True content_id: str = "" def __post_init__(self): object.__setattr__(self, "scope", scope_tuple(self.scope)) object.__setattr__( self, "required_dimensions", identity_tuple(self.required_dimensions, 4, 20), ) integer(self.minimum_alternatives, 2, 100) integer(self.maximum_evidence_age_days, 0, 3650) integer(self.minimum_failure_scenarios, 1, 100_000) finite_float(self.minimum_capacity_headroom_fraction, 0.0, 1.0) integer(self.maximum_open_high_risks, 0, 100_000) if exact_bool(self.require_named_owners) is not True: raise ValueError("architecture packet requires named ownership") expected = seal(self) if self.content_id and self.content_id != expected: raise ValueError("architecture contract digest mismatch") object.__setattr__(self, "content_id", expected) @dataclass(frozen=True) class DimensionEvidence: scope: tuple packet_id: str system_id: str architecture_revision: str dimension_id: str owner: str decision_record_id: str evidence_digest: str status: str evidence_age_days: int assumptions_closed: bool failure_scenario_count: int rollback_defined: bool tradeoff_recorded: bool content_id: str = "" def __post_init__(self): object.__setattr__(self, "scope", scope_tuple(self.scope)) identity(self.packet_id) identity(self.system_id) identity(self.architecture_revision) identity(self.dimension_id) identity(self.owner) identity(self.decision_record_id) sha256_text(self.evidence_digest) identity(self.status) if self.status not in DIMENSION_STATUSES: raise ValueError("unknown review dimension status") integer(self.evidence_age_days, 0, 3650) exact_bool(self.assumptions_closed) integer(self.failure_scenario_count, 0, 100_000) exact_bool(self.rollback_defined) exact_bool(self.tradeoff_recorded) expected = seal(self) if self.content_id and self.content_id != expected: raise ValueError("dimension evidence digest mismatch") object.__setattr__(self, "content_id", expected) @dataclass(frozen=True) class OperationalEvidence: scope: tuple packet_id: str system_id: str architecture_revision: str owner: str source_id: str observed_at: str evidence_age_days: int quality_evidence_id: str latency_evidence_id: str cost_evidence_id: str capacity_evidence_id: str quality_gate_passed: bool latency_slo_met: bool cost_budget_met: bool capacity_headroom_fraction: float content_id: str = "" def __post_init__(self): object.__setattr__(self, "scope", scope_tuple(self.scope)) identity(self.packet_id) identity(self.system_id) identity(self.architecture_revision) identity(self.owner) identity(self.source_id) identity(self.observed_at) integer(self.evidence_age_days, 0, 3650) sha256_text(self.quality_evidence_id) sha256_text(self.latency_evidence_id) sha256_text(self.cost_evidence_id) sha256_text(self.capacity_evidence_id) exact_bool(self.quality_gate_passed) exact_bool(self.latency_slo_met) exact_bool(self.cost_budget_met) finite_float(self.capacity_headroom_fraction, 0.0, 1.0) expected = seal(self) if self.content_id and self.content_id != expected: raise ValueError("operational evidence digest mismatch") object.__setattr__(self, "content_id", expected) @dataclass(frozen=True) class ArchitectureEvidence: scope: tuple contract_content_id: str packet_id: str system_id: str architecture_revision: str selected_option: str operating_owner: str decision_authority: str alternatives_compared: int operational: OperationalEvidence open_high_risks: int executive_tradeoffs_recorded: bool dimensions: tuple content_id: str = "" def __post_init__(self): object.__setattr__(self, "scope", scope_tuple(self.scope)) sha256_text(self.contract_content_id) identity(self.packet_id) identity(self.system_id) identity(self.architecture_revision) identity(self.selected_option) identity(self.operating_owner) identity(self.decision_authority) integer(self.alternatives_compared, 0, 100) operational = validate_record(self.operational, OperationalEvidence) if operational.scope != self.scope: raise ValueError("operational evidence outside architecture scope") if ( operational.packet_id != self.packet_id or operational.system_id != self.system_id or operational.architecture_revision != self.architecture_revision ): raise ValueError("operational evidence belongs to another architecture") integer(self.open_high_risks, 0, 100_000) exact_bool(self.executive_tradeoffs_recorded) dimensions = bounded_sequence(self.dimensions, 1, 20) rebuilt = tuple(validate_record(item, DimensionEvidence) for item in dimensions) if any(item.scope != self.scope for item in rebuilt): raise ValueError("dimension evidence outside architecture scope") if any( item.packet_id != self.packet_id or item.system_id != self.system_id or item.architecture_revision != self.architecture_revision for item in rebuilt ): raise ValueError("dimension evidence belongs to another architecture") identifiers = tuple(item.dimension_id for item in rebuilt) if len(identifiers) != len(set(identifiers)): raise ValueError("duplicate architecture dimension evidence") object.__setattr__(self, "operational", operational) object.__setattr__(self, "dimensions", rebuilt) expected = seal(self) if self.content_id and self.content_id != expected: raise ValueError("architecture evidence digest mismatch") object.__setattr__(self, "content_id", expected) @dataclass(frozen=True) class ArchitectureReport: decision: str violations: tuple packet_id: str system_id: str selected_option: str dimensions_present: int dimensions_required: int failure_scenarios: int evidence_id: str claim: str = "LOCAL_PACKET_COMPLETENESS_AUDIT_NOT_ARCHITECTURE_APPROVAL" def review_architecture( contract: ArchitectureContract, evidence: ArchitectureEvidence ) -> ArchitectureReport: """Check packet completeness without approving or deploying an architecture.""" contract = validate_record(contract, ArchitectureContract) evidence = validate_record(evidence, ArchitectureEvidence) if evidence.scope != contract.scope or evidence.contract_content_id != contract.content_id: raise ValueError("evidence belongs to another architecture contract") required = set(contract.required_dimensions) observed = {item.dimension_id: item for item in evidence.dimensions} if set(observed) - required: raise ValueError("evidence contains dimensions outside the contract") violations = [] for dimension_id in contract.required_dimensions: dimension = observed.get(dimension_id) if dimension is None: violations.append(f"missing-dimension:{dimension_id}") continue if dimension.status != "PASS": violations.append(f"dimension-gap:{dimension_id}") if dimension.evidence_age_days > contract.maximum_evidence_age_days: violations.append(f"stale-evidence:{dimension_id}") if not dimension.assumptions_closed: violations.append(f"open-assumptions:{dimension_id}") if dimension.failure_scenario_count == 0: violations.append(f"untested-failure:{dimension_id}") if not dimension.rollback_defined: violations.append(f"rollback-gap:{dimension_id}") if not dimension.tradeoff_recorded: violations.append(f"tradeoff-gap:{dimension_id}") failure_scenarios = sum( dimension.failure_scenario_count for dimension in observed.values() ) if evidence.alternatives_compared < contract.minimum_alternatives: violations.append("alternatives-incomplete") if failure_scenarios < contract.minimum_failure_scenarios: violations.append("failure-coverage") if evidence.operational.evidence_age_days > contract.maximum_evidence_age_days: violations.append("stale-operational-evidence") if not evidence.operational.quality_gate_passed: violations.append("quality-gate") if not evidence.operational.latency_slo_met: violations.append("latency-slo") if not evidence.operational.cost_budget_met: violations.append("cost-budget") if ( evidence.operational.capacity_headroom_fraction < contract.minimum_capacity_headroom_fraction ): violations.append("capacity-headroom") if evidence.open_high_risks > contract.maximum_open_high_risks: violations.append("open-high-risks") if not evidence.executive_tradeoffs_recorded: violations.append("executive-tradeoffs") return ArchitectureReport( decision="REVISE_PACKET" if violations else "READY_FOR_DECISION", violations=tuple(violations), packet_id=evidence.packet_id, system_id=evidence.system_id, selected_option=evidence.selected_option, dimensions_present=len(observed), dimensions_required=len(contract.required_dimensions), failure_scenarios=failure_scenarios, evidence_id=evidence.content_id, ) def illustrative_fixture(): contract = ArchitectureContract() packet_id = "review-packet-2026-09-27" system_id = "support-assistant" architecture_revision = "architecture-v7" dimensions = tuple( DimensionEvidence( scope=contract.scope, packet_id=packet_id, system_id=system_id, architecture_revision=architecture_revision, dimension_id=dimension_id, owner=f"owner-{index}", decision_record_id=f"ADR-{100 + index}", evidence_digest=token(f"{dimension_id}-evidence-v1"), status="PASS", evidence_age_days=5 + index, assumptions_closed=True, failure_scenario_count=2, rollback_defined=True, tradeoff_recorded=True, ) for index, dimension_id in enumerate(contract.required_dimensions, start=1) ) operational = OperationalEvidence( scope=contract.scope, packet_id=packet_id, system_id=system_id, architecture_revision=architecture_revision, owner="service-reliability-owner", source_id="qualified-operating-envelope-run-v4", observed_at="2026-09-27T08:00:00Z", evidence_age_days=1, quality_evidence_id=token("quality-evidence-v4"), latency_evidence_id=token("latency-evidence-v4"), cost_evidence_id=token("cost-evidence-v4"), capacity_evidence_id=token("capacity-evidence-v4"), quality_gate_passed=True, latency_slo_met=True, cost_budget_met=True, capacity_headroom_fraction=0.30, ) evidence = ArchitectureEvidence( scope=contract.scope, contract_content_id=contract.content_id, packet_id=packet_id, system_id=system_id, architecture_revision=architecture_revision, selected_option="bounded-platform-with-managed-models", operating_owner="ai-platform-team", decision_authority="architecture-review-board", alternatives_compared=3, operational=operational, open_high_risks=0, executive_tradeoffs_recorded=True, dimensions=dimensions, ) return contract, evidence def main(): contract, evidence = illustrative_fixture() report = review_architecture(contract, evidence) print("example=illustrative_only") print(f"decision={report.decision}") print(f"packet={report.packet_id};system={report.system_id}") print( f"dimensions={report.dimensions_present}/{report.dimensions_required};" f"failure_scenarios={report.failure_scenarios}" ) print(f"selected_option={report.selected_option}") print(f"claim={report.claim}") if __name__ == "__main__": main()