deepnsm: address PR #479 review — coref-keyed cam64, expectation lifecycle, P64 dedup

Three findings from codex + CodeRabbit on PR #479:

1. (codex P2, reader_state.rs) Build Cam64 from the resolved subject.
   For "John … He …", effective_subject was the antecedent but Cam64 was
   built from the raw pronoun triple, so cam64/P64/CAM4096 keyed to the
   pronoun bucket while truth fields pointed at John — downstream locality
   lookup and basin matching used the wrong entity. Now constructs an
   effective triple (subject = resolved antecedent) before from_triple().
   No-op when there is no coreference. The code now matches the comment
   that already promised "use the effective triple (post-coref)".
   Test: cam64_keyed_to_resolved_antecedent_not_pronoun.

2. (codex P2, window.rs) Clear consumed expectations.
   Forward-expectation slots were never drained, so across several
   relative/anaphora clauses they accumulated to MAX_EXPECTED (4), after
   which push_expected silently dropped newer antecedents and stale
   expectations could win over the confirmed ring. step() now clears the
   expectation buffer at the start of each sentence (expectations are
   single-step predictions), bounding it permanently.
   Test: expectations_do_not_accumulate_across_sentences.

3. (CodeRabbit, sentence_transformer64.rs) P64 duplicated P64MeaningField.
   Both were byte-identical 8-lane u64 meaning fields. Consolidated:
   P64 (the richer superset) is now canonical; signed_crystal re-exports
   `pub use crate::sentence_transformer64::P64 as P64MeaningField`. Removes
   drift risk. Behaviour-preserving (both from_cam64_and_nsm were identical).

Also removed three now-unused imports surfaced by the consolidation
(NO_ROLE in signed_crystal; MorphFlags + SpoTriple in sentence_transformer64).

217 deepnsm tests pass (was 215; +2 new regression tests).

https://claude.ai/code/session_0147hSzjmWZDuy2MSQNrhEK5

Author: claude

crates/deepnsm/src/reader_state.rs

