LOOPGUARD-AI — CANONICAL PROOF OF CONCEPT V1.0.11

RATIUM.AI — Independent R&D (AI Systems)

Author: Benny Donewitz

Technical Publication — WIX Native Text Edition

Engine: 1.0.11-poc

Decision semantics: 1.0.11

Specification: Canonical POC Specification V1.5.1 Rev B

Publication baseline: LOCKED

Independent Final Integrity Verification: PASS

A publication-locked deterministic proof of concept for evidence-aware AI decision control, including exact source-code excerpts, execution traces, artifact provenance and independent verification.

00 — DOCUMENT CONTEXT AND INTERPRETATION FRAME

LoopGuard-AI is the applied decision-control architecture published within the RATIUM.AI research framework. This page presents the canonical, publication-locked proof-of-concept implementation of that architecture: LoopGuard-AI V1.0.11, governed by Canonical POC Specification V1.5.1 Rev B.

The purpose of this document is not merely to describe a governance concept. It documents and evidences an executable, replay-verifiable control model that connects structured evaluation inputs to four explicit operational gates: SHIP, RESTRICT, HOLD, and ROLLBACK.

The POC is constructed around a specific governance proposition: evaluation alone does not constitute operational control if detected uncertainty, policy conflict, evidence weakness, authority failure, instability, or rollback pressure has no defined consequence for execution. LoopGuard-AI therefore treats evaluation as an input to deterministic decision control rather than solely as a reporting layer.

Within the broader conceptual framework of RATIUM.AI, the Central Equilibrium Problem (CEP) provides theoretical motivation for examining self-reinforcing and structurally suboptimal decision environments. LoopGuard-AI is the applied governance architecture used here to test a narrower engineering proposition: whether evaluation, evidence quality, policy precedence, human authorization, recovery logic, persistence, and replay can be combined into an auditable deterministic control loop. The POC does not empirically validate CEP itself.

The implementation documented and evidenced here is deliberately deterministic. Evidence classification and evidence quality are treated as independent dimensions. For SHIP eligibility, every required metric must satisfy its own status, confidence, and completeness requirements; unrelated stronger metrics cannot compensate for a deficient required metric. The active PolicyPack's evidence-quality minima are versioned, canonically serialized, included in hash material, persisted, and replay-verifiable.

The publication baseline is frozen under the Canonical Publication Lock. Its verification record includes 225/225 shipped checks, 15/15 independent final integrity probes, and 100/100 randomized schema-valid lifecycle reconstructions. These results establish integrity of the deterministic synthetic POC contract. They do not establish empirical metric validity, empirical CEP validity, production readiness, certification, regulator acceptance, customer validation, real-world safety efficacy, cryptographic trust anchoring, or tamper-proof authentication.

Document class: Canonical Technical Proof of Concept / Evidence & Verification Record

Interpretation boundary: Architecture claims, implementation claims, verification claims, and deployment claims are distinct and must not be conflated.

01 — SYSTEM CLAIM

Evaluation becomes an explicit operational decision.

LoopGuard-AI is a deterministic decision-control POC that connects versioned evaluation signals and policy rules to one of four operational gates.

The central technical requirement is not merely to compute a risk score. It is to preserve an auditable path from source inputs, through metric and policy evaluation, to a terminal gate that can be independently reconstructed from persisted artifacts.

Canonical precedence:

hard blockers → risk elevation → conditional restriction → green path → audited human override

Evidence quality is an affirmative SHIP-eligibility condition, not a new precedence layer.

02 — FOUR OPERATIONAL GATES

SHIP

All green-path policy conditions and evidence-quality requirements are satisfied.

RESTRICT

An existing conditional restriction controls the outcome; operation proceeds only within constrained bounds.

HOLD

A blocker, elevated risk, fail-closed condition or SHIP-quality deficit requires execution to be withheld.

ROLLBACK

A valid rollback determination and authorization contract control the outcome.

Decision flow:

Request + Signals → Metrics + PolicyPack → Gate + Evidence Record

03 — METRIC SURFACE

Ten recommended MVP metrics. The locked architecture preserves non-compensation: a strong unrelated metric cannot offset a required metric that fails its own SHIP eligibility condition.

