SRIC: external semantic admission

SRIC Block 24: External Latent-Reasoner Causal-Semantic Admission

Release: v0.3.2
Frozen scientific protocol: v0.3.0
Canonical status: INFRASTRUCTURE_VALIDATED_EXTERNAL_EXECUTION_PENDING
Author: Komorebi P.

This package is the first source-locked SRIC implementation intended to audit a third-party latent-reasoning checkpoint. It targets the public multimode GPT-2 Coconut checkpoint trained on PrOntoQA and turns the synthetic Block 16-23 methodology into a fail-closed external-model protocol.

The package does not contain the external repository, checkpoint, GPT-2 weights, or public dataset. It does not report a result for the real checkpoint. The actual checkpoint has not been executed in this build environment.

What the package asks

The primary causal audit asks whether the model's recurrent latent trace is:

1. replayable through a source-faithful adapter;
2. useful for the protected answer;
3. temporally ordered;
4. structurally meaningful beyond vector norm or covariance;
5. stable under semantic-preserving surface changes;
6. specific to the current proof instance beyond final-answer identity.

Only a model passing the causal admission gates may enter semantic escalation. The semantic compiler then searches for a low-rank quotient that predicts later latent states, answer-residual future state, anonymous intervention effects, and the final answer while remaining stable across semantic twins. Gold proof steps and explicit-CoT mode are withheld until after the quotient is sealed.

Primary claim tier

The PrOntoQA primary tier is explicitly labeled content-specific, not algorithmically procedure-specific. The public test family is dominated by fixed-form unary chains. A same-answer, different-proof transplant can show that traces are tied to task or proof-instance content, but it cannot by itself establish that the model represents different reasoning algorithms.

A stronger structure-sensitive follow-up is specified for ProsQA in PROSQA_FOLLOWUP_PROTOCOL.md.

Sealed chronology

verify source commit and Git blobs
        -> hash checkpoint and local GPT-2 snapshot
        -> choose deterministic task population
        -> reserve group-disjoint covariance calibration support
        -> freeze causal audit support and donor plans
        -> freeze semantic discovery/calibration/final partitions
        -> write pre-audit seal
        -> estimate covariance on calibration support only
        -> run causal audit on disjoint audit support
        -> if CONTENT_SPECIFIC, collect semantic discovery support
        -> collect semantic calibration support
        -> select and seal quotient
        -> only then collect semantic final twins/counterfactuals
        -> reveal proof-instance and explicit-CoT witnesses
        -> run causal subspace patching
        -> write result receipt

External-runtime and terminal-summary hardening in v0.3.2

Version 0.3.2 is an infrastructure-only patch. It does not alter the v0.3.0 scientific gates, task profiles, donor rules, semantic chronology, or claim boundary. It adds:

• automatic discovery of an installed Python 3.10, 3.11, or 3.12 runtime;
• a revision-pinned asset downloader for the exact checkpoint_37 file;
• a minimal allowlist for the GPT-2 base-model snapshot instead of downloading every framework variant;
• automatic retry through the standard HTTP/LFS path if the local Hugging Face Xet transfer fails;
• -DisableXet and -LocalFilesOnly setup modes;
• an asset receipt recording complete checkpoint SHA-256, size, minimal base-model tree SHA-256, revisions, and transfer mode;
• tests that reject unpinned or overbroad asset plans.

The external checkpoint remains unexecuted in the release environment. Asset-transfer failure is classified as infrastructure failure and cannot be interpreted as evidence about the model.

Scientific safeguards frozen in v0.3.0

• Exact external repository commit and required Git blobs are verified.
• Hugging Face checkpoint and base-model revisions are pinned by setup commands.
• The complete checkpoint file and local base-model tree are hashed into the seal.
• Covariance-matched noise is calibrated on a group-disjoint support, not the causal audit rows.
• The semantic final support is not captured before quotient selection and sealing.
• Gold explicit-CoT is reserved for post-seal comparison and cannot aid quotient construction.
• PrOntoQA's maximum specificity claim is narrowed to content/proof-instance specificity.
• A separate source-faithful recurrence parity test compares the adapter engine against the reviewed upstream recurrence.
• The engineered fixture is staged before execution and is always marked as a non-real positive control.

Status taxonomy

Engineered validation result

The included fixture is deliberately constructed to contain a causal semantic packet. It is a mechanical positive control, not evidence about Coconut.

• Frozen fixture seal: 68b04ea973f5030a7085d2b1891e87bedbf058db007d004fefee047beaee70b9
• Fixture result receipt: 924157159d14b8d3715f2f886c2ad294b55f5cac15a3b63f1552df1b3731e620
• Causal status: CONTENT_SPECIFIC
• Semantic status: CAUSALLY_VALIDATED
• Selected quotient: joint, rank 3
• Audit rows: 40
• Covariance calibration rows: 8
• Explicit-CoT used during construction: false
• Final semantic support captured before quotient seal: false

Windows execution

1. Validate the package without external weights

$ErrorActionPreference='Stop'; Expand-Archive .\SRIC_Block24_External_LRM_Causal_Semantic_Admission_v0.3.2.zip .\SRIC_Block24 -Force; Set-Location .\SRIC_Block24\SRIC_Block24_External_LRM_Causal_Semantic_Admission_v0.3.2; .\Run_Fake_Validation.ps1

2. Create the pinned external runtime

.\Setup_External_PrOntoQA_Coconut.ps1

Useful fail-closed alternatives:

# Force the standard HTTP/LFS path instead of Xet
.\Setup_External_PrOntoQA_Coconut.ps1 -DisableXet

# Verify and stage assets already present in the local Hugging Face cache
.\Setup_External_PrOntoQA_Coconut.ps1 -LocalFilesOnly

# CPU-only setup for adapter debugging; not the recommended final audit path
.\Setup_External_PrOntoQA_Coconut.ps1 -CpuOnly

The setup script creates an isolated Python 3.10-3.12 environment, checks out the pinned upstream commit, downloads the exact checkpoint plus only the required GPT-2 files, verifies the source blobs, hashes the complete local assets, and writes external_runtime\runtime_paths.json. If Xet transfer is unavailable, it retries through the standard HTTP/LFS path.

3. Run a 12-task smoke audit

.\Run_Real_LRM_Pilot.ps1 -Profile smoke -Device cuda

4. Run the primary 64-task audit

.\Run_Real_LRM_Pilot.ps1 -Profile primary -Device cuda

5. Run the 256-task audit only after reviewing the primary receipt

.\Run_Real_LRM_Pilot.ps1 -Profile full -Device cuda

The default scientific order is smoke -> primary -> full. Do not alter thresholds after viewing a final result. A failure is a valid terminal result.

Important boundary

This package validates infrastructure and an engineered positive control. It does not establish that the external Coconut checkpoint uses its latent states, represents proof-instance content, exposes a discoverable semantic quotient, or supports causal semantic editing. Those questions remain open until the source-locked checkpoint is run.

See:

• BLOCK24_PROTOCOL.md
• BRAINSTORM_AND_DESIGN_DECISIONS.md
• CLAIM_BOUNDARY.md
• REAL_EXECUTION_STATUS.md
• REAL_RUN_CHECKLIST.md
• PROSQA_FOLLOWUP_PROTOCOL.md

Terminal-summary fix in v0.3.2

The 12-task smoke profile intentionally disables covariance-matched noise. Its result therefore records causal_calibration: null. Earlier summarization code incorrectly assumed this optional field was always an object and could raise an AttributeError after the result itself had already been written and verified. Version 0.3.2 handles this terminal path explicitly. The scientific result JSON and all frozen causal gates are unchanged.