@@ -39,6 +39,7 @@ use crate::episodic_spo::{
 use crate::morphology::MorphFlags;
 use crate::parser::SentenceStructure;
 use crate::pos::PoS;
+use crate::spo::SpoTriple;
 use crate::window::{ExpectedReason, SentenceWindow, WindowEntry};
 
 // ── Left-corner trigger ───────────────────────────────────────────────────
@@ -226,6 +227,12 @@ impl ReadingState {
             return (frames, next);
         }
 
+        // Forward expectations are single-step predictions: each `step` rebuilds
+        // them fresh. Clearing here bounds the expectation buffer (it can never
+        // accumulate stale slots across sentences until `MAX_EXPECTED` fills and
+        // `push_expected` silently drops newer antecedents).
+        next.window.clear_expected();
+
         // Left-corner trigger from the first triple's features sets the frame.
         let first_feat = features.get(0);
         next.active_trigger = first_feat.left_corner_trigger;
@@ -286,11 +293,17 @@ impl ReadingState {
             };
 
             // ── Build Cam64 locality code ────────────────────────────────
-            // Use the effective triple (post-coref) for the entity bucket.
-            // The basin lane incorporates the left-corner trigger.
+            // Build from the EFFECTIVE triple (subject replaced by the resolved
+            // antecedent) so the locality key, P64, and CAM4096 are keyed to the
+            // real entity. Otherwise "John … He …" emits a frame whose truth
+            // fields point at John but whose cam64 is bucketed on the pronoun.
+            // When there is no coreference, effective_subject == triple.subject()
+            // so this is a no-op.
+            let effective_triple =
+                SpoTriple::new(effective_subject, triple.predicate(), triple.object());
             let stack_depth = next.entity_stack_len.min(127) as u8;
             let base_cam64 = Cam64::from_triple(
-                triple,
+                &effective_triple,
                 morph,
                 stack_depth,
                 coref_resolved,
@@ -423,7 +436,6 @@ impl ReadingState {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::spo::SpoTriple;
 
     fn sentence_one_triple(s: u16, p: u16, o: u16) -> SentenceStructure {
         SentenceStructure {
@@ -628,4 +640,55 @@ mod tests {
         assert_eq!(frames[0].refers_to_candidate_id, 50);
         assert_eq!(frames[0].subject_candidate_id, 50);
     }
+
+    #[test]
+    fn cam64_keyed_to_resolved_antecedent_not_pronoun() {
+        // "John(70) ... He(5) ...": the frame's cam64 entity lane must bucket
+        // the resolved antecedent (70), NOT the pronoun rank (5).
+        let rs = ReadingState::new(0);
+        let s1 = sentence_one_triple(50, 60, 70); // most-recent head = 70
+        let (_, rs2) = rs.step(&s1, &plain_features());
+
+        let s2 = sentence_one_triple(5, 80, 90); // subject is a pronoun
+        let feat = SentenceFeatures {
+            per_triple: vec![TripleFeatures {
+                subject_is_pronoun: true,
+                ..Default::default()
+            }],
+        };
+        let (frames, _) = rs2.step(&s2, &feat);
+        // Resolved antecedent is 70 (most recent prior head).
+        assert_eq!(frames[0].subject_candidate_id, 70);
+        // Entity lane must be bucketed on 70, not on the pronoun rank 5.
+        assert_eq!(frames[0].cam64.entity_state(), (70u16 >> 5) as u8);
+        assert_ne!(frames[0].cam64.entity_state(), (5u16 >> 5) as u8);
+    }
+
+    #[test]
+    fn expectations_do_not_accumulate_across_sentences() {
+        // Many consecutive Relative-trigger sentences must NOT fill the
+        // expectation buffer and silently drop newer antecedents: each step
+        // clears stale slots first, so the most recent antecedent always wins.
+        let mut rs = ReadingState::new(0);
+        // Prime an initial subject.
+        let (_, next) = rs.step(&sentence_one_triple(1000, 1, 2), &plain_features());
+        rs = next;
+
+        // Run 8 relative-trigger sentences (> MAX_EXPECTED = 4).
+        for i in 0..8u16 {
+            let subj = 2000 + i * 10;
+            let s = sentence_one_triple(subj, 1, 2);
+            let feat = SentenceFeatures {
+                per_triple: vec![TripleFeatures {
+                    left_corner_trigger: LeftCornerTrigger::Relative,
+                    ..Default::default()
+                }],
+            };
+            let (_, next) = rs.step(&s, &feat);
+            rs = next;
+            // After each step the buffer holds exactly this step's single
+            // expectation — never accumulating toward the MAX_EXPECTED drop point.
+            assert_eq!(rs.window.iter_expected().len(), 1);
+        }
+    }
 }

crates/deepnsm/src/sentence_transformer64.rs

@@ -80,8 +80,7 @@
 
 use crate::cam64::Cam64;
 use crate::episodic_spo::{DependencyRole, EpisodicSpoFrame};
-use crate::morphology::MorphFlags;
-use crate::spo::{SpoTriple, NO_ROLE};
+use crate::spo::NO_ROLE;
 
 // ── P64 ──────────────────────────────────────────────────────────────────────
 

crates/deepnsm/src/signed_crystal.rs

@@ -58,7 +58,6 @@
 //! fused without an explicit projection step.
 
 use crate::cam64::Cam64;
-use crate::spo::NO_ROLE;
 
 // ── HorizonPolarity (v2 stub) ─────────────────────────────────────────────────
 
@@ -282,84 +281,22 @@ impl Crystal4096 {
     }
 }
 
-// ── P64MeaningField ───────────────────────────────────────────────────────────
+// ── P64MeaningField (alias of the canonical P64) ───────────────────────────────
 
 /// 8-lane grammar/semantic/discourse meaning field.
 ///
-/// Derived from `Cam64` + NSM prime mask, this is the *meaning-field projection*
-/// — the composite signal that summarises what this sentence is *about*, in the
-/// grammar of the reading state machine.
+/// **This is an alias of [`crate::sentence_transformer64::P64`]** — the single
+/// canonical meaning-field type. The two were introduced separately but are
+/// byte-identical (8-lane `u64`, `from_cam64_and_nsm` / `lane` / `bind` /
+/// `agreement` / `popcount` / `raw`); consolidating removes the drift risk of
+/// maintaining two copies.
 ///
-/// **`P64MeaningField` is NOT `Cam64`.** `Cam64` is a reading-state locality key
-/// (fast index, not truth). `P64MeaningField` is the output of the DeepNSM
-/// grammar lens onto the P64 meaning lattice — a different interpretive layer.
-///
-/// Lane layout (same physical encoding as Cam64 but different semantic contract):
-/// ```text
-/// byte 0 — primary entity bucket  (vocabulary rank >> 5)
-/// byte 1 — predicate bucket
-/// byte 2 — object bucket (0 if absent)
-/// byte 3 — morphology / NSM prime composite (low byte)
-/// byte 4 — NSM prime composite (high byte, top-16 primes)
-/// byte 5 — discourse / coreference marker
-/// byte 6 — causal / temporal / episodic marker
-/// byte 7 — basin / novelty / wisdom / epiphany marker
-/// ```
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct P64MeaningField {
-    pub bits: u64,
-}
-
-impl P64MeaningField {
-    /// Construct from a `Cam64` locality code and the NSM prime mask.
-    ///
-    /// The NSM prime mask (64-bit, up to 63 primes) is folded into lanes 3-4
-    /// via XOR — this makes the meaning field sensitive to semantic prime
-    /// coverage without losing the grammar-lane signals.
-    #[inline]
-    pub fn from_cam64_and_nsm(cam: Cam64, nsm_prime_mask: u64) -> Self {
-        // Fold low 16 bits of NSM mask into lanes 3-4 (the morphology lanes).
-        let nsm_low  = (nsm_prime_mask & 0xFF) as u64;
-        let nsm_high = ((nsm_prime_mask >> 8) & 0xFF) as u64;
-        let nsm_xor  = nsm_low | (nsm_high << 8); // into bits 24-39
-
-        Self {
-            bits: cam.raw() ^ (nsm_xor << 24),
-        }
-    }
-
-    /// Extract one meaning-field lane (0-7).
-    #[inline]
-    pub fn lane(self, i: usize) -> u8 {
-        debug_assert!(i < 8);
-        (self.bits >> (i * 8)) as u8
-    }
-
-    /// XOR bind with another meaning field (VSA binding).
-    #[inline]
-    pub fn bind(self, other: P64MeaningField) -> P64MeaningField {
-        P64MeaningField { bits: self.bits ^ other.bits }
-    }
-
-    /// Popcount — number of active bits in the meaning field.
-    #[inline]
-    pub fn popcount(self) -> u32 {
-        self.bits.count_ones()
-    }
-
-    /// Shared bits with another field (XNOR popcount = agreement measure).
-    #[inline]
-    pub fn agreement(self, other: P64MeaningField) -> u32 {
-        64 - (self.bits ^ other.bits).count_ones()
-    }
-
-    /// Raw u64.
-    #[inline]
-    pub fn raw(self) -> u64 {
-        self.bits
-    }
-}
+/// The name `P64MeaningField` is retained here because the holograph-bridge
+/// framing in this module reads more clearly with the longer name: it is the
+/// *meaning-field projection* (what the sentence is *about*), distinct from
+/// `Cam64` (a reading-state locality key, not truth). Same bits, different
+/// interpretive contract.
+pub use crate::sentence_transformer64::P64 as P64MeaningField;
 
 // ── SignedSentenceCrystal ─────────────────────────────────────────────────────
 

docs/architecture/deepnsm-reader-design.md

@@ -259,12 +259,12 @@ FORBIDDEN INTERNAL PATH (absent by omission):
 | `cam64` | 13 (5 new: basin continuation) |
 | `episodic_spo` | 8 |
 | `window` | 11 (6 new: expectation slots) |
-| `reader_state` | 12 (2 new: trigger wiring) |
-| `signed_crystal` | 18 |
+| `reader_state` | 14 (4 new: trigger wiring + coref-keyed cam64 + no expectation accumulation) |
+| `signed_crystal` | 18 (`P64MeaningField` is now an alias of the canonical `P64`) |
 | `sentence_transformer64` | 26 |
 | `crystal_neighborhood` | 16 |
 | **Existing deepnsm tests** | 104 (unchanged) |
-| **Total** | **215** |
+| **Total** | **217** |
 
 ---