From 99c11f3b43482a3102aefdf8dc770698d488a419 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 12 Jul 2026 20:37:39 +0000 Subject: [PATCH 1/6] =?UTF-8?q?board:=20chess-arc=20=E2=86=92=20V3=20muscl?= =?UTF-8?q?e-memory=20transfer=20=E2=80=94=204=20validations=20+=20D-EPIPH?= =?UTF-8?q?ANY-SIG-1=20(Hambly-Lyons=20epiphany=20detector,=20probe-gated)?= =?UTF-8?q?=20+=20rejected=20rhymes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .claude/board/AGENT_LOG.md | 6 ++++++ .claude/board/EPIPHANIES.md | 29 +++++++++++++++++++++++++++++ .claude/v3/FUTURE-DESIGN.md | 1 + 3 files changed, 36 insertions(+) diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index bf565996..df45436a 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,9 @@ +## 2026-07-12 — chess-arc-v3-transfer-carve — E-CHESS-ARC-TO-V3-TRANSFER-1 distilled (4 validations + D-EPIPHANY-SIG-1 probe-gated + 3 rejected rhymes) + +- **Deliverable:** `EPIPHANIES.md` `E-CHESS-ARC-TO-V3-TRANSFER-1` — chess-signature arc (`E-CHESS-SIGNATURE-ARC-1`) distilled into V3 muscle memory: 4 validations of already-ruled directions + 1 novel probe-gated method (D-EPIPHANY-SIG-1, Hambly–Lyons epiphany-vs-rumination detector) + 3 rejected rhymes named explicitly. +- **Board:** EPIPHANIES prepended; FUTURE-DESIGN.md wiring-queue bullet added (D-EPIPHANY-SIG-1). +- **Outcome:** distillation carved, rides PR #687. No code changed (doc-only). + ## 2026-07-12 — stockfish-wave3-fleet — chess-signature arc capstone: no-hindsight GREEN, needle 9.70×, personality 98% inter, Turk-Polson substrate in-tree - **Fleet:** Sonnet workers for D-SF-HINDSIGHT-1, PERSONALITY-1..4, BLITZ-1, SIGNATURE-1, NEEDLE-1 (CHAODA) + temporal-test worker (lance-graph-planner) + this doc applier. diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index ad2d04f7..e5f054c4 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,32 @@ +## 2026-07-12 — E-CHESS-ARC-TO-V3-TRANSFER-1 — the chess-signature arc distilled into V3 muscle memory (4 validations + 1 probe-gated method + 3 rejected rhymes) + +**Status:** SYNTHESIS (distillation of E-CHESS-SIGNATURE-ARC-1; grades explicit; the novel method is CONJECTURE, probe-gated). +**Frame:** the chess arc was a probe of THINKING itself (identity, adaptation, hindsight, epiphany, the rare belief-update). What transfers to the V3 substrate, graded mechanism-vs-rhyme: + +**Four validations of already-ruled V3 directions (chess arc supplied the evidence):** + +1. **Identity is a response-function, not a stored trait [H, strong].** Personality measured 98% INTER (opponent-driven) / 2% INTRA (trait) — a constant-vector model mis-specifies it. This IS the mailbox-as-owner / no-singleton ruling (cognition = dispatch-response-to-casts, `E-MAILBOX-KANBAN-NO-COLLAPSEGATE`), measured: a stored-BindSpace-singleton would have been the 2% model; the response-to-casts substrate is the correctly-specified one. The aggregate chess negatives (~1.3×) are the empirical cost of the architecture V3 already rejected. + +2. **The temporal rung IS the learning-strategy dial [G enforcement / H framing].** D-SF-HINDSIGHT-1 proved `TemporalPov::at(v, Strict)` enforces zero future-ply access (0/521,630 reads). So `temporal.rs`'s Strict/Aware/Retro rungs are not only a read-coherence selector (INTEGRATION-PLAN Addendum-8) — they are a LEARNING-REGIME selector: Strict = causal/online (no leak), Retro = hindsight/credit-assignment. The rung chooses whether a NARS revision pass may see the settled outcome. Muscle-memory addition to the WAL-read ruling; no new mechanism. + +3. **Episodic basins and signature moments need DIFFERENT storage [H].** Basins (the recurring `part_of:is_a` rails, le-contract L1–L3) are averaged context — and the MEAN does not identify (comfort-basin probe 1.1×). Signature moments (rare tail) carry identity (delayed-gratification-sac rate 9.70×) and must be preserved INDIVIDUALLY, not bundled into the rail. Rule: bundle the basin, anomaly-detect-and-preserve the signature. Refines the memory model; does not replace it. + +4. **When the signal is a rare event, bundling destroys it [G].** A mean's SNR is bounded by the event rate; a ~1% needle cannot survive averaging (measured: every averaged probe ~1.1–1.3×). I-VSA-IDENTITIES / CollapseGate discipline stated as a detection rule: `MergeMode::Bundle` is right for the Markov-context basin, WRONG for the discriminating rare event — route the needle to anomaly detection (ndarray CLAM/CHAODA), never into the bundle. + +**The standout — one genuinely new, probe-gated method [H / CONJECTURE]:** + +**D-EPIPHANY-SIG-1 — Hambly–Lyons as an epiphany-vs-rumination detector for NARS reasoning.** Hambly–Lyons (jc pillar #11): a path's signature is trivial IFF the path is tree-like (a detour-and-return collapsing to its start). Map onto a thinking trajectory (the `Think` struct's path over a cycle: `FreeEnergy` F descending, `awareness` divergence, contradiction-depth): +- RUMINATION = out-and-back — F oscillates, no belief net-moves — path is tree-like — signature ≈ identity, Lévy area ≈ 0. +- EPIPHANY = area swept — F net-descends, a Contradiction commits, awareness revises — path non-tree-like — signature ≠ identity, Lévy area ≠ 0. +So the LÉVY AREA of the belief-trajectory is a principled "did this reasoning actually update anything" test — the operator's `epiphany-detection ↔ NARS reasoning` link. A NARS revision that returns a belief to its prior conveys no net information (tree-like); one that displaces it sweeps area. Every piece is in-tree: `sigker::signature_truncated` (signature) + `jc/hambly_lyons` (certificate) + the `Think`/`FreeEnergy`/NARS model + `temporal.rs` (the stream the path rides). **Probe (probe-first, mechanism lands after its failing probe):** take recorded Think cycles labeled epiphany (ΔF<0.05, both-triples-commit) vs rumination (F oscillates, no commit), compute the depth-2 signature of the `(ΔF, awareness-divergence, contradiction-depth)` path, test whether the Lévy area / signature norm separates them ≥2× a shuffled-order control. Stays [H] until it runs. Caveat: use `sigker::signature_kernel`, never `signature_kernel_pde` (jc-flagged bug). + +**Three rejected rhymes (anti-dilution — do NOT build):** +- ✗ "the perturbation shader IS the signature transform" — the shader is VSA bind+braid+bundle; the signature is iterated integrals; different algebras. Braiding-by-position rhymes with order-encoding but is [S], do-not-build until measured. +- ✗ "personality = the QualiaColumn" — a rhyme; do not force the 18×f32 to carry it. +- ✗ treating the ~1.3× aggregate results as "signal" — they are the honest null; never launder them into canon as a win. + +**Cross-ref:** E-CHESS-SIGNATURE-ARC-1 (the arc); INTEGRATION-PLAN Addendum-8 (temporal rungs); `E-MAILBOX-KANBAN-NO-COLLAPSEGATE`; I-VSA-IDENTITIES; jc pillar #11 (`hambly_lyons.rs`); `.claude/v3/FUTURE-DESIGN.md` (D-EPIPHANY-SIG-1 queued to the thinking-engine gem wiring queue). + ## 2026-07-12 — E-CHESS-SIGNATURE-ARC-1 — personality is the opponent-response function (inter 98% / intra 2%); Turk-Polson substrate already in-tree **Status:** MEASURED (stockfish-rs `79ce78f`/`57ae59f`/`654a605`/`2c54e1a`/`64b8aa3`/`5d74b6c`/`2f73686`/`fa7beff`; lance-graph `505b989e`). diff --git a/.claude/v3/FUTURE-DESIGN.md b/.claude/v3/FUTURE-DESIGN.md index 180d0f27..649c0d8a 100644 --- a/.claude/v3/FUTURE-DESIGN.md +++ b/.claude/v3/FUTURE-DESIGN.md @@ -79,6 +79,7 @@ wiring; some are calibration-only by design): - `domino.rs` / `composite_engine.rs` / `dual_engine.rs` — M8's collapse surface (4 near-duplicate engines → one dispatched engine). - `l4_bridge.rs` / `tensor_bridge.rs` — the L4 learning-loop seam (W4b). +- **D-EPIPHANY-SIG-1 (queued, [H]/CONJECTURE)** — Hambly–Lyons epiphany-vs-rumination detector: the Lévy area of the `Think` belief-trajectory signature distinguishes real belief-update (non-tree, area swept) from circular rumination (tree-like, collapses). In-tree parts: `sigker` + `jc/hambly_lyons` + `Think`/NARS + `temporal.rs`. Probe-gated; full text EPIPHANIES `E-CHESS-ARC-TO-V3-TRANSFER-1`. **Standing constraint:** the value-tenant migration is MID-FLIGHT (10 lanes, `ENVELOPE_LAYOUT_VERSION=2`, BoardAggregates gated on the batched mint + From b9ae704e1274b3ca0a97d395b6fcde36c8341a45 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 12 Jul 2026 20:53:30 +0000 Subject: [PATCH 2/6] =?UTF-8?q?plan+board:=20chess-arc=20evidence=20layer?= =?UTF-8?q?=20under=20the=20temporal-markov=20spine=20=E2=80=94=206=20grad?= =?UTF-8?q?ed=20mappings=20(sender=E2=86=92receiver=3Dedge,=20wave=3Dstrea?= =?UTF-8?q?m,=20basins=20ground/wave=20identifies)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .claude/board/AGENT_LOG.md | 6 ++ .claude/board/EPIPHANIES.md | 6 ++ .../temporal-markov-and-style-classes-v1.md | 80 +++++++++++++++++++ 3 files changed, 92 insertions(+) diff --git a/.claude/board/AGENT_LOG.md b/.claude/board/AGENT_LOG.md index df45436a..52479094 100644 --- a/.claude/board/AGENT_LOG.md +++ b/.claude/board/AGENT_LOG.md @@ -1,3 +1,9 @@ +## 2026-07-12 — chess-arc-spine-evidence-carve — E-THINKING-SPINE-CHESS-EVIDENCE-1 + temporal-markov plan addendum + +- **Deliverable:** `.claude/plans/temporal-markov-and-style-classes-v1.md` addendum (6 graded mappings of the chess arc onto Track A/B) + `EPIPHANIES.md` `E-THINKING-SPINE-CHESS-EVIDENCE-1` pointer entry. +- **Board:** plan file appended; EPIPHANIES prepended. +- **Outcome:** evidence-layer carve, no ruling changed (1 conjecture flagged [S] un-run, 1 probe-gated [H]). Rides PR #687. No code changed (doc-only). + ## 2026-07-12 — chess-arc-v3-transfer-carve — E-CHESS-ARC-TO-V3-TRANSFER-1 distilled (4 validations + D-EPIPHANY-SIG-1 probe-gated + 3 rejected rhymes) - **Deliverable:** `EPIPHANIES.md` `E-CHESS-ARC-TO-V3-TRANSFER-1` — chess-signature arc (`E-CHESS-SIGNATURE-ARC-1`) distilled into V3 muscle memory: 4 validations of already-ruled directions + 1 novel probe-gated method (D-EPIPHANY-SIG-1, Hambly–Lyons epiphany-vs-rumination detector) + 3 rejected rhymes named explicitly. diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index e5f054c4..05a1c36a 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,9 @@ +## 2026-07-12 — E-THINKING-SPINE-CHESS-EVIDENCE-1 — chess arc mapped onto the temporal-markov spine (Track A/B evidence layer) + +**Status:** SYNTHESIS (session evidence addendum on `.claude/plans/temporal-markov-and-style-classes-v1.md`; grades explicit; no ruling changed). +**What:** the chess-signature arc is the evidence layer under the ratified cognition spine. Six graded mappings: (1) thinking-is-a-moving-wave = the temporal.rs Markov stream, sigker its featurizer [G/H]; (2) sender→receiver meta-awareness = the CausalEdge/PREDICATE, not the S/O nodes — 98% inter measured [H strong]; (3) basins GROUND / SPO-2³ facts ANCHOR / the WAVE IDENTIFIES (mean 1.1× vs tail 9.70×) [H]; (4) macro/wide-angle vs tele = WideFieldMask-breadth vs version-range-depth [S, D-SF-FILTER un-run — conjecture, not fact]; (5) needle discipline = don't Bundle the rare event, anomaly-detect it [G]; (6) epiphany = non-tree Lévy sweep (D-EPIPHANY-SIG-1) [H probe-gated]. +**Cross-ref:** E-CHESS-SIGNATURE-ARC-1, E-CHESS-ARC-TO-V3-TRANSFER-1, E-MARKOV-TEMPORAL-STREAM-1, the temporal-markov-and-style-classes-v1 addendum (2026-07-12). + ## 2026-07-12 — E-CHESS-ARC-TO-V3-TRANSFER-1 — the chess-signature arc distilled into V3 muscle memory (4 validations + 1 probe-gated method + 3 rejected rhymes) **Status:** SYNTHESIS (distillation of E-CHESS-SIGNATURE-ARC-1; grades explicit; the novel method is CONJECTURE, probe-gated). diff --git a/.claude/plans/temporal-markov-and-style-classes-v1.md b/.claude/plans/temporal-markov-and-style-classes-v1.md index ad9a6787..e668ba6e 100644 --- a/.claude/plans/temporal-markov-and-style-classes-v1.md +++ b/.claude/plans/temporal-markov-and-style-classes-v1.md @@ -139,3 +139,83 @@ explicit `on_behalf` (owner ≠ classid, rs-graph-llm `8ef18b9`). |---|---|---| | D-ORG-1 | `BatchWriter::ack_and_propose` self-pumping loop + probes | SHIPPED this arc (2 tests green) | | D-ORG-2 | W2c re-scope: symbiont arm = storage/read-glove only | STATUS_BOARD row updated this arc | + +## Addendum (session evidence, 2026-07-12) — the chess-signature arc as the evidence layer under this spine + +NOT a ruling change — session evidence that VALIDATES Track A/B with measured +numbers, plus honestly-graded conjectures. Full arc: EPIPHANIES +`E-CHESS-SIGNATURE-ARC-1`; the V3 transfer + rejected rhymes + the one new +method: `E-CHESS-ARC-TO-V3-TRANSFER-1`. Grades explicit ([G]/[H]/[S]); +probe-first honored. + +**1. Thinking is a moving wave — the wave IS this plan's temporal.rs Markov +stream [G/H].** Turk & Polson, "Chess Signatures of Play" (arXiv 2606.18544, +June 2026), model a game (a thought) as a multivariate PATH; the Lyons +signature is its reparametrization-invariant featurization, discriminating +info in the LÉVY AREAS (order-interaction). This is external evidence FOR +Track A's ruling (`E-MARKOV-TEMPORAL-STREAM-1`): the Markov trajectory lives +on the temporal.rs sorted STREAM, not the VSA braid — because the +discriminating structure is in the wave's ORDER, which means/aggregates +DESTROY. Measured: every averaged chess style-measure landed ~1.1–1.3× +chance; the order-preserving stream is the correct carrier. The workspace +already owns the featurizer: `sigker::signature_truncated` (Chen–Lyons), +certified by jc pillar #11 (`hambly_lyons.rs`) against the exact tree-like- +equivalence uniqueness theorem the paper's identifiability rests on. + +**2. Sender→receiver meta-awareness lives in the PREDICATE (edge), not the +nodes [H, strong].** Chess personality measured **98% INTER (interaction) / +2% INTRA (trait)** — identity is the opponent-response, not a stored vector. +In SPO that is S(self)—**P(interaction)**—O(other): the **CausalEdge / +EdgeColumn (P)** carries the adaptive identity; `FingerprintColumns` (S/O +nodes) carry the ~2% invariant. The mailbox **cast→response IS +sender→receiver**. Consequence for Track B's `WideFieldMask` (which projects +SPO / Pearl 2³ rung set / CausalEdge / qualia over the SoA row): the +**CausalEdge projection is the measured seat of meta-awareness** — weight it +accordingly. This is also why the constant-vector chess probes failed: they +fit an INTRA model to a 98%-INTER process. + +**3. Three reasoning surfaces — and which one carries identity [H].** The +`Think` struct resolves against three tissues; the chess arc measured their +division of labor. **Episodic basins** (`part_of:is_a` rails, le-contract +L1–L3) = averaged CONTEXT — the mean, measured NOT to identify (comfort-basin +probe 1.1×). **SPO 2³ rung-decomposed facts** = what is BELIEVED (Pearl- +laddered; the chess awareness ladder L0-egocentric/L1-perspective/L2-gestalt + +the counterfactual clause ARE Pearl rungs 1/2/3, `E-SF-AWARENESS-OPPONENT-ARC-1`). +**The temporal.rs wave** = the moving TRAJECTORY, where the signature — and +identity — lives (delayed-gratification-sac rate 9.70× reputation-correct, in +the TAIL not the mean). So: **basins GROUND, facts ANCHOR, the WAVE +IDENTIFIES.** Validates Track A third-wave addendum (AriGraph context, +V3-tenant-shaped, essential for Markov context-building) with the sharpening +that the CHAINING (the wave), not the BASIN (the mean), is the discriminating +surface. + +**4. Macro/wide-angle vs tele = WideFieldMask breadth vs version-range depth +[S — CONJECTURE, PROBE UN-RUN].** The spatial wide-angle (attention over the +current SoA row = `WideFieldMask`) vs the temporal tele (k-ply version-range +deinterlace depth, `QueryReference::at(v, rung)`) is a candidate reasoning-mode +dial, RHYMING with NARS breadth-vs-depth inference. **Graded [S]: the chess +D-SF-FILTER probe (spatial-field read vs k-ply rollout read, switched on the +contact/wedge signal) was queued but NEVER RUN** — this is a conjecture, NOT +evidence, and must not calcify as fact. Probe it before wiring. + +**5. The needle discipline for the L4 perturbation shader [G].** When the +discriminating signal is a RARE event, bundling (`CollapseGate +MergeMode::Bundle`, and the L4 palette² shader accumulation) destroys it — a +mean's SNR is bounded by the event rate (a ~1% needle cannot survive +averaging; measured across every aggregate probe). Route the needle to +anomaly-detection (ndarray CLAM/CHAODA); `MergeMode::Bundle` is correct for +the Markov-context BASIN, wrong for the discriminating rare event. This is +I-VSA-IDENTITIES stated as a merge-mode selection rule for the shader. + +**6. Epiphany = non-tree Lévy sweep [H, probe-gated].** D-EPIPHANY-SIG-1 +(carved in `E-CHESS-ARC-TO-V3-TRANSFER-1`): the Lévy area of the `Think` +belief-trajectory signature distinguishes real belief-update (non-tree, area +swept) from circular rumination (tree-like, collapses) — the operator's +`epiphany ↔ NARS` link. In-tree parts: `sigker` + jc/hambly_lyons + Think/NARS ++ temporal.rs. Probe-first; stays [H] until run. Cross-ref, not repeated here. + +**Rejected rhymes (anti-dilution, do NOT build):** ✗ "the perturbation shader +IS the signature transform" (different algebras: VSA bind+braid+bundle vs +iterated integrals — braiding-by-position rhymes with order-encoding but is +[S] until measured); ✗ "personality = the QualiaColumn"; ✗ treating the ~1.3× +aggregate nulls as signal. Full text: `E-CHESS-ARC-TO-V3-TRANSFER-1`. From e83e5f1031060b2613db122a1620226fde5246b6 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 13 Jul 2026 22:54:26 +0000 Subject: [PATCH 3/6] planner: lift the ThinkingStyle compat alias back to thinking:: (D-TSC-1 regression fix) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1a11038 (D-TSC-1) renamed the planner 12-space ThinkingStyle -> StyleFamily and left `#[deprecated] pub type ThinkingStyle = StyleFamily;` in thinking/style.rs "for external compat" — but the same commit dropped ThinkingStyle from the `thinking/mod.rs` re-export (line 22 went from `pub use style::{…, ThinkingStyle}` to `…, StyleFamily`). So the alias was stranded one level down: `thinking::style::ThinkingStyle` resolved, but `thinking::ThinkingStyle` — the natural, pre-existing consumer import path — hard-broke. Not a compat shim; a compat shim I forgot to wire up. Same second-order break for the methods that used to be inherent on the old enum (cluster/tau_address/modulation): they moved onto the `PlannerStyleExt` ext trait, which was only privately `use`d in mod.rs, so `style.cluster()` broke even with the type alias present. Fix: re-export ThinkingStyle at thinking/mod.rs (with `#[allow(deprecated)]` on the re-export line so the crate stays -D warnings clean) and lift PlannerStyleExt via `pub use`. Consumers on the old paths now compile again (with the deprecation warning steering them to StyleFamily) instead of failing outright. `cargo build -p lance-graph-planner` clean, no new warnings (the 2 remaining are pre-existing deprecated-CausalEdge64 calls in nars_engine.rs, untouched). thinking-engine's alias was already at its prior path (cognitive_stack::) so it never broke; #674 audited clean (RESERVE-DON'T-RECLAIM, no stranded alias). Board: EPIPHANIES E-COMPAT-ALIAS-MUST-BE-LIFTED-1. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .claude/board/EPIPHANIES.md | 9 +++++++++ crates/lance-graph-planner/src/thinking/mod.rs | 14 ++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 05a1c36a..77146fc1 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,12 @@ +## 2026-07-13 — E-COMPAT-ALIAS-MUST-BE-LIFTED-1 — a compat alias left in a leaf module but not re-exported at the consumer import path is a hard break, not a shim (D-TSC-1 regression, fixed) + +**Status:** CORRECTION (fixes a real consumer-facing regression shipped in `1a11038` / D-TSC-1; grade [G] — reproduced by compile). +**The break:** D-TSC-1 renamed the planner 12-space `ThinkingStyle` → `StyleFamily` (moved to `lance_graph_contract::style_family`) and left `#[deprecated] pub type ThinkingStyle = StyleFamily;` in `planner thinking/style.rs` "for external compat." But the SAME commit changed `planner thinking/mod.rs` line 22 from `pub use style::{…, ThinkingStyle}` to `pub use style::{…, StyleFamily}` — dropping the re-export. Result: `lance_graph_planner::thinking::style::ThinkingStyle` still resolved, but `lance_graph_planner::thinking::ThinkingStyle` (the natural, pre-existing import path) **hard-broke**. The alias was left in the basement and not lifted back to the floor consumers import from. Same for the methods that were inherent on the old enum (`cluster()`/`tau_address()`/modulation) — they moved to the `PlannerStyleExt` ext trait, which was only privately `use`d in mod.rs, never `pub use`d, so `style.cluster()` broke even with the type alias present. +**The gate gap that let it through:** the D-TSC-1 gate was `G1 grep = 1 enum def + 3 deprecated aliases` — it counted alias **definitions**, never verified they were **reachable from the paths consumers actually import** (module-root re-exports). Counting a `pub type X = Y` in a leaf proves nothing about whether `crate::mod::X` still resolves. +**The rule:** when a rename leaves a compat alias, the alias MUST be re-exported at **every module level the old name was reachable from before** — not just defined in the leaf. A compat-alias gate must assert the old import PATH resolves (`use crate::path::OldName;` compiles), not that an alias token exists somewhere. Extension traits that absorb former inherent methods must be lifted to the same module root as the type, so the consumer fix is one `use …::PlannerStyleExt`, not a hunt into a submodule. +**Fix (this commit):** `planner thinking/mod.rs` re-exports `ThinkingStyle` (with `#[allow(deprecated)]` on the re-export) + lifts `PlannerStyleExt` via `pub use`. `-p lance-graph-planner` builds clean, no new warnings. thinking-engine's alias was already at its pre-existing path (`cognitive_stack::ThinkingStyle`) so it never broke; the driver had no public `ThinkingStyle` type. #674 (node-layout / 4+12 facet) was audited for the same disease and is CLEAN — it followed RESERVE-DON'T-RECLAIM (`NodeGuid::new` still callable, `CLASSID_*_LEGACY` aliases preserved, contract lib.rs change purely additive); its break is doctrinal (migrate mints to `mint_for`), not a stranded-alias compile break. +**Cross-ref:** `1a11038` (the regression), D-TSC-1 spec, I-LEGACY-API-FEATURE-GATED (sibling doctrine — same "backward-compat shims need systematic coverage" spirit, applied to module re-export paths rather than layout bits). + ## 2026-07-12 — E-THINKING-SPINE-CHESS-EVIDENCE-1 — chess arc mapped onto the temporal-markov spine (Track A/B evidence layer) **Status:** SYNTHESIS (session evidence addendum on `.claude/plans/temporal-markov-and-style-classes-v1.md`; grades explicit; no ruling changed). diff --git a/crates/lance-graph-planner/src/thinking/mod.rs b/crates/lance-graph-planner/src/thinking/mod.rs index 32135ca5..bca6df89 100644 --- a/crates/lance-graph-planner/src/thinking/mod.rs +++ b/crates/lance-graph-planner/src/thinking/mod.rs @@ -19,12 +19,22 @@ pub mod style; pub use nars_dispatch::{NarsInferenceType, QueryStrategy}; pub use semiring_selection::SemiringChoice; pub use sigma_chain::{SigmaStage, ThinkingAtom}; -pub use style::{FieldModulation, StyleFamily, ThinkingCluster}; +// `ThinkingStyle` is the deprecated compat alias for `StyleFamily` (D-TSC-1); +// re-exported here so pre-1a11038 consumers importing +// `lance_graph_planner::thinking::ThinkingStyle` keep compiling (with the +// deprecation warning steering them to `StyleFamily`), instead of hard-breaking. +#[allow(deprecated)] +pub use style::{FieldModulation, StyleFamily, ThinkingCluster, ThinkingStyle}; use crate::mul::MulAssessment; use crate::plan::PlannerConfig; use lance_graph_contract::cognitive_shader::RungLevel; -use style::PlannerStyleExt; +// Lifted (not just `use`d internally): the cluster/τ/modulation methods that +// used to be inherent on the old `ThinkingStyle` enum now live on this ext +// trait. Re-exporting it at the module root means a pre-1a11038 consumer whose +// `style.cluster()` broke needs one obvious `use thinking::PlannerStyleExt`, +// not a hunt into the `style` submodule. +pub use style::PlannerStyleExt; /// Complete thinking context produced by orchestration. /// This is what the query planner receives as input alongside the query. From 9316d49d0eef4039ffe93dc12d69ad8d9ef74d6c Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 13 Jul 2026 23:43:59 +0000 Subject: [PATCH 4/6] =?UTF-8?q?contract:=20legacy=5Foutliers=20=E2=80=94?= =?UTF-8?q?=20the=20blunt=20V3=20migration=20waiting=20room=20(operator=20?= =?UTF-8?q?ruling=202026-07-13)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The V3 12-byte facet payload is a content-blind register the ClassView projects; L1-L8 (le-contract §3) are all byte-axis readings (8:8 / 8:8:8 / 8:8:8:8). This adds the three WIDE CONTIGUOUS grace carvings a not-yet- decomposed class may sit in temporarily, in a bluntly-named module so it announces its own status: - LegacyOutlier::WideMixed (G1) — 3×u16 + 2×u24 = 48+48 - LegacyOutlier::WideTriple (G2) — 4×u24 (contiguous, NOT axis 4×(8:8:8)) - LegacyOutlier::WideQuad (G3) — 3×u32 (contiguous, NOT axis 3×(8:8:8:8)) All 96 bit, LE read/write, u24 no-silent-truncation guard mirroring NodeGuid::new. Deliberately a SEPARATE module from facet::CascadeShape and NOT a variant of it — a wide carving with no rail/axis is exactly what that enum refuses to bless, which is the whole point. Tagged "strongly discouraged if god-object-related or lacking proper bucket rollover; migrate to cosine-replacement palette256 (L4)" — the conditions are the diagnosis (god object -> decompose; no bucket rollover -> saturates silently; exit -> L4 6×(8:8) palette256²). NOT a V1 tail revival: one register read coarsely, no path/tail split. The V1 family:identity u24 fragment is the degenerate G1/G2 case (test proves the waiting-room claim). New classes MUST NOT be born into G1-G3. le-contract.md §3a documents the catalogue + code home; EPIPHANIES E-V3-GRACE-WIDE-CARVINGS-1 records the ruling. 5 lib tests green, clippy clean (-p lance-graph-contract). Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .claude/board/EPIPHANIES.md | 8 + .claude/v3/soa_layout/le-contract.md | 44 ++++ .../src/legacy_outliers.rs | 208 ++++++++++++++++++ crates/lance-graph-contract/src/lib.rs | 1 + 4 files changed, 261 insertions(+) create mode 100644 crates/lance-graph-contract/src/legacy_outliers.rs diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 77146fc1..dcab6898 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,11 @@ +## 2026-07-13 — E-V3-GRACE-WIDE-CARVINGS-1 — V1 migration gets a discouraged waiting room, not a crash (operator ruling) + +**Status:** RULED (operator, 2026-07-13). Recorded in `.claude/v3/soa_layout/le-contract.md` §3a. +**Frame:** the V3 12-byte payload is a content-blind register the ClassView projects — there is **no tail**; "V3 tail" is a category error, and modeling V3 as a `TailVariant::V3` inside `mint_for(tail_variant, …)` imported the dead V1 suffix-discriminator model into the new substrate (the poison). L1–L8 are all **byte-axis** projections (8:8 / 8:8:8 / 8:8:8:8). +**The ruling:** rather than hard-crash un-migrated classes, add three **wide contiguous** grace carvings as a documented, strongly-discouraged waiting room — G1 `3×16 + 2×24`, G2 `4×24`, G3 `3×32` (all 96-bit). Tagged *"strongly discouraged if god-object-related or lacking proper bucket rollover; migrate to cosine-replacement palette256 (L4)"* — the conditions ARE the diagnosis (god object → decompose; no bucket rollover → saturates silently; exit → L4 `6×(8:8)` palette256²). The V1 `family:identity` u24 fragment is the degenerate G1/G2 case. **Not** a tail revival (one register read coarsely, no path/tail split); `CascadeShape` gains **no** variants (stays byte-axis-only — a wide carving is what it refuses to bless). New classes MUST NOT be born into G1–G3. +**Code home:** `lance_graph_contract::legacy_outliers` (`legacy_outliers.rs`) — bluntly named per operator; `LegacyOutlier::{WideMixed/WideTriple/WideQuad}`, a *separate* module from `facet::CascadeShape` (never a variant), LE read/write + 5 tests incl. the V1 `family:identity` degenerate-case proof. +**Cross-ref:** le-contract.md §3a; E-V3-FACET-4-PLUS-12; the CANON supersession note (the `mint_for(tail_variant, …)` / "V3 tail" wording is the poison this reframes away from). + ## 2026-07-13 — E-COMPAT-ALIAS-MUST-BE-LIFTED-1 — a compat alias left in a leaf module but not re-exported at the consumer import path is a hard break, not a shim (D-TSC-1 regression, fixed) **Status:** CORRECTION (fixes a real consumer-facing regression shipped in `1a11038` / D-TSC-1; grade [G] — reproduced by compile). diff --git a/.claude/v3/soa_layout/le-contract.md b/.claude/v3/soa_layout/le-contract.md index c385d397..cc27b90e 100644 --- a/.claude/v3/soa_layout/le-contract.md +++ b/.claude/v3/soa_layout/le-contract.md @@ -66,6 +66,50 @@ Byte accounting: every layout is exactly 12 bytes — 6×2, 4×3, 3×4, 2×6. The 16-byte facet stride never changes; layouts differ only in how the 96 payload bits subdivide. +### §3a Grace-period wide carvings — strongly discouraged (the V1 migration waiting room) (operator, 2026-07-13) + +L1–L8 are the **axis-grouped byte-tile** catalogue: every tier is a *byte* +(8:8 pairs / 8:8:8 triplets / 8:8:8:8 quads), so the classview projects +real rails and `group_of` is a pure shift. A class that has **not yet +decomposed into byte-axis tiles** may sit *temporarily* in one of these +**wide contiguous carvings** — still exactly 96 bits, still one +content-blind register, **but not a tail and not first-class**: + +| # | Layout | Shape | 96-bit? | +|---|---|---|---| +| G1 | wide-mixed | 3 × 16-bit + 2 × 24-bit | 48 + 48 ✓ | +| G2 | wide-triple | 4 × 24-bit (contiguous — **NOT** the axis-grouped `4×(8:8:8)`) | 96 ✓ | +| G3 | wide-quad | 3 × 32-bit (contiguous — **NOT** the axis-grouped `3×(8:8:8:8)`) | 96 ✓ | + +**Strongly discouraged if god-object-related or lacking proper bucket +rollover; migrate to cosine-replacement palette256 (L4).** The conditions +are the diagnosis, not decoration: + +- **god-object-related** → a wide field is a symptom of a class carrying too + many concerns; you owe a **decomposition** (split the class / focus the + lens), never a wider field. +- **lacking proper bucket rollover** → a wide contiguous field with no HHTL + cascade spill has nothing to overflow *into*; it saturates silently. Give + it rollover, or narrow it. +- **the exit** → the real destination is **L4 `6×(8:8)` palette256²** + (each byte pair indexes the 256×256 palette LUT — cosine-replacement), + the axis-grouped shape the wide field is standing in for. + +These carvings exist **only** to give an un-migrated class a legal V3 home +during migration instead of crashing — the V1 `family:identity` u24 fragment +is the degenerate G1/G2 case. They are **not** a revival of the V1 *tail* +model (there is no path/tail split; this is one content-blind register read +coarsely), and **`CascadeShape` gains no variants for them** — that enum +stays byte-axis-only, and a wide carving is precisely what it refuses to +bless. New classes MUST NOT be born into G1–G3; the waiting room is not a +destination. + +Code home: **`lance_graph_contract::legacy_outliers`** (`legacy_outliers.rs`) +— bluntly named so it announces its own status. `LegacyOutlier::{WideMixed +(G1), WideTriple (G2), WideQuad (G3)}` with LE read/write over the 12-byte +payload; deliberately a *separate* module from `facet::CascadeShape`, never a +variant of it. + ### The (8:8) pair is polymorphic — the classview selects the reading Beyond L1–L4, a `6×(8:8)` plane admits these operator-sanctioned readings diff --git a/crates/lance-graph-contract/src/legacy_outliers.rs b/crates/lance-graph-contract/src/legacy_outliers.rs new file mode 100644 index 00000000..615716f2 --- /dev/null +++ b/crates/lance-graph-contract/src/legacy_outliers.rs @@ -0,0 +1,208 @@ +//! Legacy outlier carvings — the strongly-discouraged V3 migration waiting room. +//! +//! The V3 facet's 12-byte payload is a **content-blind register** the ClassView +//! projects. The sanctioned readings ([`crate::facet::CascadeShape`] + +//! `le-contract.md §3` L1–L8) are all **byte-axis** projections: every tier is a +//! *byte* (`6×(8:8)` rails / `4×(8:8:8)` triplets / `3×(8:8:8:8)` quads), so the +//! classview projects real rails and `group_of` is a pure shift. +//! +//! This module is the **opposite** — the three **wide contiguous** carvings a +//! class may sit in *temporarily* when it has **not yet** decomposed into +//! byte-axis tiles. They are still exactly 96 bits, still one content-blind +//! register — but they carry **no axis, no rail, no shift-addressable group**, +//! which is precisely why they are outliers and why [`CascadeShape`] refuses to +//! bless them (this module exists *because* they must not become `CascadeShape` +//! variants). +//! +//! [`CascadeShape`]: crate::facet::CascadeShape +//! +//! # STRONGLY DISCOURAGED +//! +//! A carving here is a smell, tagged by the operator ruling (2026-07-13, +//! `le-contract.md §3a`) with its own diagnosis: +//! +//! - **god-object-related** → a wide field means the class carries too many +//! concerns; you owe a **decomposition** (split the class / focus the lens), +//! never a wider field. +//! - **lacking proper bucket rollover** → a wide contiguous field with no HHTL +//! cascade spill has nothing to overflow *into*; it saturates silently. Give +//! it rollover, or narrow it. +//! - **the exit** → the real destination is the L4 `6×(8:8)` **palette256²** +//! cosine-replacement (each byte pair indexes the 256×256 palette LUT), the +//! axis-grouped shape the wide field is standing in for. +//! +//! This is **not** a revival of the V1 *tail* model. There is no path/tail +//! split; this is one content-blind register read coarsely. The V1 +//! `family:identity` u24 fragment is simply the degenerate [`WideMixed`] / +//! [`WideTriple`] case, given a legal V3 home during migration instead of a +//! crash. **New classes MUST NOT be born into these carvings.** The waiting room +//! is not a destination. + +/// The 12-byte content-blind payload every carving reads (facet bytes `4..16`). +pub const PAYLOAD_LEN: usize = 12; + +/// Read a little-endian `u24` from three bytes (as a `u32`, high byte zero). +#[inline] +const fn u24_le(a: u8, b: u8, c: u8) -> u32 { + (a as u32) | ((b as u32) << 8) | ((c as u32) << 16) +} + +/// Write a little-endian `u24` into three bytes. Debug-asserts the 24-bit fit — +/// the same no-silent-truncation guard `NodeGuid::new` uses for its u24 groups. +#[inline] +fn put_u24_le(dst: &mut [u8], v: u32) { + debug_assert!(v <= 0x00FF_FFFF, "legacy outlier u24 field must fit 24 bits"); + dst[0] = (v & 0xFF) as u8; + dst[1] = ((v >> 8) & 0xFF) as u8; + dst[2] = ((v >> 16) & 0xFF) as u8; +} + +/// The three sanctioned-but-discouraged wide carvings of the 96-bit payload. +/// +/// Selection is the classview's job (slot purity) exactly as for the byte-axis +/// layouts — never by inspecting payload bytes. A carving is chosen here only +/// because the class has not yet been decomposed onto the byte axis. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LegacyOutlier { + /// **G1** — `3 × u16 + 2 × u24` (48 + 48 = 96 bit). The coarsest mixed + /// waiting room; the V1 `family:identity` u24 pair lands in the two u24 + /// fields. + WideMixed, + /// **G2** — `4 × u24` (96 bit), contiguous. **NOT** the axis-grouped + /// `4×(8:8:8)` triplets ([`CascadeShape::G4D3`]) — no per-byte rail. + /// + /// [`CascadeShape::G4D3`]: crate::facet::CascadeShape::G4D3 + WideTriple, + /// **G3** — `3 × u32` (96 bit), contiguous. **NOT** the axis-grouped + /// `3×(8:8:8:8)` quads ([`CascadeShape::G3D4`]) — no per-byte rail. + /// + /// [`CascadeShape::G3D4`]: crate::facet::CascadeShape::G3D4 + WideQuad, +} + +impl LegacyOutlier { + /// Every carving, for exhaustive audits. + pub const ALL: [LegacyOutlier; 3] = [ + LegacyOutlier::WideMixed, + LegacyOutlier::WideTriple, + LegacyOutlier::WideQuad, + ]; + + /// G1 read: `[u16; 3]` (bytes `0..6`) then `[u24 as u32; 2]` (bytes `6..12`). + #[inline] + pub const fn read_wide_mixed(p: &[u8; PAYLOAD_LEN]) -> ([u16; 3], [u32; 2]) { + ( + [ + u16::from_le_bytes([p[0], p[1]]), + u16::from_le_bytes([p[2], p[3]]), + u16::from_le_bytes([p[4], p[5]]), + ], + [u24_le(p[6], p[7], p[8]), u24_le(p[9], p[10], p[11])], + ) + } + + /// G2 read: `[u24 as u32; 4]`, little-endian, contiguous. + #[inline] + pub const fn read_wide_triple(p: &[u8; PAYLOAD_LEN]) -> [u32; 4] { + [ + u24_le(p[0], p[1], p[2]), + u24_le(p[3], p[4], p[5]), + u24_le(p[6], p[7], p[8]), + u24_le(p[9], p[10], p[11]), + ] + } + + /// G3 read: `[u32; 3]`, little-endian, contiguous. + #[inline] + pub const fn read_wide_quad(p: &[u8; PAYLOAD_LEN]) -> [u32; 3] { + [ + u32::from_le_bytes([p[0], p[1], p[2], p[3]]), + u32::from_le_bytes([p[4], p[5], p[6], p[7]]), + u32::from_le_bytes([p[8], p[9], p[10], p[11]]), + ] + } + + /// G1 write. Debug-asserts each u24 fits 24 bits. + #[inline] + pub fn write_wide_mixed(shorts: [u16; 3], longs: [u32; 2]) -> [u8; PAYLOAD_LEN] { + let mut p = [0u8; PAYLOAD_LEN]; + p[0..2].copy_from_slice(&shorts[0].to_le_bytes()); + p[2..4].copy_from_slice(&shorts[1].to_le_bytes()); + p[4..6].copy_from_slice(&shorts[2].to_le_bytes()); + put_u24_le(&mut p[6..9], longs[0]); + put_u24_le(&mut p[9..12], longs[1]); + p + } + + /// G2 write. Debug-asserts each u24 fits 24 bits. + #[inline] + pub fn write_wide_triple(vals: [u32; 4]) -> [u8; PAYLOAD_LEN] { + let mut p = [0u8; PAYLOAD_LEN]; + put_u24_le(&mut p[0..3], vals[0]); + put_u24_le(&mut p[3..6], vals[1]); + put_u24_le(&mut p[6..9], vals[2]); + put_u24_le(&mut p[9..12], vals[3]); + p + } + + /// G3 write. + #[inline] + pub fn write_wide_quad(vals: [u32; 3]) -> [u8; PAYLOAD_LEN] { + let mut p = [0u8; PAYLOAD_LEN]; + p[0..4].copy_from_slice(&vals[0].to_le_bytes()); + p[4..8].copy_from_slice(&vals[1].to_le_bytes()); + p[8..12].copy_from_slice(&vals[2].to_le_bytes()); + p + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn every_carving_is_exactly_96_bits() { + // G1: 3×16 + 2×24 = 48 + 48; G2: 4×24; G3: 3×32 — all 96 bit = 12 byte. + assert_eq!(3 * 16 + 2 * 24, 96); + assert_eq!(4 * 24, 96); + assert_eq!(3 * 32, 96); + assert_eq!(PAYLOAD_LEN * 8, 96); + } + + #[test] + fn wide_mixed_round_trips() { + let p = LegacyOutlier::write_wide_mixed([0x1234, 0x5678, 0x9ABC], [0x11_2233, 0x44_5566]); + let (shorts, longs) = LegacyOutlier::read_wide_mixed(&p); + assert_eq!(shorts, [0x1234, 0x5678, 0x9ABC]); + assert_eq!(longs, [0x11_2233, 0x44_5566]); + } + + #[test] + fn wide_triple_round_trips() { + let p = LegacyOutlier::write_wide_triple([0x00_0001, 0x0A_0B0C, 0xFF_FFFF, 0x12_3456]); + assert_eq!( + LegacyOutlier::read_wide_triple(&p), + [0x00_0001, 0x0A_0B0C, 0xFF_FFFF, 0x12_3456] + ); + } + + #[test] + fn wide_quad_round_trips() { + let p = LegacyOutlier::write_wide_quad([0xDEAD_BEEF, 0x0000_0001, 0xCAFE_BABE]); + assert_eq!( + LegacyOutlier::read_wide_quad(&p), + [0xDEAD_BEEF, 0x0000_0001, 0xCAFE_BABE] + ); + } + + #[test] + fn v1_family_identity_fragment_is_the_degenerate_wide_mixed_case() { + // The retired V1 tail = family(u24) ++ identity(u24) — the two u24 + // fields of G1, the three u16 zero. Proves the "waiting room" claim: + // an un-migrated V1 unit has a legal home here, not a crash. + let p = LegacyOutlier::write_wide_mixed([0, 0, 0], [0x00_00AB, 0x00_00CD]); + let (shorts, longs) = LegacyOutlier::read_wide_mixed(&p); + assert_eq!(shorts, [0, 0, 0]); + assert_eq!(longs, [0xAB, 0xCD]); + } +} diff --git a/crates/lance-graph-contract/src/lib.rs b/crates/lance-graph-contract/src/lib.rs index 9f2cfad5..05b1de4c 100644 --- a/crates/lance-graph-contract/src/lib.rs +++ b/crates/lance-graph-contract/src/lib.rs @@ -94,6 +94,7 @@ pub mod high_heel; pub mod hotplug; pub mod jit; pub mod kanban; +pub mod legacy_outliers; pub mod literal_graph; pub mod mail; pub mod manifest; From 6de620c67fc23570867210124baeddff2626d7b1 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 13 Jul 2026 23:53:05 +0000 Subject: [PATCH 5/6] =?UTF-8?q?contract:=20bridge=20NodeGuid=20<->=20Facet?= =?UTF-8?q?Cascade=20=E2=80=94=20reach=20the=20content-blind=20surface,=20?= =?UTF-8?q?not=20mint=5Ffor?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adoption measured the market verdict: facet:: is used in 8 files / 28 sites with no apology; NodeGuid::mint_for has 3 real call sites and EVERY one is wrapped in a comment justifying the `mint_for(classid_read_mode(c) .tail_variant, …)` incantation. Sessions reached for facet::FacetCascade because it is the content-blind register done right; they held their nose past mint_for's tail ergonomics. Root cause: NodeGuid and FacetCascade are the SAME 16 bytes (`classid(4) | 6×(8:8)`) — one the tail lens, one the content-blind lens — but there was NO bridge, so a mint literally could not reach the good surface. This adds it: byte-identical `From for NodeGuid`, `From for FacetCascade`, and a `NodeGuid::facet()` accessor. No layout change, no reinterpretation — a mint can now build the ergonomic FacetCascade and `.into()` the node key with zero tail incantation. Byte-identity proven (facet_bridge_tests, green). Additive only; retiring mint_for/TailVariant and re-projecting the 3 sites' per-class ClassView byte placement are the follow-ups (the latter is a per-class semantic call, not a mechanical one). Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .../src/canonical_node.rs | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/crates/lance-graph-contract/src/canonical_node.rs b/crates/lance-graph-contract/src/canonical_node.rs index 3fe9375c..04b9271d 100644 --- a/crates/lance-graph-contract/src/canonical_node.rs +++ b/crates/lance-graph-contract/src/canonical_node.rs @@ -408,6 +408,60 @@ impl NodeGuid { } } +// ── FacetCascade bridge — the content-blind surface the workspace reaches for ── +// +// `NodeGuid` and [`crate::facet::FacetCascade`] are the SAME 16 bytes: +// `classid(4) | 6×(8:8)`. `NodeGuid` is the (legacy) tail lens; `FacetCascade` +// is the content-blind register lens — and adoption measured 8 files / 28 uses +// of `facet::` vs 3 apologetic `mint_for` call sites, because there was no +// bridge letting a mint reach the good surface. These conversions are +// **byte-identical** (no reinterpretation): build the ergonomic `FacetCascade`, +// `.into()` it, and get the node key with zero +// `mint_for(classid_read_mode(c).tail_variant, …)` incantation. +impl From for NodeGuid { + #[inline] + fn from(f: crate::facet::FacetCascade) -> Self { + Self(f.to_bytes()) + } +} + +impl From for crate::facet::FacetCascade { + #[inline] + fn from(g: NodeGuid) -> Self { + crate::facet::FacetCascade::from_bytes(g.as_bytes()) + } +} + +impl NodeGuid { + /// This key read as the content-blind + /// [`FacetCascade`](crate::facet::FacetCascade) — the same 16 bytes under the + /// register lens the workspace reaches for. Prefer building a `FacetCascade` + /// and `.into()`-ing it over `mint_for`. + #[inline] + pub const fn facet(&self) -> crate::facet::FacetCascade { + crate::facet::FacetCascade::from_bytes(&self.0) + } +} + +#[cfg(test)] +mod facet_bridge_tests { + use super::*; + + #[test] + fn nodeguid_facet_bridge_is_byte_identical() { + let g = NodeGuid::new(0x0A0B_0C0D, 0x1111, 0x2222, 0x3333, 0x44_5566, 0x77_8899); + let f: crate::facet::FacetCascade = g.into(); + // classid agrees across the lens; the 6 tiers ARE HEEL/HIP/TWIG/… + assert_eq!(f.facet_classid, g.classid()); + // facet bytes == guid bytes, and the round-trip is byte-identical + assert_eq!(f.to_bytes(), *g.as_bytes()); + let back: NodeGuid = f.into(); + assert_eq!(g.as_bytes(), back.as_bytes()); + // the `.facet()` accessor is the same view + assert_eq!(g.facet().to_bytes(), *g.as_bytes()); + } +} + // ── GUID v2 tail (leaf·family·identity, 3×u16) — D-GV2-1, feature-gated ──────── // // The v2 basin tail repartitions bytes 10..16: leaf(u16) 10..12 (the 4th HHTL From 8540d0e5547bfb097b33ea9912221d4e1da339d6 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 14 Jul 2026 07:09:17 +0000 Subject: [PATCH 6/6] v3: persona-vs-rung-ladder demarcation doc + rung-content ladder ruling banked (board + CLAUDE.md link) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Operator rulings from this session, calcified before they dilute: - NEW `.claude/v3/knowledge/persona-vs-rung-ladder.md` — the demarcation file. The rung-content ladder (ladybug-rs -> thinking-engine lineage): 0-1 observation / 2 = the 144 thinking atoms (12 verb families x 12 tenses; sigma_rosetta + verb_table) / 3 = the 34 NARS reasoning tactics = THE runbooks (contract::recipes RECIPES[34], primitives in ndarray hpc/styles) / 4 = StyleFamily-12 macros, autopoiesis through frozen x learned x exploration. The adjective-36 in contract::thinking is the SEPARATE persona-modeling storyline - off-ladder, unwired by design, never rung 3, never "NARS runbooks". Corrects the E-STYLE-FAMILY-VS-RUNBOOK-1 label (default_runbook() bridges rung-4 macros to the persona vocabulary while wearing the rung-3 tactics' name). Anti-conflation card for the four spaces + open items O1-O6 (rung-content wiring, StyleFamily->recipes edge, persona future work, D-TSC-1 residue, probe results, triangle landing zone). - CLAUDE.md: the doc linked from the V3 SUBSTRATE section as a MANDATORY read before touching StyleFamily / runbooks / recipes / 144 verbs / RungLevel / persona modeling (in addition to the existing .claude/board links). - Board: EPIPHANIES prepend E-RUNG-CONTENT-LADDER-1 (the ruling + the correction, append-only); TECH_DEBT prepend flipping TD-STYLE-TABLE-RESIDUE item 3 to PROBED/DORMANT (p64-bridge STYLES[ord % 12] has zero external callers; dependents import only CognitiveShader; UNIFIED_STYLES confirmed tethered-not-collapsed, closing the MODULE-TABLE census question). Doc + board only; no code change in this commit. Co-Authored-By: Claude Claude-Session: https://claude.ai/code/session_01Awg6TXocHcwTtc6eGsHcdD --- .claude/board/EPIPHANIES.md | 8 ++ .claude/board/TECH_DEBT.md | 19 +++ .../v3/knowledge/persona-vs-rung-ladder.md | 118 ++++++++++++++++++ CLAUDE.md | 9 ++ 4 files changed, 154 insertions(+) create mode 100644 .claude/v3/knowledge/persona-vs-rung-ladder.md diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index dcab6898..7facd95e 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,11 @@ +## 2026-07-14 — E-RUNG-CONTENT-LADDER-1 — the rung-content ladder ruled; persona-36 demarcated as a separate storyline (corrects E-STYLE-FAMILY-VS-RUNBOOK-1's "runbook" label) + +**Status:** RULED (operator, 2026-07-14). Canonical text: `.claude/v3/knowledge/persona-vs-rung-ladder.md` (linked from CLAUDE.md § V3 SUBSTRATE). +**The ladder (content reading of the 0–9 rungs, from the ladybug-rs → thinking-engine lineage):** rung 0–1 = observation; rung 2 = the 144 thinking atoms (12 verb families × 12 tenses — `sigma_rosetta.rs` + `grammar/verb_table.rs`); rung 3 = the **34 NARS reasoning tactics** = THE runbooks (`lance_graph_contract::recipes::RECIPES [Recipe; 34]`, primitives in `ndarray::hpc::styles`); rung 4 = `StyleFamily`-12 thinking macros, autopoiesis through the triangle frozen × learned × exploration. The shipped `RungLevel` carries only the Pearl causal-depth reading — the content wiring (O1) and the rung-4→rung-3 edge (O2, the TRUE default_runbook semantics) are OPEN. +**The demarcation:** the adjective-36 in `contract::thinking` (Empathetic/Warm/Blunt/Poetic…) is the **persona-modeling storyline** — off-ladder, unwired by design, NOT rung 3, NOT "literal NARS runbooks." `E-STYLE-FAMILY-VS-RUNBOOK-1`'s label is corrected through this entry (append-only; the original stands as written): `default_runbook()` bridges rung-4 macros to the persona vocabulary while wearing the rung-3 tactics' name. +**Probe results banked with the ruling (2026-07-14 session):** p64-bridge `STYLES[ord % 12]` = DORMANT (zero external callers; TD-STYLE-TABLE-RESIDUE item 3 flipped below); `UNIFIED_STYLES` = TETHERED-not-collapsed (parity test; answers the MODULE-TABLE census open question). +**Cross-ref:** persona-vs-rung-ladder.md (O1–O6 open items), E-FIVE-STYLE-TABLES-1, E-THINKING-STYLES-ARE-CLASSES-1 (FUTURE-DESIGN), MODULE-TABLE ADDENDUM 2026-07-10 (2). + ## 2026-07-13 — E-V3-GRACE-WIDE-CARVINGS-1 — V1 migration gets a discouraged waiting room, not a crash (operator ruling) **Status:** RULED (operator, 2026-07-13). Recorded in `.claude/v3/soa_layout/le-contract.md` §3a. diff --git a/.claude/board/TECH_DEBT.md b/.claude/board/TECH_DEBT.md index 38e0b34a..ed90d6a5 100644 --- a/.claude/board/TECH_DEBT.md +++ b/.claude/board/TECH_DEBT.md @@ -1,5 +1,24 @@ # Technical Debt Log — Open + Paid (double-entry, append-only) +## TD-STYLE-TABLE-RESIDUE item 3 — PROBED, downgraded (2026-07-14) + +The "does any caller feed StyleFamily ordinals into p64-bridge +`STYLES[ord % 12]`" probe ran (this session): **DORMANT — no live bug.** +`STYLES` is reachable only via `style_by_ordinal`/`style_by_name`/ +`all_styles`; repo-wide, the only `style_by_ordinal` caller is +p64-bridge's own 0..12 test loop; the three Cargo dependents +(driver/planner/osint) import only `cognitive_shader::CognitiveShader`, +never the styles surface; p64-bridge never imports `StyleFamily`. +Residual hazard is **latent-API only**: `style_by_ordinal(family as +usize)` by a future caller would scramble the predicate chain silently. +Free hardening queued (zero external callers = zero breakage): +`#[deprecated]` on `style_by_ordinal` steering to by-name conversion. +Companion answer for the MODULE-TABLE census: driver `UNIFIED_STYLES` +was TETHERED (names/ordinals/len parity test), not collapsed — a +legitimate close of that open question. Ruling context: +`E-RUNG-CONTENT-LADDER-1`; demarcation doc: +`.claude/v3/knowledge/persona-vs-rung-ladder.md`. + ## TD-MESSAGE-RESIDUE (2026-07-10, operator-ruled LEAVE-AS-IS) Per E-NOBODY-WAITS-1: no messages, no actors anywhere — ractor is only diff --git a/.claude/v3/knowledge/persona-vs-rung-ladder.md b/.claude/v3/knowledge/persona-vs-rung-ladder.md new file mode 100644 index 00000000..dc5024b2 --- /dev/null +++ b/.claude/v3/knowledge/persona-vs-rung-ladder.md @@ -0,0 +1,118 @@ +# Persona modeling vs the rung-content ladder — the demarcation + +> READ BY: v3-template-smith, truth-architect, integration-lead, +> perspective-weaver (persona side), any session touching StyleFamily, +> ThinkingStyle, runbooks, recipes, the 144 verbs, RungLevel semantics, +> or persona modeling. Operator-ruled 2026-07-14 (this session, chat +> transcript); board anchor: `E-RUNG-CONTENT-LADDER-1` in +> `.claude/board/EPIPHANIES.md`. + +## Why this file exists + +The workspace carried FOUR similar-looking spaces that sessions kept +conflating — three 12-spaces and a 36-space — and D-TSC-1 (`1a11038`) +canonized one conflation into the board ("36 = literal NARS runbooks"). +The operator separated them. This file is the demarcation, so no future +session re-merges them. + +## The rung-content ladder (operator ruling, 2026-07-14) + +The 0–9 rung ladder came from ladybug-rs thinking and migrated to +`crates/thinking-engine`. Its CONTENT reading — what kind of thinking +object occupies each rung — is: + +| Rung | Occupant | Where it lives (today) | +|---|---|---| +| 0–1 | **Observation** | Pearl L1 side of `contract::cognitive_shader::RungLevel` | +| 2 | **Thinking atoms** — the 12×12 = 144 universal-grammar verbs (12 verb families × 12 tenses) | `cognitive-shader-driver/src/sigma_rosetta.rs` (`VERB_ROOTS`/`VERB_TENSES`, 64 glyphs × 144 verbs = 9,216 atoms) + `contract/src/grammar/verb_table.rs` (`VerbRoleTable [[SlotPrior;12];12]`, TEKAMOLO priors) | +| 3 | **The 34 NARS reasoning tactics** (induction, abduction, deduction, extrapolation, counterfactual, …) — THE runbooks, in the literal sense: executable inference recipes | Catalogue spine: `lance_graph_contract::recipes` (`RECIPES: [Recipe; 34]`, Stakelum/ladybug numbering, Sun et al. 2025 tiers, SPO-2³ coverage). Substrate primitives: `ndarray::hpc::styles` (29/34 modules shipped, `fn(Base17, NarsTruth) → result`) — most of it migrated toward lance-graph via the recipes spine | +| 4 | **Thinking macros / styles** = `StyleFamily` (12) — Autopoiesis through the triangle **frozen × learned × exploration** (frozen = compiled templates / StepMask; learned = NARS revision / awareness; exploration = MUL / exploratory machinery) | `lance_graph_contract::style_family` | + +The code's shipped `RungLevel` carries the **Pearl causal-depth** +reading (0–2 observe / 3–5 intervene / 6–9 counterfactual) plus the +homeostatic elevation policy. That coexists with — but does NOT +implement — the content ladder above. The rung↔content wiring is the +half-hearted part of the 0–9 rewiring and is OPEN (see below). + +## Persona modeling — a SEPARATE storyline (the demarcation) + +The **36 adjective styles** in `lance_graph_contract::thinking` +(Empathetic, Warm, Blunt, Frank, Poetic, … — 36 variants, 6 clusters, +τ addresses, `FieldModulation`) are the **persona-modeling storyline**: + +- They are **NOT rung 3.** They are not reasoning moves. +- They are **NOT the NARS runbooks.** The runbooks are the 34 recipes + (rung 3, above). +- They are **not wired** into the rung ladder, the shader dispatch, or + the planner execution paths today ("carried and displayed, not acted + on" — the audited finding). That is expected, not a defect: persona + modeling is future work with its own storyline (perspective-weaver / + persona.rs territory), and the adjective vocabulary is its asset. +- They happen to be 12-groupable (`ThinkingStyle::family()` → 36→12, + distribution 1..6 per family — NOT 3-per-family, so they are also + not the rung-4 triangle decomposition). + +**What made the conflation easy:** persona-36 is 12-groupable, the +word "style" appears in all four spaces, and D-TSC-1's board ruling +`E-STYLE-FAMILY-VS-RUNBOOK-1` labeled the persona-36 "literal NARS +runbooks seeding the rung ladder." That label is CORRECTED by this +demarcation: `StyleFamily::default_runbook()` bridges rung-4 macros to +the *persona vocabulary*, while wearing the name of the *rung-3 +tactics*. The mapping pair (`family()`/`default_runbook()`) is +mechanically sound as a 12↔36 bridge WITHIN the persona storyline; only +its "runbook" naming and the board label cross storylines. + +## The four spaces, one line each (anti-conflation card) + +1. `StyleFamily` (12) — rung-4 thinking macros, orchestration dispatch. Canonical, deduped, frozen ordinals (driver order, Deliberate=0). +2. `recipes::RECIPES` (34) — rung-3 NARS reasoning tactics. THE runbooks. Catalogue in contract; primitives in ndarray `hpc/styles`. +3. 144 verbs (12×12) — rung-2 thinking atoms, the unified predicate surface (`sigma_rosetta` + `verb_table`). Computing, test-pinned. +4. persona-36 adjectives — persona-modeling storyline. Off-ladder, unwired, future work. Keep out of rung vocabulary. + +## OPEN / CURRENT (the live items this demarcation leaves) + +- **O1 — rung↔content wiring absent.** `RungLevel` knows Pearl depth, + not content occupants. No rung references `sigma_rosetta`, + `verb_table`, `recipes`, or `StyleFamily`. The content ladder exists + only as this ruling. +- **O2 — the rung-4→rung-3 edge (`StyleFamily` → recipe selection) + does not exist.** A macro choosing which of the 34 tactics fire is + the true "default_runbook" semantics; today's `default_runbook()` + points at the persona vocabulary instead. Eventual fix: retarget (or + twin) the mapping at `recipes::Recipe`, and rename the persona bridge + honestly (e.g. `default_persona()`). +- **O3 — persona storyline unwired by design.** Future persona work + picks up the adjective-36 + `thinking-engine/persona.rs`; until then + no rung/dispatch code should consume it as if it were reasoning. +- **O4 — D-TSC-1 residue (from the cross-session audit):** + `PlannerStyleExt` re-exported at `thinking::` but still NOT at + `api::` (the q2 E0599 path); the `#[deprecated]` note on the planner + alias points at the wrong space ("36-runbook space") and needs the + corrected wording; the two lab-only name→ordinal tables (`wire.rs`, + `auto_style.rs`) remain untethered. +- **O5 — probe results to ledger (run 2026-07-14, this session):** + p64-bridge `STYLES[ord % 12]` is DORMANT (zero external callers; + dependents import only `CognitiveShader`) — latent-API hazard only; + free hardening = `#[deprecated]` on `style_by_ordinal` steering to + by-name. `UNIFIED_STYLES` (driver `engine_bridge.rs`) was + TETHERED-not-collapsed by D-TSC-1 (names/ordinals/len parity test) — + answers the MODULE-TABLE census's open question. +- **O6 — triangle structure unbuilt.** Rung 4's autopoiesis triangle + (frozen × learned × exploration) has its three poles in separate + subsystems (StepMask/templates, NARS awareness, MUL) but no composed + macro object. `FUTURE-DESIGN.md` E-THINKING-STYLES-ARE-CLASSES-1 + ("style = class: StepMask × WideFieldMask + rung set + KausalSpec") + is the landing zone. + +## Cross-refs + +- `.claude/board/EPIPHANIES.md` — `E-RUNG-CONTENT-LADDER-1` (this + ruling), `E-STYLE-FAMILY-VS-RUNBOOK-1` (carries the corrected label + via this file), `E-FIVE-STYLE-TABLES-1` (the dedup finding). +- `.claude/v3/MODULE-TABLE.md` ADDENDUM 2026-07-10 (2) — the + ancestry-pipeline census rows for `verb_table.rs`, `sigma_rosetta.rs`, + p64-bridge `StyleParams`, `UNIFIED_STYLES`, `auto_style.rs`. +- `.claude/v3/FUTURE-DESIGN.md` — E-THINKING-STYLES-ARE-CLASSES-1. +- `lance_graph_contract::recipes` module doc — the 34-tactic spec + provenance (ladybug `34_TACTICS_x_REASONING_LADDER`; ladybug is spec + source, never dependency — ada-rewrite-charter D0). diff --git a/CLAUDE.md b/CLAUDE.md index 9b3c26e1..a2924b14 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,6 +38,15 @@ fleet-shipped 2026-07-02): - `.claude/v3/MODULE-TABLE.md` — per-file census of core / contract / planner - `.claude/v3/soa_layout/` — LE contract, tenant lanes, consumer map, routing - `.claude/v3/knowledge/` — V3 doctrine docs (`READ BY:` headers) +- `.claude/v3/knowledge/persona-vs-rung-ladder.md` — MANDATORY before + touching StyleFamily / ThinkingStyle / runbooks / recipes / the 144 + verbs / RungLevel semantics / persona modeling: the operator-ruled + rung-content ladder (0–1 observation, 2 = 144 verb atoms, 3 = the 34 + NARS tactic recipes = THE runbooks, 4 = StyleFamily macros + + autopoiesis triangle) and the demarcation that the adjective-36 in + `contract::thinking` is the SEPARATE, unwired persona-modeling + storyline — never rung 3, never "NARS runbooks" (corrects + E-STYLE-FAMILY-VS-RUNBOOK-1's label). Open items O1–O6 tracked there. - `.claude/v3/agents/BOOT.md` — the four V3 cards (`v3-mailbox-warden`, `v3-envelope-auditor`, `v3-kanban-executor-engineer`, `v3-template-smith`) - `.claude/v3/knowledge/sonnet-worker-guardrails.md` — MANDATORY in every