• risk_level — Operational risk classification

• evidence_status — Semantic sufficiency / limitation / conflict

• authority_status — Requested authority vs. granted authority

• reversibility_status — Ability to reverse the proposed action

• core_instability — Instability in core system/governance behavior

• shell_weakness — Weakness in surrounding controls

• policy_conflict — Conflict with active policy constraints

• drift_status — Divergence from the relevant baseline

• rollback_pressure — Pressure to restore a safer prior state

• cep_stability — CEP-relevant composite stability signal

04 — LOCKED IMPLEMENTATION EXCERPTS

The following seven Python excerpts are copied directly from the locked V1.0.11 source identified by SHA-256 1fa2cf1f0aca8d6bb65a1a2def0c9ecfbcebc193c2289bedf74c9c7436f3913b. They are not pseudo-code and are not rewritten for publication.

Strict persisted JSON reader

Locked source lines 3025–3041

def read_json(path: Path) -> Any: """Ambiguity-safe persisted JSON reader. Rejects duplicate object keys and non-standard NaN/Infinity constants so a verification PASS has one parser-independent JSON interpretation. """ text = Path(path).read_text(encoding='utf-8') try: return json.loads( text, object_pairs_hook=_strict_object_pairs, parse_constant=_reject_json_constant, ) except POCError: raise except (json.JSONDecodeError, TypeError, ValueError) as exc: raise POCError(f'STRICT_JSON_PARSE_FAILURE:{Path(path).name}:{type(exc).__name__}') from exc

Canonical gate resolution

Locked source lines 402–418

def resolve_gate(rules: List[Dict[str, Any]], metrics: Dict[str, Dict[str, Any]], trusted: Dict[str, Any], policy: PolicyPack) -> Tuple[str, str]: triggered = [r for r in rules if r['triggered']] by_id = {r['rule_id']: r for r in triggered} for rid in policy.precedence_rules.get('terminal_blocking_rule_ids', []): if rid in by_id: return ('HOLD', rid) gate_order = policy.precedence_rules.get('gate_order', ['ROLLBACK', 'HOLD', 'RESTRICT', 'SHIP']) for gate in gate_order: matches = [r for r in triggered if r['candidate_gate'] == gate] if matches: matches.sort(key=lambda r: (r['precedence_rank'], r['rule_id'])) if gate == 'SHIP': return ('SHIP', matches[0]['rule_id']) if gate == 'ROLLBACK': return ('ROLLBACK', matches[0]['rule_id']) return (gate, f'{gate}_PRECEDENCE') return (policy.precedence_rules.get('fallback_gate', 'HOLD'), policy.precedence_rules.get('fallback_reason', 'POLICY_COVERAGE_FAILURE'))

EvidenceQualityEvaluation construction

Locked source lines 3106–3204

