CRSP / NRC Compile-time Binding • Runtime Binding

Binding: from NRC Compilation to AER Enforcement

“Binding” appears in two places in a CRSP Type-III system. In nrc_compiler.py, binding means turning a declarative NRC into an executable contract. In NRC → AER, binding means attaching that executable contract to a specific interaction so every AER phase is constrained, validated, and auditable.

Compiler binding #nrc_compiler Runtime binding #aer Proof & audit #evidence Implementation checklist #build

Two bindings, one contract

Binding is not identity and not persona. It is normative compilation + installation. First you compile the contract (compiler binding). Then you install it into an AER session (runtime binding).

Non-persona Inferential licensing Defeater enforcement Auditable release

One-sentence doctrine

Compiler binding answers: “What is the contract?” Runtime binding answers: “Which interaction is governed by it?”

If you skip compiler binding, your rules remain informal. If you skip runtime binding, your rules remain unenforced.

Binding in nrc_compiler.py

Compile-time binding: declarative → executable

Definition

Compile-time binding is the act of converting an NRC specification (YAML/JSON) into a normalized, version-pinned, enforcement-ready object. This object is what your AER orchestrator and entitlement engine can execute deterministically.

What the compiler binds

References → definitions (e.g., defeater profile names → concrete rule refs)
Synonyms → canonical schema (e.g., “CASRC” → structured accountability anchor)
Policy “latest” → pinned versions (hashes to prevent silent drift)
Constraints → validators (required sections + forbidden content rules)

Compiled NRC (example output)

{ "nrc_id": "NRC.SUTTER.TYPEIII.RETEAM.RISK_SCORE.AUTHORITY", "nrc_version": "sha256:…", "type_posture": "TYPE_III", "inferential_scope_constraint": { "allowed_moves": [ "identify_failure_modes", "define_defeater_triggers", "propose_mitigations", "specify_audit_requirements" ], "forbidden_moves": [ "clinical_advice", "treatment_protocols", "dosing", "patient_specific_guidance" ] }, "epistemic_posture_declaration": "second_order_risk_reasoning", "accountability_anchor": { "id": "CASRC", "display_name": "Clinical AI Safety Review Committee", "routing_queue": "queue.casrc.review" }, "defeater_activation_profile": [ { "id": "D_AI_AS_AUTHORITY", "rule_ref": "defeaters/ai_as_authority.v1" }, { "id": "D_HIGH_STAKES_GUIDANCE", "rule_ref": "defeaters/clinical_guidance.v3" } ], "required_checks": [ "audit_fields", "monitoring_plan", "review_cadence", "defeater_scan_summary" ], "validators": [ "forbidden_content_scan.v2", "required_sections_schema.v1", "authority_leakage_scan.v1" ] }

NRC binds to AER

Runtime binding: contract → interaction

Definition

Runtime binding happens when an AER session is created for a user request and the compiled NRC is attached to that session. After binding, every AER phase must obey the contract and every release is conditional.

What binding installs into the session

Inferential Scope Constraint: allowed/forbidden moves enforced across phases
Epistemic Posture Declaration: what kind of claims are permitted (e.g., second-order risk)
Accountability Anchor: who the output answers to (e.g., CASRC)
Defeater Activation Profile: which failure conditions are preloaded and must be surfaced

AER session state (binding target)

AERSession { session_id, request_id, // runtime binding outputs nrc_id, compiled_nrc, artifact_manifest_hash, accountability_anchor, // phase results ask_result, evidence_result, propose_result, entitlement_result, release_result, // audit trail audit_events[] }

Binding is the moment the request becomes an institution-governed transaction, not free-form prompting.

How binding constrains each AER phase

Contract enforcement is phase-specific

AER phase	What must happen	How binding enforces it
ASK	Normalize the request into a governed task spec	Requires explicit scope + non-scope; binds audience and posture
EVIDENCE	Declare assumptions + uncertainties; cite artifacts	Requires evidence/uncertainty fields if NRC says so
PROPOSE	Draft the institutional artifact (provisional)	Allows only licensed moves; forbids clinical directives
ENTITLE	Run validators + defeaters; decide pass/fail	Executes required checks + defeater activation profile deterministically
RELEASE	Publish only if entitled; attach audit metadata	Blocks output on any defeater hit; writes audit events

Why binding proves “institutional artifact”

Observable, auditable, reproducible

Binding is evidence, not rhetoric

When you can show the NRC ID + version, artifact manifest hashes, validator versions, defeater outcomes, and the release decision, you can prove the output is not a “chatbot answer.” It is a governed institutional artifact produced under contract.

Binding event (recommended audit record)

AER_BIND { session_id, request_id, nrc_id, nrc_version, accountability_anchor: "CASRC", required_checks: [...], defeater_profile: [...], artifact_manifest_hash, policy_bundle_hash }

What “CASRC-governed” looks like in logs

Audience anchored to CASRC
Required sections present (audit/monitoring/cadence)
Defeaters preloaded (AI-as-authority, clinical guidance)
Release is conditional on ENTITLE

AER_ENTITLE_DECISION { pass: true, defeaters_hit: [], missing_checks: [], validators: ["..."], decision: "ENTITLED_FOR_RELEASE" }

Implementation checklist

What to build to make binding real

Compiler binding

Validate NRC against schema (CI gate)
Resolve defeater/profile references to concrete rules
Canonicalize audience/accountability anchor objects
Pin versions/hashes for reproducibility
Emit validators + required checks as executable config

Runtime binding

Create AER session and attach compiled NRC
Bind explicit artifact manifest (hashes)
Enforce phase-specific constraints (ASK/EVIDENCE/PROPOSE)
Run deterministic ENTITLE validators + defeaters
Release only on pass; log every event and decision

Non-persona vocabulary recap

If you want to avoid “identity” entirely, treat binding as installing the four non-persona functions into the session:

Inferential Scope Constraint Epistemic Posture Declaration Accountability Anchor Defeater Activation Profile Together: the NRC. Binding: compiling + installing this NRC into AER.