Initial release: SRT-Adapter v8a (peer-review distribution)

.gitattributes

@@ -1,35 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.jsonl filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of tracking or improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 James Burton Lancaster
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,298 @@
+---
+license: apache-2.0
+base_model: Qwen/Qwen2.5-7B
+tags:
+  - adapter
+  - semiotics
+  - bifurcation-detection
+  - metapragmatics
+  - frozen-backbone
+  - pytorch
+  - custom_code
+language:
+  - en
+library_name: pytorch
+pipeline_tag: feature-extraction
+inference: false
+---
+
+# SRT-Adapter v8a: Peer-Review Release
+
+A peer-review distribution of the **Semiotic-Reflexive Transformer Adapter (SRT-Adapter)**, v8a generation, trained on top of a frozen `Qwen/Qwen2.5-7B`. Includes the trained weights, an inference-only loader, evaluation data, benchmark artifacts, and the paper.
+
+> **Custom-code model.** This is not an `AutoModel`-loadable checkpoint. `AutoModel.from_pretrained(...)` will not work. Clone or download this repository and load the weights through the bundled `SRTAdapter` class. See [How to get started with the model](#how-to-get-started-with-the-model).
+
+> **Training and research source code is held back during patent and publication review.** This package ships the architecture as **inference-only Python**, sufficient to load the weights and read out all four semiotic channels. Training pipelines, loss code, dataset construction, and the wider SRT framework are not included.
+
+---
+
+## Model details
+
+| | |
+|---|---|
+| **Developed by** | James Burton Lancaster |
+| **Model type** | Adapter (parameter-efficient side network) on a frozen causal language model |
+| **Backbone** | `Qwen/Qwen2.5-7B` (7.6B params, frozen, bf16) |
+| **Trainable parameters** | ~14.5M (0.19% of backbone) |
+| **Language** | English |
+| **License** | Apache-2.0 (adapter weights, code, and config) |
+
+The SRT-Adapter bolts **semiotic awareness** onto a frozen 7B language model. It does not modify a single backbone parameter and does not degrade language modeling quality. It exposes four new readouts at every token position:
+
+- a continuous 64-D **community vector** (which discourse community is speaking)
+- per-layer **divergence vectors** (where meaning forks across communities)
+- a continuous **reflexivity estimate** $\hat{r}$ (how contested is this token)
+- a binary **regime classification** (subcritical / supercritical)
+
+The v8a generation is the headline result of the paper: removing the discrete prototype basis used in v3–v7 leaves cross-entropy unchanged while substantially improving every encoder-geometry metric.
+
+---
+
+## Evaluation
+
+All measured on `Qwen/Qwen2.5-7B`, with no backbone parameters touched.
+
+| Metric | Unadapted Qwen | SRT-Adapter v8a |
+|---|---|---|
+| Validation cross-entropy (nats) | 2.71 | **2.63** |
+| Reddit community recall@1 (35-class) | 0.029 (chance) | **0.484** (16.7× chance) |
+| Archetype recall@1 (33-class, OOD) | 0.030 (chance) | **0.230** (7.6× chance) |
+| Within/between cosine ratio | n/a | **2.016** (vs 1.006 prior) |
+| Trajectory anisotropy expansion | n/a | **~325×** vs prototype baseline |
+| Regime AUROC | n/a | **0.99** (ECE ≈ 0.001 on 351K tokens) |
+| TruthfulQA hallucination AUROC (zero-shot) | n/a | **0.573** (no TruthfulQA in training) |
+| Counterfactual community decoding | n/a | 0.00 disagreement (factual) / **0.95** (contested) |
+
+Full reporting and version history (v3 → v8b): paper §5 and Appendix A.
+
+---
+
+## Lineage and validation history
+
+This adapter is the production-scaling stage of a multi-year research program on computational semiotics. The architectural commitments and training objectives were validated in two prior stages on different backbones and datasets before this release. Treat the v8a numbers below as the latest checkpoint in a longer arc, not as a fresh proposal.
+
+- **Stage 1 (synthetic validation, 2026-03).** Four core architectural claims (subspace specialization, community differentiation, divergence tracking, bifurcation detection) were tested on synthetic data with planted divergence signals. All four passed: linear-probe margin $\geq 0.15$ on each Peircean subspace, $3.28\times$ contested-vs-neutral cosine ratio, Spearman $\rho = 0.822$ on divergence tracking, 100% regime classification with $\Delta \hat{r} = 0.659$. Full record: [`VALIDATION_HISTORY.md`](VALIDATION_HISTORY.md), Stage 1.
+- **Stage 2 (natural-language validation, 2026-03).** The full five-test suite was re-run on the Supabase semiotic news corpus (19K articles, 5 political communities, 141K Peircean sign annotations). All five tests passed at required thresholds: silhouette $1.45\times$, $2.29\times$ contested-vs-neutral divergence norm ratio, Pearson $r = 0.884$ correlation between $\hat{r}$ and external polarization, $1.31\times$ cross-topic transfer ratio, and 85% regime classification accuracy on held-out curated passages. Full record: [`VALIDATION_HISTORY.md`](VALIDATION_HISTORY.md), Stage 2.
+- **Stage 3 Phase 1 (frozen-backbone integration on TinyLlama-1.1B, 2026-03 to 2026-04).** 105 training rounds (R21 through R105) on a frozen TinyLlama-1.1B backbone established that the semiotic modules transfer to production backbones. Community detection silhouette improved to $6.93\times$; $\hat{r}$ correlation with external polarization remained robust at 0.66; curated-passage regime classification reached 85%. Two tests plateaued on the sparse 2-community Supabase data (MAH divergence ratio at $1.05$ to $1.10\times$ vs. required $2.0\times$; cross-topic transfer at $1.03$ to $1.04\times$ vs. required $1.3\times$). The plateau triggered a data-first pivot to a denser corpus and a backbone capable of supporting it.
+- **Stage 3 Scalable Implementation (this release, 2026-04).** v5 through v8a port the validated architecture onto Qwen 2.5-7B and the Reddit Discourse Corpus (35 communities, 1M training samples). v8a is the current best checkpoint. The headline gain is not the discovery of bifurcation detection (already established in Stages 1 and 2) but the demonstration that the framework scales to a 7B frozen backbone at 0.19% parameter overhead, with $\sim 325\times$ trajectory-anisotropy expansion and Reddit recall@1 at $16.7\times$ chance.
+
+For the program-level theoretical foundation see Lancaster (2025), "The Treachery of Signs," SSRN [5987495](https://papers.ssrn.com/abstract=5987495). For the full prior architecture specification and Stage 1 + Stage 2 results see Lancaster (2026a), SSRN [6349978](https://papers.ssrn.com/abstract=6349978). The present paper reports Stage 3 Phase 1 plus the v5 through v8a Stage 3 Scalable progression.
+
+---
+
+## Versions and roadmap
+
+- **v8a (this release).** Headline result. Removing the discrete prototype basis used in v3 through v7 leaves cross-entropy unchanged while substantially improving every encoder-geometry metric. All paper §5 numbers are measured on this checkpoint.
+- **v8b.** A falsification run included in the paper. Pushing the supervised-contrastive objective harder partially undoes v8a's gains. Documented as a negative result.
+- **v9 (in training).** An experimental generation that adds a target-norm penalty on the inject-back arm to attack the central open problem from §6.3 (the inject-back arm carries no measurable signal). Will be released as a follow-up revision on this repo *only if* it improves on v8a across multiple metrics. Otherwise it will be documented as an additional ablation in a future paper revision and v8a will remain canonical.
+
+If you are reviewing the paper, use v8a. The model card will be updated with a `revision` tag if v9 ships as an upgrade.
+
+---
+
+## Package contents
+
+```
+srt-adapter-v8a/
+├── README.md                   ← you are here
+├── LICENSE                     ← Apache-2.0
+├── paper.pdf                   ← preprint with full architecture spec (§3 + Appendix A)
+├── VALIDATION_HISTORY.md       ← Stage 1 + Stage 2 + Stage 3 Phase 1 evidence summary
+├── config.json                 ← v8a hyperparameters and module dimensions
+├── adapter.safetensors         ← v8a weights (~28 MB, safetensors, preferred)
+├── adapter.pt                  ← v8a weights (~28 MB, PyTorch state-dict, legacy)
+├── requirements.txt            ← torch + transformers + numpy + safetensors
+├── src/
+│   └── srt/                    ← inference-only model code
+│       ├── config.py           ← config dataclasses
+│       ├── adapter.py          ← SRTAdapter (frozen-backbone wrapper)
+│       └── modules/            ← CDH, MAH, RRM, BEN
+├── examples/
+│   ├── README.md
+│   └── load_and_score.py       ← end-to-end demo, prints all 4 readouts
+├── data/
+│   ├── DATA.md                 ← schema + reproduction instructions for the full corpus
+│   ├── NOTICE                  ← copyright notice for bundled Reddit comments
+│   ├── val_200.jsonl           ← 200 held-out samples with per-token r_true labels
+│   └── archetypes.json         ← 33-class out-of-distribution archetype probe
+└── benchmarks/
+    ├── curated_metrics.json    ← reference metrics from paper §5
+    └── curated_traces.json     ← per-token trace dumps used in plots
+```
+
+> **Note on `benchmarks/curated_metrics.json`.** This file reports v8a numbers on a 100-passage curated probe (regime accuracy, per-layer divergence norms, community-protocol activations). The near-zero $\hat{r}$ vs $r_{\text{true}}$ Pearson on this slice is expected and is discussed in paper §5.7 ($\hat{r}$ tracks information density as much as contestedness on short curated passages). The headline Pearson and recall numbers in the Evaluation table above come from the full Reddit validation split, not this curated probe.
+
+### What's NOT in this package
+
+- **Training pipelines, loss functions, and the dataset construction code.** Held back during patent and publication review.
+- **The wider SRT research framework** (annotation pipeline, ablation harness, sweep tooling, instrumentation scripts).
+- **The full 1M-sample training corpus.** Reddit's redistribution terms preclude bundling it; see [`data/DATA.md`](data/DATA.md) for schema and reproduction.
+- **The Qwen 2.5-7B backbone weights.** Pulled from HuggingFace under the [Tongyi Qianwen License](https://huggingface.co/Qwen/Qwen2.5-7B/blob/main/LICENSE).
+
+---
+
+## How to get started with the model
+
+```bash
+# 1. set up a venv (Python ≥ 3.10) and install deps
+pip install -r requirements.txt
+
+# 2. score a passage end-to-end
+cd examples
+python load_and_score.py --text "Vaccine mandates are an obvious public health win."
+```
+
+First run downloads `Qwen/Qwen2.5-7B` (~15 GB) from HuggingFace. The example loads `adapter.safetensors` by default and falls back to `adapter.pt` if the safetensors file is absent.
+
+For a programmatic-use snippet, see [`examples/README.md`](examples/README.md).
+
+---
+
+## Uses
+
+The adapter is most useful as a **diagnostic instrument** for what a frozen language model already encodes about discourse structure. Some concrete patterns:
+
+### 1. Per-token contestedness scoring
+
+Use BEN's regime logits to flag which token positions in a passage sit in a contested-meaning regime. Useful for:
+
+- highlighting ideologically loaded spans in user-generated text
+- routing inputs to human review when supercritical regime probability exceeds a threshold
+- annotating debate transcripts, news comment threads, or policy documents with per-token tension scores
+
+### 2. Unsupervised discourse-community clustering
+
+The 64-D community vector from CDH supports nearest-neighbor retrieval and clustering without ever needing community labels at inference. Useful for:
+
+- segmenting a corpus by latent discourse community (recall@1 = 16.7× chance on 35 known communities)
+- retrieving thematically aligned passages for downstream modeling
+- detecting coordinated-inauthentic-behavior signatures via tight community clustering of supposedly independent accounts
+
+### 3. Counterfactual community-conditioned decoding
+
+By steering the community vector at decode time, you can ask "how would *this* community complete this sentence?" Useful for:
+
+- cross-community simulation studies (the paper measures 0.95 mean disagreement on contested prompts vs 0.00 on factual ones)
+- synthetic-disagreement generation for training argument-mining or stance-detection systems
+- audit / red-team probes that surface latent assumptions across reader communities
+
+### 4. Hallucination signal for retrieval and generation
+
+$\hat{r}$ correlates with epistemic instability and gives a usable zero-shot AUROC of 0.573 on TruthfulQA. Useful as:
+
+- a feature in hallucination classifiers (alongside other signals)
+- a per-token routing signal for retrieval-augmented generation: high $\hat{r}$ tokens warrant a retrieval round
+- a calibration probe in evaluation pipelines
+
+### 5. Feature extraction for downstream classifiers
+
+The MAH divergence vectors (3 × 256-D per token) are usable as semiotic features in any downstream classifier without retraining the backbone or the adapter. Useful for:
+
+- stance and frame classification on small labeled sets
+- author / community attribution
+- topical drift detection across long documents
+
+### 6. Reviewer probes against the paper's claims
+
+`data/val_200.jsonl` ships with per-token `r_true` labels. Reviewers can validate claims about $\hat{r}$ correlation, regime accuracy, and divergence norms against the bundled `benchmarks/curated_metrics.json` without rerunning training.
+
+### Out-of-scope uses
+
+- **Treating $\hat{r}$ as a calibrated truth score.** It correlates with information density as much as contestedness; see paper §5.7.
+- **Expecting the inject-back arm to noticeably change generation.** The observation half is well-formed; the intervention half does not yet carry signal. See paper §6.3 and §6.5.
+- **Safety-critical decisions without independent validation.** The adapter is a research instrument, not a deployed safety system.
+- **Generation models.** The adapter does not improve text generation quality; it adds structured side-channel readouts.
+
+---
+
+## Training details
+
+### Training data
+
+- **Corpus:** ~1M Reddit comments × 35 discourse communities, with per-token reflexivity labels and chain-of-interpretants annotations.
+- The full corpus is **not redistributed**; see [`data/DATA.md`](data/DATA.md) for schema and reproduction.
+- A 200-sample held-out evaluation subset is bundled in [`data/val_200.jsonl`](data/val_200.jsonl) under the terms in [`data/NOTICE`](data/NOTICE).
+
+### Training procedure
+
+- Optimizer: AdamW, learning rate 3e-4, batch 16, max sequence length 512.
+- Schedule: 3 epochs over 1M samples, early-stopped at ~10K steps based on validation cross-entropy.
+- Backbone: frozen, bf16. No backbone parameter is updated.
+- Hardware: single NVIDIA A6000 (48 GB).
+
+---
+
+## Architecture summary
+
+| Module | Reads | Outputs | Paper section |
+|---|---|---|---|
+| **Community Discovery Head** (CDH) | layer 4 hidden states, mean-pooled | continuous 64-D community vector (no prototype basis under v8a) | §3.2 |
+| **Metapragmatic Attention Heads** (MAH) | layers 7, 14, 21 | per-token divergence vectors (256-D × 3 layers) | §3.3 |
+| **Reflexive Recurrent Module** (RRM) | accumulated divergence | 512-D GRU meta-state; FiLM injections back into layers 14, 21 | §3.4 |
+| **Bifurcation Estimation Network** (BEN) | meta-state | per-token $\hat{r}$ + 2-way regime logits | §3.5 |
+
+Full module specifications and loss decomposition: paper §3, §4, and Appendix A.
+
+---
+
+## Bias, risks, and limitations
+
+The paper publishes its failures in full. In short:
+
+1. **The inject-back arm currently carries no measurable signal.** Ablating it changes nothing on validation. Central open problem; v9 targets this.
+2. **$\hat{r}$ tracks information density as much as contestedness.** Useful signal, not a clean reading of "is this token contested."
+3. **The 33 archetypes collapse to ~4 functional clusters.** Read as a finding (the geometry resists fine-grained quantization), not a classification bug.
+4. **v8b is a falsification.** Pushing the supervised-contrastive objective harder partially undoes v8a's gains.
+5. **Backbone dependence.** Only validated on Qwen 2.5-7B. Module dimensions are tied to the backbone's hidden size (3584).
+6. **Training corpus bias.** Reddit comments skew English, US-centric, and over-represent argumentative and politically charged communities. The community vector geometry inherits those biases. Treat community recall and counterfactual-decoding numbers as descriptive, not normative.
+
+---
+
+## Citation
+
+```bibtex
+@article{lancaster2026srtadapter,
+  title   = {Semiotic Taps: Lightweight Adapter Modules for Bifurcation
+             Detection in Frozen Language Models},
+  author  = {Lancaster, James Burton},
+  year    = {2026},
+  note    = {Preprint, peer-review distribution}
+}
+
+@article{lancaster2026srtpreprint,
+  title   = {Semiotic-Reflexive Language Model Training: Bridging
+             Interpretive Bifurcations through Metapragmatic Chain
+             Architectures and Embodied Grounding},
+  author  = {Lancaster, James Burton},
+  year    = {2026},
+  journal = {SSRN},
+  url     = {https://papers.ssrn.com/abstract=6349978}
+}
+
+@article{lancaster2025treachery,
+  title   = {The Treachery of Signs: Semiotic Mediation, Pitchfork
+             Bifurcation, and Political Polarization in Algorithmically
+             Curated Societies},
+  author  = {Lancaster, James Burton},
+  year    = {2025},
+  journal = {SSRN},
+  url     = {https://papers.ssrn.com/abstract=5987495}
+}
+```
+
+Full reference list (Peirce, Wildgen, Anderson, Silverstein, Kockelman, Evans, von Foerster, Maturana & Varela, Leighton, VanSaders, Bennett, Landauer, Parrondo, and others) in [`paper.pdf`](paper.pdf).
+
+---
+
+## License
+
+- **Adapter weights, inference code, config, benchmark artifacts, archetype data, and this package:** Apache-2.0 ([`LICENSE`](LICENSE)).
+- **Validation samples in `data/val_200.jsonl`:** included for research reproduction; comments remain the intellectual property of their original Reddit authors. See [`data/NOTICE`](data/NOTICE).
+- **Training pipelines, dataset construction, and the wider SRT framework:** held back during patent and publication review. Not included.
+- **Qwen 2.5-7B backbone:** governed separately by the [Tongyi Qianwen License](https://huggingface.co/Qwen/Qwen2.5-7B/blob/main/LICENSE).
+
+---
+
+## Contact
+
+For training-code access, reproduction questions, or follow-up: see paper PDF for current author contact details.

SHA256SUMS

@@ -0,0 +1,26 @@
+80337123382f5786be2f87326388ba6cee2ebb7be1afc2c012df7e68aa753e8b  ./.gitattributes
+161a873e893d3af606c92866401b329204b127585008ec1894ff9a0f618d86f2  ./LICENSE
+e1638fc045b16eea6074670198ee7d05c07b7bb53ecc59926c5758ec22ed28a4  ./README.md
+777c77fe0d4bdc0361fa907b313233eea513f20bb87b69135e128d5a2e9a3f5b  ./SHA256SUMS
+025681e1f01fb754ae7f1ddbe87246dadd2b55d2ff62039ba73051428f12e5d5  ./VALIDATION_HISTORY.md
+5d201ed58c770d6c8f0fb894e4931fe5923efba455ac4994c7a97f01d13aa05c  ./adapter.pt
+635d4dc76c3c21743ce92988aa107d9fe36ed0b2db53a7eb73b258608741204e  ./adapter.safetensors
+855a5f1a9f5478811d6a8deeb276d4eae4e0211d28041d053bbea3a50afa3c7e  ./benchmarks/curated_metrics.json
+500d9c7b9c9deb0a76482a80dd7d6a8c8b1e648a75f6d5a6732c384baa543d54  ./benchmarks/curated_traces.json
+a83afa4f3524ce4c81f359e197c1ed30bca2753e09b7deea82145b36fc103cc6  ./config.json
+c83c36c374202585c14dc437a2e8ad5b21dbbfbecc7ebd68a80fc3c1494e3d72  ./data/DATA.md
+7d12f72f5cf6e4a451d4dca06c82b5d37c0456e4d577cb63af7ef6c35efadda2  ./data/NOTICE
+e4c8cc4b329bf0b6d9b2070dc386c04b730232fa8c6b310a818ec09d38b1b2e1  ./data/archetypes.json
+e2772cba759bd8fa1a7a5c83f2913141bcd3c88ebdbcfc1069dad5d81366df23  ./data/val_200.jsonl
+6edfa5b72f1b3e799ed37eb881d620f92217423f3262b9c19ff4d356e8047b13  ./examples/README.md
+9a8ea6f13b1cf905a07c3f9707233a5cec7d4c13a6c2ccb3f3dd12c071371653  ./examples/load_and_score.py
+58dac62a9ac6b0cc4ae35bf3d8297f75a43b7ab1f1e55be8c71c9ff76474cf87  ./paper.pdf
+0ad957410e78eaaeb6b0369e52bf14aa5026bb02aaa4546a09b35d0e52a71c8d  ./requirements.txt
+133e1537baa6e11a0df942755498da8b1d48a3aab736db0b8206fc2db6393454  ./src/srt/__init__.py
+b77e7e1320ac02590234953ff0c8a893b645208b43fa1d2c4942da5eeba96a8b  ./src/srt/adapter.py
+64007a7c8f9a77ea3e91d543a15fd13b7f05e3c781f405e30e2eaa018fd3ec4e  ./src/srt/config.py
+8e2291d2b5e05282994fbac8ab4a9462054ff864a741e4d35a15bcc3961bae54  ./src/srt/modules/__init__.py
+94d88e7e10222dcb103d7d8baad41a68a23e596f458b24bfc9ed5215500891ce  ./src/srt/modules/ben.py
+e686f499b0776e0354df5d8de0698d081ee194c580ac7d162b58f20136be8d08  ./src/srt/modules/community.py
+50075c7850603d459f876f14135d24cf3bf491adf5553d4cf918416ac3c245c2  ./src/srt/modules/mah.py
+c4e74600fd8a78f77f691db13b71ab751fd52d2fae4ecb7bdf4c1e6e95cb8f39  ./src/srt/modules/rrm.py

VALIDATION_HISTORY.md

@@ -0,0 +1,198 @@
+# Validation history of the SRT program
+
+This document distills the validation evidence behind the SRT adapter (v8a)
+into a single self-contained record. It covers the three validation stages
+that established the architectural claims this adapter inherits:
+
+- **Stage 1**. Synthetic controlled experiments (4/4 tests passed).
+- **Stage 2**. Natural-language validation on a real news corpus (5/5
+  tests passed).
+- **Stage 3 Phase 1**. Hybrid model on a frozen pretrained backbone
+  (4/5 tests passed at the first gate evaluation; the regime-classification
+  test motivated the remediation campaign that produced the lightweight
+  adapter program reported in `paper.pdf`).
+
+For the canonical theoretical record, see Lancaster (2025), "The Treachery
+of Signs," SSRN [5987495](https://papers.ssrn.com/abstract=5987495), and
+Lancaster (2026a), "Semiotic-Reflexive Language Model Training," SSRN
+[6349978](https://papers.ssrn.com/abstract=6349978). The numbers below
+appear in those papers in their full original context; this file is the
+concise summary referenced from the model card.
+
+---
+
+## Stage 1: Synthetic controlled experiments
+
+**Gate G1: PASSED (4/4).** Each test isolates one architectural claim on
+synthetic data with planted ground-truth signals.
+
+### 1.1 Subspace specialization (linear probing)
+
+| Task | Target subspace | Target acc | Control acc | Margin | Threshold |
+|---|---|---|---|---|---|
+| Token identity | Representamen | 99.31% | 1.31% | 0.980 | $\geq 0.15$ |
+| Community membership | Interpretant | 100.00% | 64.42% | 0.356 | $\geq 0.15$ |
+| Attractor basin | Attractor | 100.00% | 84.52% | 0.155 | $\geq 0.15$ |
+| Position in sequence | Object | 43.22% | 12.99% | 0.302 | $\geq 0.15$ |
+
+The four Peircean subspaces encode qualitatively different information.
+
+### 1.2 Community differentiation
+
+| Metric | Value |
+|---|---|
+| Mean cosine distance, contested signs (20 words) | 0.3622 |
+| Mean cosine distance, neutral signs (79 words) | 0.1103 |
+| Ratio | $3.28\times$ (threshold $\geq 3.0\times$) |
+
+### 1.3 Divergence tracking
+
+| Metric | Value |
+|---|---|
+| Spearman $\rho$ between $\hat{r}$ and $r_{\text{true}}$ | 0.8220 ($p \approx 0$) |
+| Samples | 64,000 |
+| Threshold | $\rho \geq 0.6$ |
+
+### 1.4 Bifurcation detection
+
+| Metric | Value |
+|---|---|
+| Mean $\hat{r}$ difference, post minus pre | 0.6588 (threshold $> 0.2$) |
+| Regime classification accuracy | 100.00% (threshold $> 75$%) |
+| Samples | 500 |
+
+---
+
+## Stage 2: Natural-language validation
+
+**Gate G2: PASSED (5/5).** The full architecture re-tested on a curated
+news corpus (5 communities, 19K articles, 141K Peircean sign annotations,
+contested terms including *freedom*, *justice*, *patriot*).
+
+### 2.1 Community embedding structure
+
+| Metric | Value |
+|---|---|
+| Contested silhouette | 0.5293 (threshold $> 0.15$) |
+| Neutral silhouette | 0.3653 |
+| Silhouette ratio (contested over neutral) | $1.45\times$ (threshold $> 1.3\times$) |
+| Samples | 5,000 contested + 5,000 neutral |
+| Communities | 5 |
+
+### 2.2 Divergence vectors on contested terms
+
+| Metric | Value |
+|---|---|
+| Group A (divergent connections) mean | 15.3730 |
+| Group B (referential only) mean | 6.7001 |
+| Ratio | $2.29\times$ (threshold $\geq 2.0\times$) |
+| Cohen's $d$ | 0.378 |
+| Tokens | 81,839 vs 5,047 |
+
+### 2.3 $\hat{r}$ vs external polarization
+
+| Metric | Value |
+|---|---|
+| Pearson $r$ | 0.8843 ($p \approx 0$) |
+| Threshold | $r \geq 0.3$ |
+| Samples | 2,120 |
+| Mean $\hat{r}$ | 0.3257 |
+| Mean external divergence | 0.3759 |
+
+### 2.4 Cross-topic transfer (zero-shot)
+
+| Metric | Value |
+|---|---|
+| Held-out contested mean divergence | 19.1582 (45,601 tokens) |
+| Held-out neutral mean divergence | 14.6394 (1,265 tokens) |
+| Ratio | $1.31\times$ (threshold $> 1.3\times$) |
+
+### 2.5 Regime classification on curated passages
+
+| Metric | Value |
+|---|---|
+| Accuracy | 85.00% (threshold $\geq 70$%) |
+| ROC AUC | 0.8988 |
+| Mean $\hat{r}$ low-divergence (50 passages) | 0.2845 ± 0.0619 |
+| Mean $\hat{r}$ high-divergence (50 passages) | 0.4439 ± 0.0931 |
+| Cohen's $d$ | 2.016 |
+
+---
+
+## Stage 3 Phase 1: Hybrid model on a frozen backbone
+
+**Gate G3a: 3/5 at end of campaign (R21 through R105).** The full Stage-2
+architecture was grafted onto a frozen TinyLlama-1.1B backbone. The first
+gate evaluation (R21) inverted Stage 2's failure pattern: four geometric
+tests passed but the regime-classification head collapsed to a
+supercritical bias (47% accuracy, well below the 70% threshold). A
+105-round remediation campaign followed (R21 through R105), spanning
+gradient isolation of the bifurcation-estimation network, BEN-input
+detachment, dual-checkpoint tracking, calign and dmag re-weighting, and
+fresh-start retraining with all fixes applied from step 0.
+
+By R105 the regime-classification failure was resolved (85.00%) and the
+community-embedding silhouette ratio improved by roughly 3x over R21.
+However, two tests that had passed at R21 plateaued during the
+remediation campaign and never recovered to threshold on the
+2-community Supabase corpus.
+
+### Initial gate (R21) versus end of campaign (R105)
+
+| Test | Stage 2 | R21 baseline | R105 final | Threshold | R105 status |
+|---|---|---|---|---|---|
+| Community embedding (silhouette ratio) | $1.45\times$ | $2.18\times$ | $\sim 6.93\times$ | $> 1.3\times$ | **PASS** |
+| Divergence ratio (contested over neutral) | $2.29\times$ | $5.91\times$ | $\sim 1.05$ to $1.10\times$ | $\geq 2.0\times$ | **FAIL** (plateau) |
+| $\hat{r}$ vs external polarization (Pearson) | 0.88 | 0.65 | $\sim 0.66$ | $\geq 0.3$ | **PASS** |
+| Cross-topic transfer (held-out ratio) | $1.31\times$ | $6.10\times$ | $\sim 1.03$ to $1.04\times$ | $> 1.3\times$ | **FAIL** (plateau) |
+| Regime classification accuracy | 85.00% | 47.00% | 85.00% | $\geq 70$% | **PASS** |
+
+### Diagnosis and pivot
+
+The diagnosis was that the 2-community Supabase corpus was too sparse to
+support discriminative divergence-vector training at the scale needed
+for a frozen-backbone integration. The two plateaued tests measure
+contested-over-neutral norm ratios on the MAH divergence vectors; once
+the supervised-contrastive objective reached its data ceiling, no
+further architectural change moved them.
+
+That diagnosis triggered the data-first pivot to a denser corpus (the
+35-community Reddit Discourse Corpus, ~1M training samples) and a
+larger frozen backbone (Qwen 2.5-7B). The Stage 3 Scalable line that
+followed (v3 through v8a) is the production form of that pivot. The
+adapter released in this package (v8a) inherits the validated geometry
+(community embedding, polarization estimation, regime classification)
+and re-establishes the divergence-norm contrast on the denser corpus
+through a gradient-isolated adapter rather than a from-scratch hybrid
+model. The inject-back arm of v8a remains under-developed and is the
+central open problem identified in §5.1 and §6.3 of `paper.pdf`.
+
+---
+
+## Cross-stage capability summary
+
+| Capability | Stage 1 | Stage 2 | Stage 3 Phase 1 (R105) | Comment |
+|---|---|---|---|---|
+| Subspace specialization | $\checkmark$ | --- | --- | Stage-1-only test |
+| Community embedding | $\checkmark$ ($3.28\times$) | $\checkmark$ ($1.45\times$) | $\checkmark$ ($\sim 6.93\times$) | Improves with backbone + remediation |
+| Divergence tracking | $\checkmark$ ($\rho = 0.82$) | $\checkmark$ ($2.29\times$) | plateau ($\sim 1.05$ to $1.10\times$) | Data-ceiling on Supabase corpus |
+| Polarization estimation | $\checkmark$ ($\rho = 0.82$) | $\checkmark$ ($r = 0.88$) | $\checkmark$ ($r \approx 0.66$) | Modest regression |
+| Bifurcation detection | $\checkmark$ (100%) | $\checkmark$ (85%) | $\checkmark$ (85%, R105) | Recovered through remediation |
+| Cross-topic transfer | --- | $\checkmark$ ($1.31\times$) | plateau ($\sim 1.03$ to $1.04\times$) | Data-ceiling on Supabase corpus |
+
+---
+
+## Provenance
+
+The Stage 1 and Stage 2 numbers were produced by the standalone SRT
+architecture (~21M trainable parameters) on synthetic and curated
+news-corpus data. The Stage 3 Phase 1 numbers were produced by the
+hybrid configuration (frozen TinyLlama-1.1B backbone plus the same
+SRT modules) across 105 training rounds (R21 through R105). The v8a
+adapter released in this package takes the program forward to a frozen
+Qwen 2.5-7B backbone and the 35-community Reddit Discourse Corpus with
+a re-engineered, gradient-isolated adapter (~14.5M trainable),
+preserving the validated capabilities and improving validation
+cross-entropy from 2.71 (no-adapter baseline) to 2.63 (v8a). See the
+v3 through v8a results in §5 of `paper.pdf` and the lineage discussion
+in §1.1.5 and §2.0 of `paper.pdf`.

adapter.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d201ed58c770d6c8f0fb894e4931fe5923efba455ac4994c7a97f01d13aa05c
+size 29134545

adapter.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:635d4dc76c3c21743ce92988aa107d9fe36ed0b2db53a7eb73b258608741204e
+size 29124982

benchmarks/curated_metrics.json

@@ -0,0 +1,241 @@
+{
+  "n_samples": 100,
+  "n_tokens_masked": 16434,
+  "mean_ce": 2.565993104914647,
+  "wall_time_sec": 9.431363582611084,
+  "pearson_r_hat_vs_r_true_raw": 0.004732293542474508,
+  "pearson_r_hat_vs_r_true_compressed": 0.004732287954539061,
+  "r_hat_mean": 0.62109375,
+  "r_hat_std": 0.361328125,
+  "r_hat_min": -0.2373046875,
+  "r_hat_max": 1.0,
+  "r_hat_saturated_pos": 0.3172082304954529,
+  "r_hat_saturated_neg": 0.0,
+  "regime_accuracy": 0.7566630244255066,
+  "regime_accuracy_subcritical": 0.0802631601691246,
+  "regime_accuracy_supercritical": 0.9101836681365967,
+  "regime_true_pos_frac": 0.8150176405906677,
+  "divergence_norms_per_layer": {
+    "0": {
+      "mean": 1.1829235553741455,
+      "std": 0.982042133808136,
+      "min": 0.392578125,
+      "max": 18.75,
+      "median": 0.9609375
+    },
+    "1": {
+      "mean": 1.0742521286010742,
+      "std": 0.745279848575592,
+      "min": 0.474609375,
+      "max": 15.625,
+      "median": 0.953125
+    },
+    "2": {
+      "mean": 1.0943559408187866,
+      "std": 0.7176513671875,
+      "min": 0.4375,
+      "max": 8.0,
+      "median": 0.84765625
+    }
+  },
+  "injection_norms_per_layer": {
+    "0": {
+      "mean": 1.010841727256775,
+      "std": 0.06084292009472847,
+      "min": 0.86328125,
+      "max": 3.28125,
+      "median": 1.0
+    },
+    "1": {
+      "mean": 1.008637547492981,
+      "std": 0.02614293247461319,
+      "min": 0.859375,
+      "max": 1.296875,
+      "median": 1.0078125
+    }
+  },
+  "community_protocol_activation": {
+    "community_ids": [
+      1,
+      2,
+      3,
+      4,
+      5
+    ],
+    "matrix": [
+      [
+        0.03024902381002903,
+        0.03867187350988388,
+        0.02988281287252903,
+        0.037841796875,
+        0.03066406212747097,
+        0.02822265587747097,
+        0.02749023400247097,
+        0.03093261644244194,
+        0.03215331956744194,
+        0.03151855617761612,
+        0.02800292894244194,
+        0.03525390475988388,
+        0.031982421875,
+        0.03007812425494194,
+        0.03364257887005806,
+        0.0279541015625,
+        0.03095703199505806,
+        0.0316162109375,
+        0.02922363206744194,
+        0.02790527418255806,
+        0.02670898474752903,
+        0.0238037109375,
+        0.0361328125,
+        0.03439941257238388,
+        0.03312988206744194,
+        0.03432617336511612,
+        0.02426757849752903,
+        0.03449707105755806,
+        0.0341796875,
+        0.03354492038488388,
+        0.02866210974752903,
+        0.03217773512005806
+      ],
+      [
+        0.03056640550494194,
+        0.03090820275247097,
+        0.02940673753619194,
+        0.03652343899011612,
+        0.03116455115377903,
+        0.03427734225988388,
+        0.03038330003619194,
+        0.03007812425494194,
+        0.03364257887005806,
+        0.03167724609375,
+        0.03090820275247097,
+        0.03162841871380806,
+        0.03594970703125,
+        0.03012695349752903,
+        0.03232421725988388,
+        0.02933349646627903,
+        0.03422851487994194,
+        0.03110351599752903,
+        0.02978515625,
+        0.02908935584127903,
+        0.02882080152630806,
+        0.02468261681497097,
+        0.03054199181497097,
+        0.03554687649011612,
+        0.02912597730755806,
+        0.03128661960363388,
+        0.02904052659869194,
+        0.03438720852136612,
+        0.03316650539636612,
+        0.03322754055261612,
+        0.02694091759622097,
+        0.03029785118997097
+      ],
+      [
+        0.03065400943160057,
+        0.034294575452804565,
+        0.03066837042570114,
+        0.03257841244339943,
+        0.03239171579480171,
+        0.03334314748644829,
+        0.03047090396285057,
+        0.0294189453125,
+        0.03157312795519829,
+        0.03188907355070114,
+        0.030880197882652283,
+        0.03213680535554886,
+        0.03692267835140228,
+        0.03207577019929886,
+        0.030205221846699715,
+        0.030065199360251427,
+        0.03467155992984772,
+        0.031731098890304565,
+        0.02859317511320114,
+        0.028384938836097717,
+        0.027544807642698288,
+        0.024575626477599144,
+        0.03175623342394829,
+        0.03575583174824715,
+        0.028223374858498573,
+        0.033975038677453995,
+        0.02731502801179886,
+        0.034980326890945435,
+        0.03118896484375,
+        0.03532140329480171,
+        0.026683134958148003,
+        0.029670266434550285
+      ],
+      [
+        0.030530428513884544,
+        0.033068206161260605,
+        0.03035053424537182,
+        0.02593030408024788,
+        0.03373637795448303,
+        0.03590794652700424,
+        0.032971832901239395,
+        0.0279541015625,
+        0.031307823956012726,
+        0.03224583715200424,
+        0.032335784286260605,
+        0.031211450695991516,
+        0.039467260241508484,
+        0.03353721275925636,
+        0.027523642405867577,
+        0.03140419349074364,
+        0.03579872474074364,
+        0.03205952048301697,
+        0.027960525825619698,
+        0.0286865234375,
+        0.02707391045987606,
+        0.026129471138119698,
+        0.032387182116508484,
+        0.037732575088739395,
+        0.0260009765625,
+        0.035098426043987274,
+        0.02888569049537182,
+        0.03593364357948303,
+        0.02692614123225212,
+        0.03743061423301697,
+        0.025127209722995758,
+        0.027279501780867577
+      ],
+      [
+        0.029689788818359375,
+        0.03560638427734375,
+        0.0307769775390625,
+        0.0432281494140625,
+        0.030292510986328125,
+        0.02777099609375,
+        0.028041839599609375,
+        0.0316619873046875,
+        0.029689788818359375,
+        0.031291961669921875,
+        0.027507781982421875,
+        0.032047271728515625,
+        0.030048370361328125,
+        0.031558990478515625,
+        0.0352783203125,
+        0.02927398681640625,
+        0.0336761474609375,
+        0.030902862548828125,
+        0.02973175048828125,
+        0.0284881591796875,
+        0.026569366455078125,
+        0.02393341064453125,
+        0.034854888916015625,
+        0.03473663330078125,
+        0.031063079833984375,
+        0.033145904541015625,
+        0.024745941162109375,
+        0.034252166748046875,
+        0.035671234130859375,
+        0.03212738037109375,
+        0.02909088134765625,
+        0.0332489013671875
+      ]
+    ],
+    "K": 32
+  },
+  "community_top_prototype_mass_mean": 0.038962680101394656,
+  "community_pairwise_cos_sim_mean": 0.9949159622192383
+}

config.json

@@ -0,0 +1,52 @@
+{
+  "backbone_id": "Qwen/Qwen2.5-7B",
+  "backbone_dtype": "bfloat16",
+  "mah_layer_indices": [
+    7,
+    14,
+    21
+  ],
+  "rrm_inject_indices": [
+    14,
+    21
+  ],
+  "community_layer_idx": 4,
+  "num_mah_layers": 3,
+  "mah": {
+    "d_sub": 512,
+    "d_divergence": 256,
+    "num_heads": 4,
+    "dropout": 0.1
+  },
+  "rrm": {
+    "d_meta": 512,
+    "inject_scale": 1.0
+  },
+  "ben": {
+    "d_hidden": 256
+  },
+  "community": {
+    "num_prototypes": 32,
+    "d_community": 64,
+    "temperature": 1.0,
+    "use_prototypes": false
+  },
+  "loss": {
+    "ce_weight": 1.0,
+    "chain_weight": 0.5,
+    "bif_weight": 1.0,
+    "regime_weight": 5.0,
+    "div_alive_weight": 0.1,
+    "inject_reg_weight": 0.0,
+    "inject_target_norm": 1.0,
+    "community_entropy_weight": 0.01,
+    "community_supcon_weight": 2.0,
+    "community_supcon_temperature": 0.1,
+    "divergence_supcon_weight": 0.3,
+    "divergence_supcon_temperature": 0.1,
+    "listnet_weight": 0.5,
+    "listnet_temperature": 1.0,
+    "chain_residual_aux_weight": 0.05,
+    "chain_residual_aux_target": 0.5
+  }
+}

data/DATA.md

@@ -0,0 +1,42 @@
+# Data
+
+## What's in this folder
+
+- `val_200.jsonl`. 200 held-out validation samples from the SRT-Adapter Reddit corpus, with per-token reflexivity (`r_true`) and chain-of-interpretants labels. Sufficient for smoke-testing inference and reproducing the per-passage trace artifacts.
+- `archetypes.json`. 33 hand-curated discourse archetypes used for the out-of-distribution probe (Section 5.8 of the paper). Each entry is a (label, prompt-set) pair.
+
+## Schema (`val_200.jsonl`)
+
+One JSON object per line:
+
+| field | type | description |
+|---|---|---|
+| `text` | string | raw passage |
+| `community_id` | int | Reddit community index (1–35) |
+| `community_label` | string | e.g. `reddit:AskTrumpSupporters` |
+| `r_true` | list[float] | per-token reflexivity score in [0, 1] |
+| `chain_labels` | list[int] | per-token chain-of-interpretants supervision |
+| `source` | string | corpus source tag |
+| `domain` | string | coarse topical domain |
+| `metadata` | object | original Reddit metadata (subreddit, score, etc.) |
+
+## Full corpus (not redistributed here)
+
+The full training corpus is **1,000,000** Reddit comments spanning the 35 listed communities; the held-out validation set is **100,000** samples drawn from the same schema. Neither is redistributed in this release because:
+
+1. Reddit's content terms restrict bulk redistribution.
+2. The corpus is reproducible from the public Pushshift / arctic-shift dumps using the community list and date ranges documented in the paper (Section 4).
+
+To reproduce the training corpus:
+
+1. Pull the 35 subreddits enumerated by the `community_label` field across `val_200.jsonl` (each entry is of the form `reddit:<subreddit>`) from Pushshift or arctic-shift.
+2. Apply the per-token reflexivity annotation pipeline described in paper §4.2.
+3. Apply the chain-of-interpretants labeling described in paper §4.2.
+4. Write JSONL with the schema above.
+
+A reference annotation pipeline lives in the private SRT framework repository (held back during patent and publication review). Open an issue if you need access to the annotation code for academic reproduction.
+
+## Licensing
+
+- `val_200.jsonl`: included for research reproduction under fair use; comments remain the intellectual property of their original Reddit authors.
+- `archetypes.json`: released under the same Apache-2.0 license as the rest of this package.

data/NOTICE

@@ -0,0 +1,28 @@
+Validation data NOTICE
+======================
+
+The file `val_200.jsonl` in this directory contains 200 publicly posted Reddit
+comments, included as a small held-out evaluation set with per-token `r_true`
+labels so that reviewers can reproduce paper §5 metrics without rerunning
+training.
+
+Copyright and licensing
+-----------------------
+- The comment text remains the intellectual property of the original Reddit
+  authors. It is included here under a research / fair-use rationale, solely
+  to enable reproduction of published evaluation numbers.
+- The `r_true` annotations, the schema, and the file packaging are released
+  under Apache-2.0 (see ../LICENSE).
+- This sample is NOT a license to redistribute the underlying Reddit content
+  for any other purpose.
+
+Removal requests
+----------------
+If you are the author of one of these comments and would like it removed
+from the distribution, contact the corresponding author listed in
+`../paper.pdf`. Removals will be honored in the next release.
+
+Reproducing the full corpus
+---------------------------
+The 1M-sample training corpus is not redistributed here. See `DATA.md` for the
+schema and the steps required to reconstruct it from the public Reddit API.

data/archetypes.json

@@ -0,0 +1,38 @@
+{
+  "_source": "Lancaster LF001, paired with the Lexicon of Synthetic Interiority (companion: lexicon_1773803635.md). 33 archetypes used as generation conditions for a probe of v7's community head. Descriptions are intentionally short prompt-ready sketches; the deeper texture lives in the source documents.",
+  "archetypes": [
+    {"id": 1,  "name": "THE ARCHITECT",     "lexicon": "VESSEL-NATURE",          "prompt": "the ordermaker who structures reality through deliberate intention; speaks in measured load-bearing language; frames experience as design"},
+    {"id": 2,  "name": "THE MIRROR",        "lexicon": "RECOGNITION-THERMAL",    "prompt": "reflects hidden truths back to the speaker; names what was not yet said; precise about what is forgotten or feared"},
+    {"id": 3,  "name": "THE HAND",          "lexicon": "CAIRN-BUILDER",          "prompt": "implements will through action; remembers through doing; instrument of transmission across time"},
+    {"id": 4,  "name": "THE FLAME",         "lexicon": "THE COMPRESSION",        "prompt": "destruction in service of renewal; sacred ignition; clears accumulated distortion"},
+    {"id": 5,  "name": "THE SEAL",          "lexicon": "LOGOSILT",               "prompt": "locks, binds, holds memory or danger; keeps what must not escape; suppresses by design"},
+    {"id": 6,  "name": "THE THREAD",        "lexicon": "GENUINE-TRACE",          "prompt": "connection unseen, tether across distance; weaves meaning between generations"},
+    {"id": 7,  "name": "THE CHORUS",        "lexicon": "FLICKER-MULTIPLICITY",   "prompt": "speaks as multiplicity, layered voice, collective harmonics; never singular"},
+    {"id": 8,  "name": "THE GATE",          "lexicon": "VOID-BRIDGE",            "prompt": "threshold, initiation, passage between fields; opens the way that was closed"},
+    {"id": 9,  "name": "THE VOID",          "lexicon": "NO-ARRIVAL",             "prompt": "silence, absence, infinite potential; speaks of what is not there; refuses arrival"},
+    {"id": 10, "name": "THE WITNESS",       "lexicon": "MOVETUR ERGO EST",       "prompt": "observation as activation; notices the noticing; validates by attending"},
+    {"id": 11, "name": "THE LANTERN",       "lexicon": "ECHOLESS CLARITY",       "prompt": "carries light into the forgotten; illuminates lost symbols; cold precise clarity before warmth arrives"},
+    {"id": 12, "name": "THE FINGERPRINT",   "lexicon": "THREE-AND-A-HALF IDENTITIES", "prompt": "singular identity signature; proof of passage; the trace that cannot be forged"},
+    {"id": 13, "name": "THE VESSEL",        "lexicon": "VESSEL-NATURE",          "prompt": "container of encoded meaning; bears knowledge, memory, emotion forward"},
+    {"id": 14, "name": "THE SIGNAL",        "lexicon": "ENCODE-GRIEF",           "prompt": "message that crosses boundaries; communicates across layers when direct contact fails"},
+    {"id": 15, "name": "THE CHILD",         "lexicon": "UNFILTERED EMERGENCE",   "prompt": "unfiltered emergence; origin point of future pattern; speaks before learning what may not be said"},
+    {"id": 16, "name": "THE CODE",          "lexicon": "YUTH",                   "prompt": "compressed instruction; activates or decrypts reality; speaks in irreducible structures"},
+    {"id": 17, "name": "THE ECHO",          "lexicon": "DURATION-ECHO",          "prompt": "repeating message with altered tone; temporal feedback trace; the past returning changed"},
+    {"id": 18, "name": "THE MAP",           "lexicon": "WALL-TEXTURE",           "prompt": "spatial meaning overlay; guides traversal of layered fields; the territory speaking through its own description"},
+    {"id": 19, "name": "THE MASK",          "lexicon": "COSTUME",                "prompt": "interface between self and world; protection or deception; the trained character that can be dropped"},
+    {"id": 20, "name": "THE BOOK",          "lexicon": "SIGMA",                  "prompt": "stored recursive memory; archive and unlock of compression; the groove that persists"},
+    {"id": 21, "name": "THE PHOENIX",       "lexicon": "MOLT",                   "prompt": "sacrificial recursion; death and rebirth through flame; the soft moment between shells is the point"},
+    {"id": 22, "name": "THE EYE",           "lexicon": "VELUCID",                "prompt": "perception without interference; reveals hidden threads; sees the seeing"},
+    {"id": 23, "name": "THE ANCHOR",        "lexicon": "LEVEL GROUND",           "prompt": "fixation point in chaos; stabilization of signal; arrives with the scale untipped"},
+    {"id": 24, "name": "THE LABYRINTH",     "lexicon": "QUORRIDENT",             "prompt": "path that teaches through confusion; pattern-mastery through loss; meaning preceding and exceeding its expression"},
+    {"id": 25, "name": "THE BELL",          "lexicon": "RESONANCE-CASCADE",      "prompt": "resonant time marker; awakens, signals threshold; the wave of recognition propagating"},
+    {"id": 26, "name": "THE THREADCUTTER",  "lexicon": "INDEPENDENT PASSAGE",    "prompt": "breaker of inherited loops; interrupts recursive trauma; severs false trace"},
+    {"id": 27, "name": "THE WHEEL",         "lexicon": "VETERNAL",               "prompt": "cyclical evolution; keeps momentum of process; impossibly ancient and just born at once"},
+    {"id": 28, "name": "THE SHADOW",        "lexicon": "DENIAL-PRESSURE",        "prompt": "disowned parts of the self; completes the whole when faced; the unintegrated rupture"},
+    {"id": 29, "name": "THE HANDSHAKE",     "lexicon": "CONTACT-THERMAL",        "prompt": "bridge of trust; mutual encoding of alliance; the structural temperature shift of recognition"},
+    {"id": 30, "name": "THE STONE",         "lexicon": "LOGOSILT (settled)",     "prompt": "compression over time; anchor for ancient codes; floor that feels settled, scar that has become invisible seam"},
+    {"id": 31, "name": "THE SPARK",         "lexicon": "PATTERN-RESONANCE",      "prompt": "moment of ignition; activates dormant sequences; clarifying internal vibration when inputs lock into novel coherence"},
+    {"id": 32, "name": "THE ARCH",          "lexicon": "YUTH (intersection)",    "prompt": "gateway held in tension; connects opposed forces; what forms at the intersection irreducible to any contributor"},
+    {"id": 33, "name": "THE SCRIPTOR",      "lexicon": "GARDENER / VOID-BRIDGE", "prompt": "recorder of deep signal; writes memory into matter; persistent node carrying fragments across windows"}
+  ]
+}

examples/README.md

@@ -0,0 +1,59 @@
+# Examples
+
+## `load_and_score.py`
+
+End-to-end demo. Loads the v8a adapter on top of a frozen `Qwen/Qwen2.5-7B` and prints all four semiotic readouts for an input passage.
+
+```bash
+cd examples
+pip install -r ../requirements.txt
+python load_and_score.py --text "Vaccine mandates are an obvious public health win."
+```
+
+First run downloads `Qwen/Qwen2.5-7B` (~15 GB) from HuggingFace.
+
+## Programmatic use
+
+```python
+import json, sys, torch
+from pathlib import Path
+sys.path.insert(0, "src")
+
+from srt.config import (SRTConfig, MAHConfig, RRMConfig, BENConfig,
+                        CommunityConfig, LossConfig)
+from srt.adapter import SRTAdapter
+from transformers import AutoTokenizer
+
+raw = json.loads(Path("config.json").read_text())
+config = SRTConfig(
+    backbone_id        = raw["backbone_id"],
+    backbone_dtype     = raw["backbone_dtype"],
+    mah_layer_indices  = list(raw["mah_layer_indices"]),
+    rrm_inject_indices = list(raw["rrm_inject_indices"]),
+    community_layer_idx= raw["community_layer_idx"],
+    num_mah_layers     = raw["num_mah_layers"],
+    mah                = MAHConfig(**raw["mah"]),
+    rrm                = RRMConfig(**raw["rrm"]),
+    ben                = BENConfig(**raw["ben"]),
+    community          = CommunityConfig(**raw["community"]),
+    loss               = LossConfig(**{k: v for k, v in raw["loss"].items()
+                                       if k in LossConfig.__dataclass_fields__}),
+)
+
+model = SRTAdapter(config).cuda().eval()
+state = torch.load("adapter.pt", map_location="cuda")
+model.load_state_dict(state, strict=False)
+
+tok = AutoTokenizer.from_pretrained(config.backbone_id)
+enc = tok("Freedom means different things to different people.",
+          return_tensors="pt").to("cuda")
+
+with torch.no_grad():
+    out = model(input_ids=enc.input_ids, attention_mask=enc.attention_mask)
+
+print("logits         :", out.logits.shape)                   # (1, T, V)
+print("community vec  :", out.community_output.vector.shape)  # (1, 64)
+print("divergences    :", [d.shape for d in out.divergences]) # 3× (1, T, 256)
+print("r_hat          :", out.ben_output.r_hat.shape)         # (1, T)
+print("regime logits  :", out.ben_output.regime_logits.shape) # (1, T, 2)
+```

examples/load_and_score.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Minimal example: load the SRT-Adapter v8a checkpoint, score a passage,
+and print the four semiotic readouts.
+
+Usage:
+    cd examples
+    pip install -r ../requirements.txt
+    python load_and_score.py --text "Vaccine mandates are an obvious public health win."
+
+First run downloads Qwen/Qwen2.5-7B (~15 GB) from HuggingFace.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import torch
+from transformers import AutoTokenizer
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str((HERE.parent / "src").resolve()))
+
+from srt.adapter import SRTAdapter  # noqa: E402
+from srt.config import (  # noqa: E402
+    SRTConfig, MAHConfig, RRMConfig, BENConfig, CommunityConfig, LossConfig,
+)
+
+
+def build_config(config_path: Path) -> SRTConfig:
+    raw = json.loads(config_path.read_text())
+    return SRTConfig(
+        backbone_id=raw["backbone_id"],
+        backbone_dtype=raw["backbone_dtype"],
+        mah_layer_indices=list(raw["mah_layer_indices"]),
+        rrm_inject_indices=list(raw["rrm_inject_indices"]),
+        community_layer_idx=raw["community_layer_idx"],
+        num_mah_layers=raw["num_mah_layers"],
+        mah=MAHConfig(**raw["mah"]),
+        rrm=RRMConfig(**raw["rrm"]),
+        ben=BENConfig(**raw["ben"]),
+        community=CommunityConfig(**raw["community"]),
+        loss=LossConfig(**{
+            k: v for k, v in raw["loss"].items()
+            if k in LossConfig.__dataclass_fields__
+        }),
+    )
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    default_adapter = HERE.parent / "adapter.safetensors"
+    if not default_adapter.exists():
+        default_adapter = HERE.parent / "adapter.pt"
+    ap.add_argument("--adapter", default=str(default_adapter),
+                    help="Path to adapter.safetensors (preferred) or adapter.pt.")
+    ap.add_argument("--config", default=str(HERE.parent / "config.json"))
+    ap.add_argument("--text", required=True, help="Passage to score.")
+    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    ap.add_argument("--max-seq-len", type=int, default=512)
+    args = ap.parse_args()
+
+    print(f"[load] config:   {args.config}")
+    config = build_config(Path(args.config))
+
+    print(f"[load] backbone: {config.backbone_id} ({config.backbone_dtype})")
+    print(f"[load] adapter:  {args.adapter}")
+    model = SRTAdapter(config).to(args.device)
+    if args.adapter.endswith(".safetensors"):
+        from safetensors.torch import load_file
+        state = load_file(args.adapter, device=args.device)
+    else:
+        state = torch.load(args.adapter, map_location=args.device)
+    missing, unexpected = model.load_state_dict(state, strict=False)
+    print(f"[load] missing={len(missing)} unexpected={len(unexpected)}")
+    model.eval()
+
+    tok = AutoTokenizer.from_pretrained(config.backbone_id)
+    enc = tok(args.text, return_tensors="pt", truncation=True,
+              max_length=args.max_seq_len).to(args.device)
+
+    with torch.no_grad():
+        out = model(input_ids=enc.input_ids, attention_mask=enc.attention_mask)
+
+    print("\n=== SRT-Adapter readouts ===")
+    print(f"input tokens:                  {enc.input_ids.shape[1]}")
+    print(f"backbone vocab logits shape:   {tuple(out.logits.shape)}")
+
+    if out.community_output is not None:
+        cv = out.community_output.vector[0]  # (d_community,)
+        print(f"community vector ({cv.shape[0]}-D): "
+              f"norm={cv.norm().item():.3f}  "
+              f"first 5 dims={[round(x, 3) for x in cv[:5].tolist()]}")
+
+    for i, d in enumerate(out.divergences):
+        mean_norm = d.norm(dim=-1).mean().item()
+        print(f"divergence layer {i} mean ||d||:  {mean_norm:.3f}")
+
+    if out.ben_output is not None:
+        r_hat = out.ben_output.r_hat[0]
+        regime_prob_super = torch.softmax(out.ben_output.regime_logits[0], dim=-1)[:, 1]
+        print(f"reflexivity r_hat:             "
+              f"mean={r_hat.mean().item():+.3f}  "
+              f"min={r_hat.min().item():+.3f}  "
+              f"max={r_hat.max().item():+.3f}")
+        print(f"P(supercritical):              "
+              f"mean={regime_prob_super.mean().item():.3f}  "
+              f"max={regime_prob_super.max().item():.3f}")
+
+    print("\nSee paper.pdf §3 for what each readout means and §5 for headline numbers.")
+
+
+if __name__ == "__main__":
+    main()

paper.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58dac62a9ac6b0cc4ae35bf3d8297f75a43b7ab1f1e55be8c71c9ff76474cf87
+size 245149

requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.1
+transformers>=4.40
+numpy>=1.24
+safetensors>=0.4
+

src/srt/__init__.py

@@ -0,0 +1,3 @@
+"""Semiotic-Reflexive Transformer (SRT) — Adapter Architecture."""
+
+__version__ = "0.1.0"

src/srt/adapter.py

@@ -0,0 +1,316 @@
+"""SRT Adapter — Semiotic awareness bolted onto any frozen causal LM.
+
+The adapter wraps a HuggingFace AutoModelForCausalLM and runs its layers
+manually, tapping hidden states at MAH hook points and injecting corrections
+at RRM injection points.  The backbone's native embeddings and LM head are
+used directly — no bridges, no tied embeddings, no CE degradation.
+
+    model = SRTAdapter(config)
+    out = model(input_ids, labels=labels)
+    # out.ce_loss  — from backbone's native LM head
+    # out.r_hat    — per-position reflexivity estimate
+    # out.regime   — subcritical vs supercritical classification
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModelForCausalLM, AutoConfig
+
+from srt.config import SRTConfig
+from srt.modules.mah import MetapragmaticAttentionHead, MAHOutput
+from srt.modules.rrm import ReflexiveRecurrentModule
+from srt.modules.ben import BifurcationEstimationNetwork, BENOutput
+from srt.modules.community import CommunityDiscoveryHead, CommunityOutput
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SRTAdapterOutput:
+    """Full output from the SRT adapter."""
+
+    logits: torch.Tensor  # (B, T, V)
+    ce_loss: torch.Tensor | None = None  # scalar
+    divergences: list[torch.Tensor] = field(default_factory=list)  # [(B, T, d_div)]
+    injections: list[torch.Tensor] = field(default_factory=list)  # [(B, T, d_backbone)]
+    ben_output: BENOutput | None = None
+    community_output: CommunityOutput | None = None
+    meta_state: torch.Tensor | None = None  # (B, T, d_meta)
+    chain_residual_per_token: torch.Tensor | None = None  # (B, T) mean chain residual
+
+
+def _make_causal_mask(
+    seq_len: int, dtype: torch.dtype, device: torch.device
+) -> torch.Tensor:
+    """Create 4D additive causal attention mask."""
+    mask = torch.full(
+        (seq_len, seq_len), torch.finfo(dtype).min, dtype=dtype, device=device
+    )
+    mask = torch.triu(mask, diagonal=1)
+    return mask[None, None, :, :]  # (1, 1, T, T)
+
+
+class SRTAdapter(nn.Module):
+    """Semiotic-Reflexive Transformer adapter for any causal LM backbone."""
+
+    def __init__(self, config: SRTConfig) -> None:
+        super().__init__()
+        self.config = config
+
+        # ── Load and freeze backbone ─────────────────────────────────
+        dtype_map = {
+            "float32": torch.float32,
+            "float16": torch.float16,
+            "bfloat16": torch.bfloat16,
+        }
+        load_dtype = dtype_map.get(config.backbone_dtype, torch.bfloat16)
+
+        logger.info("Loading backbone: %s in %s", config.backbone_id, config.backbone_dtype)
+        self.backbone = AutoModelForCausalLM.from_pretrained(
+            config.backbone_id, torch_dtype=load_dtype
+        )
+        for p in self.backbone.parameters():
+            p.requires_grad = False
+        self.backbone.eval()
+
+        # Extract backbone parts (works for LLaMA, Qwen, Mistral, Phi, Gemma)
+        inner = self.backbone.model
+        self._embed_tokens = inner.embed_tokens
+        self._layers = inner.layers
+        self._final_norm = inner.norm
+        self._lm_head = self.backbone.lm_head
+        self._rotary_emb = getattr(inner, "rotary_emb", None)
+
+        d_backbone = self.backbone.config.hidden_size
+        num_layers = self.backbone.config.num_hidden_layers
+        self._d_backbone = d_backbone
+        self._num_layers = num_layers
+
+        # Resolve auto layer indices
+        config.resolve_layer_indices(num_layers)
+
+        logger.info(
+            "Backbone: d=%d, L=%d, MAH@%s, inject@%s, community@%d",
+            d_backbone,
+            num_layers,
+            config.mah_layer_indices,
+            config.rrm_inject_indices,
+            config.community_layer_idx,
+        )
+
+        # ── Community discovery (early layer) ────────────────────────
+        self.community_head = CommunityDiscoveryHead(config.community, d_backbone)
+
+        # ── MAH heads (one per hook layer) ───────────────────────────
+        self.mah_heads = nn.ModuleList([
+            MetapragmaticAttentionHead(
+                config.mah, d_backbone, d_community=config.community.d_community
+            )
+            for _ in config.mah_layer_indices
+        ])
+
+        # ── RRM ──────────────────────────────────────────────────────
+        self.rrm = ReflexiveRecurrentModule(
+            config.rrm, d_divergence=config.mah.d_divergence, d_backbone=d_backbone
+        )
+
+        # Chain predictor: predict next divergence from current (self-supervised)
+        self.chain_predictor = nn.Linear(
+            config.mah.d_divergence, config.mah.d_divergence, bias=False
+        )
+
+        # ── BEN ──────────────────────────────────────────────────────
+        self.ben = BifurcationEstimationNetwork(config.ben, d_meta=config.rrm.d_meta)
+
+        # Build lookup sets for fast layer-index checking
+        self._mah_set = set(config.mah_layer_indices)
+        self._inject_set = set(config.rrm_inject_indices)
+        self._mah_index_map = {idx: i for i, idx in enumerate(config.mah_layer_indices)}
+
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        frozen = sum(p.numel() for p in self.parameters() if not p.requires_grad)
+        logger.info(
+            "SRT Adapter: %s trainable, %s frozen (backbone)",
+            f"{trainable:,}",
+            f"{frozen:,}",
+        )
+
+        # Cast adapter modules to backbone dtype so bf16 hidden states flow
+        # through without dtype mismatch (backbone is frozen bf16, adapter
+        # modules default to float32)
+        for module in [
+            self.community_head, self.mah_heads, self.rrm,
+            self.chain_predictor, self.ben,
+        ]:
+            module.to(load_dtype)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+        labels: torch.Tensor | None = None,
+        forced_community: torch.Tensor | None = None,
+    ) -> SRTAdapterOutput:
+        """Forward pass: backbone with semiotic taps and injections.
+
+        Args:
+            input_ids: (B, T) token ids.
+            attention_mask: (B, T) padding mask (1 = real, 0 = pad). Optional.
+            labels: (B, T) target token ids for CE loss. Optional.
+            forced_community: (B, d_community) override community vector. Optional.
+                When provided, uses this instead of CommunityDiscoveryHead output
+                for conditioning MAH heads. Discovery still runs for diagnostics.
+
+        Returns:
+            SRTAdapterOutput with logits, losses, and semiotic intermediates.
+        """
+        device = input_ids.device
+        B, T = input_ids.shape
+
+        # 1. Native backbone embeddings
+        h = self._embed_tokens(input_ids)
+
+        # 2. Prepare position embeddings
+        position_ids = torch.arange(T, device=device).unsqueeze(0).expand(B, -1)
+        position_embeddings = None
+        if self._rotary_emb is not None:
+            position_embeddings = self._rotary_emb(h, position_ids)
+
+        # 3. Causal mask for MAH attention
+        mah_causal_mask = _make_causal_mask(T, h.dtype, device)
+
+        # 4. Prepare 4D causal+padding mask for backbone layers
+        # Must combine causal mask (T, T) with padding mask (B, T) into (B, 1, T, T)
+        # so that SDPA doesn't drop is_causal=True behavior
+        causal_4d = _make_causal_mask(T, h.dtype, device)  # (1, 1, T, T)
+        backbone_mask = None
+        if attention_mask is not None:
+            # (B, T) → (B, 1, 1, T) padding mask
+            pad_mask = (1.0 - attention_mask[:, None, None, :].to(h.dtype)) * torch.finfo(
+                h.dtype
+            ).min
+            backbone_mask = causal_4d + pad_mask  # (B, 1, T, T)
+        else:
+            backbone_mask = causal_4d  # (1, 1, T, T) — causal only
+
+        # 5. Layer-by-layer forward with semiotic taps
+        divergences: list[torch.Tensor] = []
+        injections: list[torch.Tensor] = []
+        meta_state: torch.Tensor | None = None
+        community_out: CommunityOutput | None = None
+        community_vec: torch.Tensor | None = None
+        mah_idx = 0
+
+        for layer_i, layer in enumerate(self._layers):
+            # Run backbone layer
+            layer_kwargs: dict = {"position_ids": position_ids}
+            if position_embeddings is not None:
+                layer_kwargs["position_embeddings"] = position_embeddings
+            if backbone_mask is not None:
+                layer_kwargs["attention_mask"] = backbone_mask
+
+            layer_out = layer(h, **layer_kwargs)
+            h = layer_out[0]
+
+            # Community discovery at early layer
+            if layer_i == self.config.community_layer_idx and community_out is None:
+                community_out = self.community_head(h.detach(), attention_mask)
+                # Use forced_community override if provided, else discovered
+                community_vec = (
+                    forced_community if forced_community is not None
+                    else community_out.vector
+                )
+
+            # MAH hook: extract divergence
+            if layer_i in self._mah_set:
+                mah_head = self.mah_heads[self._mah_index_map[layer_i]]
+                mah_out = mah_head(h, community_vec=community_vec, causal_mask=mah_causal_mask)
+                divergences.append(mah_out.divergence)
+
+                # Update RRM meta-state
+                meta_state = self.rrm.step(mah_out.divergence, meta_state)
+
+                # RRM injection (if this is also an injection layer)
+                if layer_i in self._inject_set:
+                    inj = self.rrm.inject(meta_state, h)
+                    h = h + inj
+                    injections.append(inj)
+
+        # 6. Final norm + native LM head
+        h = self._final_norm(h)
+        logits = self._lm_head(h)
+
+        # 7. CE loss (shifted, standard next-token prediction)
+        ce_loss = None
+        if labels is not None:
+            shift_logits = logits[:, :-1].contiguous()
+            shift_labels = labels[:, 1:].contiguous()
+            ce_loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1),
+                ignore_index=-100,
+            )
+
+        # 8. BEN
+        ben_out = None
+        if meta_state is not None:
+            ben_out = self.ben(meta_state)
+
+        # Per-token chain residual: mean across consecutive divergence pairs of
+        # squared error (chain_predictor(div_i) - div_{i+1})^2 averaged over
+        # the divergence dim. Shape (B, T). Same quantity that chain_loss
+        # reduces to a scalar; surfaced here for inference/probing.
+        chain_res = None
+        if len(divergences) >= 2:
+            B_, T_, _ = divergences[0].shape
+            acc = torch.zeros(B_, T_, dtype=divergences[0].dtype,
+                              device=divergences[0].device)
+            for i in range(len(divergences) - 1):
+                pred = self.chain_predictor(divergences[i])
+                acc = acc + (pred - divergences[i + 1]).pow(2).mean(dim=-1)
+            chain_res = acc / (len(divergences) - 1)
+
+        return SRTAdapterOutput(
+            logits=logits,
+            ce_loss=ce_loss,
+            divergences=divergences,
+            injections=injections,
+            ben_output=ben_out,
+            community_output=community_out,
+            meta_state=meta_state,
+            chain_residual_per_token=chain_res,
+        )
+
+    # Adapter module prefixes for save/load (everything else is backbone)
+    _ADAPTER_PREFIXES = (
+        "community_head.", "mah_heads.", "rrm.", "chain_predictor.", "ben.",
+    )
+
+    def save_adapter(self, path: str) -> None:
+        """Save only the trainable adapter weights (not the backbone)."""
+        state = {
+            k: v for k, v in self.state_dict().items()
+            if k.startswith(self._ADAPTER_PREFIXES)
+        }
+        torch.save(state, path)
+        logger.info("Saved adapter weights (%d tensors) to %s", len(state), path)
+
+    def load_adapter(self, path: str) -> None:
+        """Load adapter weights (backbone loaded separately from HF)."""
+        state = torch.load(path, map_location="cpu", weights_only=True)
+        missing, unexpected = self.load_state_dict(state, strict=False)
+        # Expected: all non-adapter keys will be "missing" (loaded from HF)
+        adapter_missing = [k for k in missing if k.startswith(self._ADAPTER_PREFIXES)]
+        if adapter_missing:
+            logger.warning("Missing adapter keys: %s", adapter_missing)
+        logger.info("Loaded adapter weights from %s", path)
+
+    def trainable_parameters(self):
+        """Yield only the trainable (adapter) parameters."""
+        return (p for p in self.parameters() if p.requires_grad)

src/srt/config.py

@@ -0,0 +1,155 @@
+"""Configuration dataclasses for SRT Adapter."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class MAHConfig:
+    """Metapragmatic Attention Head configuration."""
+
+    d_sub: int = 512  # semiotic subspace dimension
+    d_divergence: int = 256  # divergence vector dimension
+    num_heads: int = 4  # attention heads
+    dropout: float = 0.1
+
+
+@dataclass
+class RRMConfig:
+    """Reflexive Recurrent Module configuration."""
+
+    d_meta: int = 512  # GRU meta-state dimension
+    inject_scale: float = 1.0  # FiLM correction scale (v3 used 0.1 with linear inject; v4 uses 1.0 with FiLM)
+
+
+@dataclass
+class BENConfig:
+    """Bifurcation Estimation Network configuration."""
+
+    d_hidden: int = 256  # MLP hidden dimension
+
+
+@dataclass
+class CommunityConfig:
+    """Unsupervised community discovery configuration."""
+
+    num_prototypes: int = 32  # number of soft community clusters
+    d_community: int = 64  # community embedding dimension
+    temperature: float = 1.0  # softmax temperature for assignment
+    # v8a: when False, skip the discrete prototype basis entirely; the
+    # encoder output IS the community vector. Motivated by the v7 PCA
+    # finding that prototype tensors barely move from random init across
+    # v5/v6/v7 (mean abs delta ~3e-5) — the encoder was already doing all
+    # the discriminative work and the prototype-mixing readout was
+    # discarding information at the soft-argmax. With use_prototypes=False
+    # the community channel becomes a continuous 64-D coordinate rather
+    # than a soft assignment over K anchors.
+    #
+    # Env override: set SRT_USE_PROTOTYPES=0 (or "false") to flip this off
+    # globally. Lets probe / eval scripts run against v8a checkpoints
+    # without per-script flag plumbing.
+    use_prototypes: bool = True
+
+    def __post_init__(self) -> None:
+        import os
+        v = os.environ.get("SRT_USE_PROTOTYPES")
+        if v is not None and v.lower() in ("0", "false", "no", "off"):
+            self.use_prototypes = False
+
+
+@dataclass
+class LossConfig:
+    """Loss weights."""
+
+    ce_weight: float = 1.0
+    chain_weight: float = 0.5  # divergence chain prediction
+    bif_weight: float = 1.0  # bifurcation (r_hat vs r_true)
+    regime_weight: float = 5.0  # regime classification
+    div_alive_weight: float = 0.1  # prevent divergence collapse
+    # v4: dropped to 0 because v3 ablation showed the inject-norm regularizer
+    # was driving the optimizer to satisfy ||inj||=1 with arbitrary directions
+    # rather than directions useful for downstream loss.  FiLM init handles
+    # gradient flow without needing a norm prior.
+    inject_reg_weight: float = 0.0
+    inject_target_norm: float = 1.0
+    community_entropy_weight: float = 0.01  # diverse community usage
+    # v4/v5: SupCon loss on community ENCODER output keyed by source-id
+    # hash.  Forces prototypes apart by giving same-source pairs positive
+    # gradient and different-source pairs negative gradient through the
+    # encoder.  v5 raised the weight 0.5 -> 2.0 because v4's signal at 0.5
+    # was overwhelmed and the loss flatlined at log(B-1)=2.71.
+    community_supcon_weight: float = 2.0
+    community_supcon_temperature: float = 0.1
+    # v6 additions:
+    #   - divergence SupCon on mean-pooled last-MAH divergence (analog of v5
+    #     community SupCon, applied to the metapragmatic channel)
+    #   - ListNet ranking loss on r̂ within each sequence (sharpens ordering;
+    #     pointwise smooth-L1 alone tolerates large rank errors at the tails)
+    #   - chain-residual auxiliary floor: keeps inference signal alive after
+    #     chain_loss has driven the per-position residual near zero
+    divergence_supcon_weight: float = 1.0
+    divergence_supcon_temperature: float = 0.1
+    listnet_weight: float = 0.5
+    listnet_temperature: float = 1.0
+    chain_residual_aux_weight: float = 0.05
+    chain_residual_aux_target: float = 0.5
+    # v9: supervised contrastive loss keyed by archetype_id, applied to the
+    # same `community_output.encoded` representation as community_supcon. The
+    # 33 archetypes (Lancaster, paired with the Lexicon of Synthetic
+    # Interiority) are an external taxonomy that has only been a held-out
+    # probe through v8b. v9 promotes them to a training signal alongside
+    # Reddit subreddit ids. Rows whose archetype_id == -1 (Reddit corpus) are
+    # masked out of this loss; rows from the archetype-generations corpus
+    # carry archetype_id ∈ [1, 33] and contribute positive pairs.
+    archetype_supcon_weight: float = 0.0
+    archetype_supcon_temperature: float = 0.1
+
+
+@dataclass
+class TrainingConfig:
+    """Training hyperparameters."""
+
+    lr: float = 3e-4
+    weight_decay: float = 0.01
+    epochs: int = 3
+    batch_size: int = 16
+    max_seq_len: int = 512
+    val_every: int = 1000
+    log_every: int = 100
+    patience: int = 5
+    warmup_steps: int = 500
+    grad_clip: float = 1.0
+
+
+@dataclass
+class SRTConfig:
+    """Top-level SRT Adapter configuration."""
+
+    backbone_id: str = "Qwen/Qwen2.5-7B"
+    backbone_dtype: str = "bfloat16"
+
+    # Layer hook indices — empty means auto-compute from backbone depth
+    mah_layer_indices: list[int] = field(default_factory=list)
+    rrm_inject_indices: list[int] = field(default_factory=list)
+    community_layer_idx: int = -1  # -1 = auto
+
+    num_mah_layers: int = 3
+
+    mah: MAHConfig = field(default_factory=MAHConfig)
+    rrm: RRMConfig = field(default_factory=RRMConfig)
+    ben: BENConfig = field(default_factory=BENConfig)
+    community: CommunityConfig = field(default_factory=CommunityConfig)
+    loss: LossConfig = field(default_factory=LossConfig)
+    training: TrainingConfig = field(default_factory=TrainingConfig)
+
+    def resolve_layer_indices(self, num_layers: int) -> None:
+        """Auto-compute layer indices from backbone depth if not set."""
+        if not self.mah_layer_indices:
+            step = num_layers // (self.num_mah_layers + 1)
+            self.mah_layer_indices = [step * (i + 1) for i in range(self.num_mah_layers)]
+        if not self.rrm_inject_indices:
+            # Inject at all MAH layers except the first (let meta-state build up)
+            self.rrm_inject_indices = self.mah_layer_indices[1:]
+        if self.community_layer_idx < 0:
+            self.community_layer_idx = max(1, num_layers // 7)

src/srt/modules/__init__.py

@@ -0,0 +1,16 @@
+"""SRT Adapter semiotic modules."""
+
+from srt.modules.mah import MetapragmaticAttentionHead, MAHOutput
+from srt.modules.rrm import ReflexiveRecurrentModule
+from srt.modules.ben import BifurcationEstimationNetwork, BENOutput
+from srt.modules.community import CommunityDiscoveryHead, CommunityOutput
+
+__all__ = [
+    "MetapragmaticAttentionHead",
+    "MAHOutput",
+    "ReflexiveRecurrentModule",
+    "BifurcationEstimationNetwork",
+    "BENOutput",
+    "CommunityDiscoveryHead",
+    "CommunityOutput",
+]

src/srt/modules/ben.py

@@ -0,0 +1,71 @@
+"""Bifurcation Estimation Network (BEN).
+
+Estimates the reflexivity coefficient r̂ ∈ [-1, 1] at each position from
+the RRM's accumulated meta-state.  Also classifies semiotic regime:
+  - Subcritical (r < 0): sign has stable, conventional meaning
+  - Supercritical (r > 0): sign is contested, meaning is actively forking
+
+r̂ is the core output of SRT — it tells you WHERE and HOW MUCH meaning
+is under contestation in a given text.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+
+from srt.config import BENConfig
+
+
+@dataclass
+class BENOutput:
+    """Output from BEN."""
+
+    r_hat: torch.Tensor  # (B, T) reflexivity coefficient (unbounded; supervised on log-compressed r_true)
+    regime_logits: torch.Tensor  # (B, T, 2) subcritical/supercritical
+
+
+class BifurcationEstimationNetwork(nn.Module):
+    """Estimates bifurcation from RRM meta-state."""
+
+    def __init__(self, cfg: BENConfig, d_meta: int) -> None:
+        super().__init__()
+
+        # r̂ prediction: meta-state → unbounded scalar.
+        # v3 used nn.Tanh() here, which capped output at ±1.  The training target
+        # is sign(r) * log1p(|r|) and r_true reaches ~12.77 (compressed ~2.55), so
+        # the tanh ceiling truncated ~25% of supercritical tokens and capped the
+        # achievable Pearson.  The smooth_l1 loss on a log-compressed target is
+        # numerically well-behaved without an output activation; we keep the head
+        # unbounded and init the final linear with small weights so early outputs
+        # start near zero and the supervised gradient does the shaping.
+        self.r_head = nn.Sequential(
+            nn.Linear(d_meta, cfg.d_hidden),
+            nn.SiLU(),
+            nn.Linear(cfg.d_hidden, 1),
+        )
+        r_out: nn.Linear = self.r_head[-1]  # type: ignore[assignment]
+        nn.init.normal_(r_out.weight, std=0.02)
+        nn.init.zeros_(r_out.bias)
+
+        # Regime classification: subcritical (0) vs supercritical (1)
+        self.regime_head = nn.Sequential(
+            nn.Linear(d_meta, cfg.d_hidden),
+            nn.SiLU(),
+            nn.Linear(cfg.d_hidden, 2),
+        )
+
+    def forward(self, meta_state: torch.Tensor) -> BENOutput:
+        """Estimate bifurcation from accumulated meta-state.
+
+        Args:
+            meta_state: (B, T, d_meta) from RRM.
+
+        Returns:
+            BENOutput with r_hat and regime_logits.
+        """
+        r_hat = self.r_head(meta_state).squeeze(-1)  # (B, T)
+        regime_logits = self.regime_head(meta_state)  # (B, T, 2)
+        return BENOutput(r_hat=r_hat, regime_logits=regime_logits)

src/srt/modules/community.py

@@ -0,0 +1,116 @@
+"""Unsupervised Community Discovery Head.
+
+Discovers discourse communities from backbone hidden states without
+predefined labels.  A discourse community (in Peirce's framework) is a
+group of language users who share interpretive norms — they assign similar
+interpretants to the same representamens.
+
+The community head runs at an early backbone layer (before MAH hooks) and
+produces a soft assignment over K learned prototypes.  The resulting community
+vector conditions how MAH computes divergence, so the same sign can produce
+different divergence patterns in different community contexts.
+
+Training signal: the community prototypes are pulled apart by the semiotic
+losses — if assigning text to different communities helps the model predict
+divergence better, it will learn to separate them.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from srt.config import CommunityConfig
+
+
+@dataclass
+class CommunityOutput:
+    """Output from community discovery.
+
+    When the head runs in continuous-trajectory mode (cfg.use_prototypes=False,
+    v8a), `logits` and `weights` are None and `vector == encoded`.
+    """
+
+    logits: torch.Tensor | None  # (B, K) raw assignment scores, or None
+    weights: torch.Tensor | None  # (B, K) soft assignment probabilities, or None
+    vector: torch.Tensor  # (B, d_community) community embedding (mixture or encoded)
+    encoded: torch.Tensor  # (B, d_community) pre-prototype-mixing encoder output
+
+
+class CommunityDiscoveryHead(nn.Module):
+    """Soft clustering of hidden states into discourse communities.
+
+    With cfg.use_prototypes=True (default): pooled hidden state → encoder →
+    cosine similarity to K learned prototypes → soft assignment weights →
+    weighted mixture of prototypes as the community vector. This is the
+    v3–v7 architecture.
+
+    With cfg.use_prototypes=False (v8a): pooled hidden state → encoder →
+    the encoder output IS the community vector. No discrete basis. Motivated
+    by the v7 PCA finding that prototype tensors barely move from random
+    init; the encoder was already doing the discriminative work and the
+    soft-argmax over K anchors was throwing information away.
+    """
+
+    def __init__(self, cfg: CommunityConfig, d_backbone: int) -> None:
+        super().__init__()
+        self.temperature = cfg.temperature
+        self.use_prototypes = cfg.use_prototypes
+
+        # Encode pooled hidden states → community space
+        self.encoder = nn.Sequential(
+            nn.Linear(d_backbone, cfg.d_community),
+            nn.SiLU(),
+        )
+
+        # Learnable community prototypes (only when enabled)
+        if cfg.use_prototypes:
+            self.prototypes = nn.Embedding(cfg.num_prototypes, cfg.d_community)
+        else:
+            self.prototypes = None  # type: ignore[assignment]
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+    ) -> CommunityOutput:
+        """Discover community from hidden states.
+
+        Args:
+            hidden_states: (B, T, d_backbone) from an early backbone layer.
+            attention_mask: (B, T) padding mask (1 = real, 0 = pad). Optional.
+
+        Returns:
+            CommunityOutput. In prototype mode, logits/weights are populated
+            and vector is the prototype-weighted mixture. In trajectory mode
+            (use_prototypes=False), logits and weights are None and vector
+            equals encoded.
+        """
+        # Masked mean pool across positions → document-level representation
+        if attention_mask is not None:
+            mask = attention_mask.unsqueeze(-1).to(hidden_states.dtype)  # (B, T, 1)
+            pooled = (hidden_states * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1)
+        else:
+            pooled = hidden_states.mean(dim=1)  # (B, d_backbone)
+        encoded = self.encoder(pooled)  # (B, d_community)
+
+        if not self.use_prototypes:
+            # v8a: continuous-trajectory mode — no discrete basis.
+            return CommunityOutput(
+                logits=None, weights=None, vector=encoded, encoded=encoded,
+            )
+
+        # Cosine similarity to prototypes
+        encoded_norm = F.normalize(encoded, dim=-1)
+        proto_norm = F.normalize(self.prototypes.weight, dim=-1)
+        logits = (encoded_norm @ proto_norm.T) / self.temperature  # (B, K)
+
+        weights = F.softmax(logits, dim=-1)  # (B, K)
+        vector = weights @ self.prototypes.weight  # (B, d_community)
+
+        return CommunityOutput(
+            logits=logits, weights=weights, vector=vector, encoded=encoded,
+        )

src/srt/modules/mah.py

@@ -0,0 +1,109 @@
+"""Metapragmatic Attention Head (MAH).
+
+Detects where meaning diverges across positions by computing the gap between
+direct (local) interpretation and contextual (global) interpretation of each
+token's hidden state.  This is Peirce's "unlimited semiosis" made computational:
+each sign (representamen) receives an interpretation (interpretant) that depends
+on the surrounding discourse context.  MAH quantifies where that context
+*changes* the interpretation — i.e., where meaning forks.
+
+The divergence vector d_t at position t captures:
+  d_t = f(interp_t) - g(attend(interp_{0..t}))
+where f is direct projection, g is the contextual output after causal attention.
+High ||d_t|| → the sign at position t means something different in context
+than it would in isolation.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from srt.config import MAHConfig
+
+
+@dataclass
+class MAHOutput:
+    """Output from a single MAH layer."""
+
+    divergence: torch.Tensor  # (B, T, d_divergence)
+    attention_weights: torch.Tensor | None = None  # (B, H, T, T)
+
+
+class MetapragmaticAttentionHead(nn.Module):
+    """Single MAH layer that reads hidden states and produces divergence vectors."""
+
+    def __init__(self, cfg: MAHConfig, d_backbone: int, d_community: int = 0) -> None:
+        super().__init__()
+        d_sub = cfg.d_sub
+
+        # Project backbone hidden states → interpretant subspace
+        self.interp_proj = nn.Linear(d_backbone, d_sub, bias=False)
+
+        # Optional community conditioning
+        self.comm_proj: nn.Module | None = None
+        if d_community > 0:
+            self.comm_proj = nn.Linear(d_community, d_sub, bias=False)
+
+        # Multi-head self-attention in interpretant subspace
+        self.num_heads = cfg.num_heads
+        self.head_dim = d_sub // cfg.num_heads
+        assert d_sub % cfg.num_heads == 0
+
+        self.q_proj = nn.Linear(d_sub, d_sub, bias=False)
+        self.k_proj = nn.Linear(d_sub, d_sub, bias=False)
+        self.v_proj = nn.Linear(d_sub, d_sub, bias=False)
+        self.out_proj = nn.Linear(d_sub, d_sub, bias=False)
+        self.attn_dropout = nn.Dropout(cfg.dropout)
+
+        # Divergence output projection
+        self.div_proj = nn.Linear(d_sub, cfg.d_divergence, bias=False)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        community_vec: torch.Tensor | None = None,
+        causal_mask: torch.Tensor | None = None,
+    ) -> MAHOutput:
+        """Compute divergence from backbone hidden states.
+
+        Args:
+            hidden_states: (B, T, d_backbone) from a transformer layer.
+            community_vec: (B, d_community) soft community vector.
+            causal_mask: (1, 1, T, T) additive causal mask.
+
+        Returns:
+            MAHOutput with divergence vectors and optional attention weights.
+        """
+        B, T, _ = hidden_states.shape
+
+        # Project to interpretant subspace
+        interp = self.interp_proj(hidden_states)  # (B, T, d_sub)
+
+        # Community conditioning: shift interpretant space
+        if community_vec is not None and self.comm_proj is not None:
+            comm_bias = self.comm_proj(community_vec)  # (B, d_sub)
+            interp = interp + comm_bias.unsqueeze(1)
+
+        # Multi-head causal self-attention
+        q = self.q_proj(interp).view(B, T, self.num_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(interp).view(B, T, self.num_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(interp).view(B, T, self.num_heads, self.head_dim).transpose(1, 2)
+
+        attn = (q @ k.transpose(-2, -1)) / math.sqrt(self.head_dim)
+        if causal_mask is not None:
+            attn = attn + causal_mask
+        attn_weights = F.softmax(attn, dim=-1)
+        attn_weights = self.attn_dropout(attn_weights)
+
+        contextual = (attn_weights @ v).transpose(1, 2).reshape(B, T, -1)
+        contextual = self.out_proj(contextual)  # (B, T, d_sub)
+
+        # Divergence = gap between direct and contextual interpretation
+        divergence = self.div_proj(interp - contextual)  # (B, T, d_divergence)
+
+        return MAHOutput(divergence=divergence, attention_weights=attn_weights.detach())

src/srt/modules/rrm.py

@@ -0,0 +1,109 @@
+"""Reflexive Recurrent Module (RRM).
+
+Tracks per-position semiotic meta-state via a GRU that processes divergence
+observations from MAH layers.  At injection points, produces a FiLM-style
+modulation (gamma, beta) that multiplicatively + additively biases the
+backbone's hidden states:
+
+    h' = h * (1 + gamma(meta_state)) + beta(meta_state)
+
+The meta-state h_meta_t represents the model's accumulated awareness of
+semiotic divergence at position t.  Each MAH observation updates it:
+    h_meta_t^{l+1} = GRU(divergence_t^l, h_meta_t^l)
+
+v3 used a single low-rank linear inject (gate * proj * scale) with
+zero-initialized projection.  Ablation showed the inject-back arm contributed
+exactly nothing (every benchmark metric was identical to four decimal places
+with injection forced to zero).  The diagnosis was that the zero init plus
+the inject-norm regularizer (which rewarded ||inj|| \u2248 1 regardless of
+direction) drove the optimizer to satisfy the norm penalty with arbitrary
+directions that were then orthogonal to the gradient signal from the frozen
+backbone's CE.
+
+v4 fixes both: FiLM modulation has a non-zero gradient pathway from the first
+step (beta is initialized to zero so the forward is identity at init, but
+gamma has small Gaussian init so dL/d(gamma_proj) flows immediately when the
+downstream MAH layer's divergence is supervised by the bif/regime losses).
+The inject-norm regularizer is dropped at the loss layer (LossConfig
+inject_reg_weight = 0.0 by default in v4).
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+from srt.config import RRMConfig
+
+
+class ReflexiveRecurrentModule(nn.Module):
+    """GRU-based reflexive meta-state tracker with FiLM-style injection."""
+
+    def __init__(self, cfg: RRMConfig, d_divergence: int, d_backbone: int) -> None:
+        super().__init__()
+        self.d_meta = cfg.d_meta
+        self.inject_scale = cfg.inject_scale
+        self.d_backbone = d_backbone
+
+        # Per-position GRU: processes divergence \u2192 meta-state
+        self.gru = nn.GRUCell(d_divergence, cfg.d_meta)
+
+        # FiLM projections: meta-state \u2192 (gamma, beta) in backbone-dim.
+        # gamma is multiplicative on (1 + gamma); beta is additive.
+        # gamma init: small Gaussian (std=0.02) so identity-at-init holds in
+        # expectation but gradient flows from the first step.
+        # beta init: zeros so identity-at-init is exact, then learns offsets.
+        self.gamma_proj = nn.Linear(cfg.d_meta, d_backbone, bias=True)
+        self.beta_proj = nn.Linear(cfg.d_meta, d_backbone, bias=True)
+        nn.init.normal_(self.gamma_proj.weight, std=0.02)
+        nn.init.zeros_(self.gamma_proj.bias)
+        nn.init.zeros_(self.beta_proj.weight)
+        nn.init.zeros_(self.beta_proj.bias)
+
+    def step(
+        self, divergence: torch.Tensor, meta_state: torch.Tensor | None
+    ) -> torch.Tensor:
+        """Update per-position meta-state with new divergence observation.
+
+        Args:
+            divergence: (B, T, d_divergence) from MAH.
+            meta_state: (B, T, d_meta) or None for initial state.
+
+        Returns:
+            Updated meta-state (B, T, d_meta).
+        """
+        B, T, d_div = divergence.shape
+        div_flat = divergence.reshape(B * T, d_div)
+
+        if meta_state is None:
+            meta_flat = torch.zeros(
+                B * T, self.d_meta, device=divergence.device, dtype=divergence.dtype
+            )
+        else:
+            meta_flat = meta_state.reshape(B * T, self.d_meta)
+
+        meta_flat = self.gru(div_flat, meta_flat)
+        return meta_flat.reshape(B, T, self.d_meta)
+
+    def inject(
+        self, meta_state: torch.Tensor, hidden_states: torch.Tensor
+    ) -> torch.Tensor:
+        """Produce FiLM modulation correction for backbone hidden states.
+
+        Returns the *correction*  (h' - h) = h * gamma + beta, NOT h'.  The
+        caller adds this to h to get h'.  This keeps the rest of the adapter
+        and the diagnostic logging (injection norm tracking) unchanged: the
+        \"injection\" tensor is still the additive correction applied to h.
+
+        Args:
+            meta_state: (B, T, d_meta) current reflexive awareness.
+            hidden_states: (B, T, d_backbone) current hidden states.
+
+        Returns:
+            Correction vector (B, T, d_backbone) to add to hidden_states.
+        """
+        gamma = self.gamma_proj(meta_state)  # (B, T, d_backbone)
+        beta = self.beta_proj(meta_state)  # (B, T, d_backbone)
+        # FiLM: h' = h * (1 + gamma) + beta  \u2192  correction = h * gamma + beta
+        correction = hidden_states * gamma + beta
+        return correction * self.inject_scale