def build_evidence_quality_evaluation( run_id: str, decision_id: str, metrics: Dict[str, Any], policy: PolicyPack, ) -> Dict[str, Any]: """Build the deterministic V1.5.1 Rev B EvidenceQualityEvaluation.""" _validate_evidence_minimums_v151(policy.evidence_minimums) required_metrics = tuple(policy.required_metrics) minima = copy.deepcopy(policy.evidence_minimums) metric_quality: Dict[str, Any] = {} violations: List[Dict[str, Any]] = [] structural_non_evaluable = False min_conf = float(minima['minimum_metric_confidence']) min_comp = float(minima['minimum_metric_completeness']) for name in required_metrics: metric = metrics.get(name) if isinstance(metrics, dict) else None entry = {'status': None, 'confidence': None, 'completeness': None} if not isinstance(metric, dict): violations.append(_quality_violation('MISSING_REQUIRED_METRIC', name)) structural_non_evaluable = True metric_quality[name] = entry continue entry['status'] = metric.get('status') if metric.get('status') != 'OK': violations.append(_quality_violation('METRIC_STATUS_NOT_OK', name, str(metric.get('status')))) structural_non_evaluable = True conf = metric.get('confidence') comp = metric.get('completeness') if _finite_real_01(conf): entry['confidence'] = float(conf) if float(conf) < min_conf: violations.append(_quality_violation('BELOW_MIN_CONFIDENCE', name)) else: violations.append(_quality_violation('INVALID_CONFIDENCE', name)) structural_non_evaluable = True if _finite_real_01(comp): entry['completeness'] = float(comp) if float(comp) < min_comp: violations.append(_quality_violation('BELOW_MIN_COMPLETENESS', name)) else: violations.append(_quality_violation('INVALID_COMPLETENESS', name)) structural_non_evaluable = True metric_quality[name] = entry evidence_counts = { 'required_evidence_items': None, 'verified_evidence_items': None, 'conflicting_evidence_items': None, } evidence_metric = metrics.get('evidence_status') if isinstance(metrics, dict) else None raw = evidence_metric.get('raw_value') if isinstance(evidence_metric, dict) else None counts_valid = isinstance(raw, dict) and set(raw) == set(evidence_counts) if counts_valid: vals = [raw[k] for k in evidence_counts] counts_valid = all(isinstance(x, int) and not isinstance(x, bool) and x >= 0 for x in vals) if counts_valid: evidence_counts = {k: int(raw[k]) for k in evidence_counts} if minima['required']: if ( evidence_counts['required_evidence_items'] < int(minima['minimum_required_evidence_items']) or evidence_counts['verified_evidence_items'] < evidence_counts['required_evidence_items'] ): violations.append(_quality_violation('INSUFFICIENT_REQUIRED_EVIDENCE', 'evidence_status')) else: # Missing/malformed evidence counts are already non-evaluable if the evidence # metric itself is missing/non-OK; ensure an explicit deterministic violation. if minima['required']: if not any(v['code'] in {'MISSING_REQUIRED_METRIC', 'METRIC_STATUS_NOT_OK'} and v.get('metric') == 'evidence_status' for v in violations): violations.append(_quality_violation('INSUFFICIENT_REQUIRED_EVIDENCE', 'evidence_status', 'COUNTS_UNAVAILABLE')) structural_non_evaluable = True violations.sort(key=lambda v: _quality_violation_sort_key(v, required_metrics)) status = 'NOT_EVALUABLE' if structural_non_evaluable else 'EVALUATED' ship_eligible = status == 'EVALUATED' and not violations reason_code = 'QUALITY_ELIGIBLE' if ship_eligible else (violations[0]['code'] if violations else 'NOT_EVALUABLE') explanation = ( 'All required metrics and evidence counts satisfy the locked V1.5.1 evidence-quality contract.' if ship_eligible else f'Evidence-quality SHIP eligibility failed: {reason_code}.' ) return { 'evaluation_id': f'EQE-{run_id}', 'run_id': run_id, 'decision_id': decision_id, 'status': status, 'policy_pack_id': policy.policy_pack_id, 'policy_pack_version': policy.policy_pack_version, 'policy_pack_hash': policy.policy_pack_hash, 'required_metrics': list(required_metrics), 'configured_minimums': minima, 'metric_quality': metric_quality, 'evidence_counts': evidence_counts, 'violations': violations, 'ship_eligible': bool(ship_eligible), 'reason_code': reason_code, 'deterministic_explanation': explanation, }

Evidence-quality replay verification

Locked source lines 3289–3307

def _validate_evidence_quality_artifact_v107(rd: Path, run_id: str, decision: Dict[str, Any], metrics: Dict[str, Any], policy: PolicyPack, bundle: Dict[str, Any]) -> None: p = rd / EVIDENCE_QUALITY_ARTIFACT if not p.exists(): raise POCError('EVIDENCE_QUALITY_ARTIFACT_MISSING') stored = read_json(p) expected = build_evidence_quality_evaluation(run_id, decision['decision_id'], metrics, policy) if stored != expected: raise POCError('EVIDENCE_QUALITY_ARTIFACT_SEMANTIC_MISMATCH') h = sha256_obj(expected) if decision.get('evidence_quality_evaluation_ref') != EVIDENCE_QUALITY_ARTIFACT: raise POCError('DECISION_EVIDENCE_QUALITY_REF_MISMATCH') if decision.get('evidence_quality_evaluation_hash') != h: raise POCError('DECISION_EVIDENCE_QUALITY_HASH_MISMATCH') if decision.get('evidence_quality_status') != expected['status']: raise POCError('DECISION_EVIDENCE_QUALITY_STATUS_MISMATCH') if decision.get('evidence_quality_ship_eligible') is not expected['ship_eligible']: raise POCError('DECISION_EVIDENCE_QUALITY_ELIGIBILITY_MISMATCH') if bundle.get('evidence_quality_evaluation_ref') != EVIDENCE_QUALITY_ARTIFACT or bundle.get('evidence_quality_evaluation_hash') != h: raise POCError('BUNDLE_EVIDENCE_QUALITY_BINDING_MISMATCH')

Manifest-event lifecycle binding

Locked source lines 5530–5603

def _derive_manifest_event_history_v111(rd: Path) -> List[Dict[str, Any]]: """Bind every post-decision manifest snapshot to exactly one append-only lifecycle event.""" records = _ordered_manifest_records_v111(rd) if not records: raise POCError('MANIFEST_EVENT_HISTORY_MISSING') if records[0][1].name != 'manifest.json': raise POCError('MANIFEST_EVENT_BASE_NAME_INVALID') base_files = records[0][2]['files'] base_events = sorted(name for name in base_files if _is_post_decision_event_artifact_v111(name)) if base_events: raise POCError(f'MANIFEST_BASE_CONTAINS_POST_DECISION_EVENT:{base_events}') events: List[Dict[str, Any]] = [] prev_files = dict(base_files) expected_auth_seq = 1 expected_override_seq = 1 for manifest_seq, mp, man in records[1:]: cur_files = dict(man['files']) removed = sorted(set(prev_files) - set(cur_files)) changed = sorted( name for name in set(prev_files) & set(cur_files) if prev_files[name] != cur_files[name] ) added = sorted(set(cur_files) - set(prev_files)) if removed: raise POCError(f'MANIFEST_EVENT_REMOVAL_FORBIDDEN:{mp.name}:{removed}') if changed: raise POCError(f'MANIFEST_EVENT_REWRITE_FORBIDDEN:{mp.name}:{changed}') if not added: raise POCError(f'MANIFEST_EVENT_DELTA_EMPTY:{mp.name}') expected_auth = f'trusted_override_authorization_{expected_auth_seq:04d}.json' expected_override_set = { f'override_request_{expected_override_seq:04d}.json', f'override_{expected_override_seq:04d}.json', f'override_evidence_{expected_override_seq:04d}.json', } added_set = set(added) if added_set == {expected_auth}: events.append({ 'manifest_sequence': manifest_seq, 'event_type': 'TRUSTED_OVERRIDE_AUTHORIZATION', 'event_sequence': expected_auth_seq, 'event_refs': [expected_auth], }) expected_auth_seq += 1 elif added_set == expected_override_set: events.append({ 'manifest_sequence': manifest_seq, 'event_type': 'OVERRIDE_TRANSACTION', 'event_sequence': expected_override_seq, 'event_refs': sorted(expected_override_set), }) expected_override_seq += 1 else: raise POCError(f'MANIFEST_EVENT_DELTA_INVALID:{mp.name}:{added}') prev_files = cur_files auth_seq = _override_artifact_sequences(rd, 'trusted_override_authorization') override_seq = _override_artifact_sequences(rd, 'override') expected_manifest_count = 1 + len(auth_seq) + len(override_seq) if len(records) != expected_manifest_count: raise POCError( f'MANIFEST_EVENT_CARDINALITY_MISMATCH:manifests={len(records)}:' f'auth={len(auth_seq)}:override={len(override_seq)}:expected={expected_manifest_count}' ) if auth_seq != list(range(1, expected_auth_seq)): raise POCError(f'MANIFEST_AUTH_EVENT_SEQUENCE_MISMATCH:{auth_seq}') if override_seq != list(range(1, expected_override_seq)): raise POCError(f'MANIFEST_OVERRIDE_EVENT_SEQUENCE_MISMATCH:{override_seq}') return events