lance-graph-contract: codegen_manifest::MethodSig — the C++ codegen compile target

The MethodSig EXTEND-CORE (C-FIRST step 2's deferred-runtime-registry piece).
A new codegen_manifest module:

- MethodSig: the dispatch-relevant C++ method signature in a const-constructible
  shape (all fields &'static: name, params: &'static [&'static str], ret,
  is_const, is_static, overrides). It is the exact literal ruff_cpp_codegen::render
  emits, so the generated text now has a real compile target. The &'static shape
  is load-bearing: class_view::FieldRef is String-backed and cannot appear in a
  const; MethodSig is the method-axis sibling that can.
- ClassMethods{classid, methods} + methods_for(registry, classid): the
  registry-entry type + pure zero-fallback lookup (unregistered classid -> empty
  slice). classid is bound OGAR-side, never minted here; the runtime
  classid->methods registry DATA is generated downstream (consumer repo), NOT
  stored here (honest-tester's "defer the runtime registry").

Additive (container-architect ADDITIVE-CONFIRMED): a sibling module, zero
NodeRow/ValueTenant/ValueSchema/stride/ENVELOPE_LAYOUT_VERSION impact. Body-shaping
flags (pure-virtual/constexpr/noexcept/operator/requires) are out of scope.
Board hygiene: LATEST_STATE Contract Inventory updated same commit
(D-CPP-CODEGEN-1). +2 tests (const-constructibility proof + zero-fallback);
640 contract lib green; clippy -D warnings clean.

C-FIRST: D + emitter scaffold + MethodSig EXTEND-CORE all landed; the in-env arc
is complete. Remaining is operator-gated (tesseract-rs wiring + byte-parity).

Co-Authored-By: Claude <noreply@anthropic.com>
https://claude.ai/code/session_016b33swuXE23hKtqxsHu9p1

Author: claude

.claude/board/LATEST_STATE.md

@@ -82,6 +82,8 @@
 
 ## Current Contract Inventory (lance-graph-contract)
 
+> **2026-06-17 — ADDED (D-CPP-CODEGEN-1, C-FIRST step 2 compile target)**: `lance_graph_contract::codegen_manifest::{MethodSig, ClassMethods, methods_for}` — the Core-side target of the C++ method-resolution manifest emitted by `ruff_cpp_codegen` (the Tesseract AST-DLL pipeline's stage 2). `MethodSig` is the dispatch-relevant signature in a **`const`-constructible** shape (all fields `&'static`: `name`, `params: &'static [&'static str]`, `ret`, `is_const`, `is_static`, `overrides`) — the method-axis sibling of `class_view::ClassView`'s field projection, deliberately NOT `String`-backed (a generated `const X: &[MethodSig] = &[MethodSig { .. }]` must compile; `FieldRef` is `String`-backed and cannot). `ClassMethods{classid, methods}` is the registry ENTRY the generated code emits (classid bound OGAR-side, never minted here); `methods_for(registry, classid) -> &'static [MethodSig]` is the pure lookup with zero-fallback (unregistered classid → empty slice). **Additive** (container-architect ADDITIVE-CONFIRMED): a sibling module, zero `NodeRow`/`ValueTenant`/`ValueSchema`/stride/`ENVELOPE_LAYOUT_VERSION` impact; the runtime `classid→methods` registry DATA lives downstream (generated in the consumer repo), not here. Body-shaping flags (pure-virtual/constexpr/noexcept/operator/requires) are out of scope (they drive body generation, not the signature manifest). The 8-agent step-2 council's deferred-runtime-registry resolution. +2 tests (const-constructibility proof + zero-fallback lookup); 640 contract lib green; clippy `-D warnings` clean. Plan: `.claude/plans/transcode-extend-core-probe-v1.md` (C step 2). Consumer: `ruff_cpp_codegen::render` (AdaWorldAPI/ruff) names this type in emit-text-only output.
+
 > **2026-06-16 — ADDED (4-task unblock-cascade)**: `lance_graph_contract::hhtl::NiblePath::{from_guid_prefix(&NodeGuid) -> Option<NiblePath>, prefix(depth: u8) -> Option<NiblePath>}` — the ontology-side keystone follow-up of #498's `classid → ReadMode` LE contract. The 20-nibble `classid · HEEL · HIP · TWIG` prefix is deterministically folded to 16 (the canon-reserved high `u16` of classid drops); returns `None` when the fold would be lossy (callers don't get silent collisions). `prefix(d)` is the O(1) single-shot ancestor view that satisfies `prefix(d).is_ancestor_of(self)` for every `d ≤ self.depth` — the routing-cache view of a deeper class path. **One layer up** in `cognitive-shader-driver::MailboxSoA<N>`: `impl MailboxSoaView + MailboxSoaOwner` (cherry-pick of `jolly-cori-clnf9::463d71b`) + the `pub phase: KanbanColumn` field — the in-RAM Rubicon owner the contract's `MailboxSoaOwner` had no real implementor for (integrated-cognitive-planner-v1 §2 Seam #3 closed). In `lance_graph::graph::scheduler`: `LanceVersionScheduler<S = NextPhaseScheduler>` — D-MBX-9-IN core impl over `VersionedGraph::versions()`, generic over the inner `VersionScheduler` policy (closes `E-SUBSTRATE-IS-THE-SCHEDULER`'s OUT-direction). In `surreal_container::view`: `SurrealMailboxView<'a>` + `read_via_kv_lance()` (D-PG-6 contract slice) — the SurrealQL read-glove the integrator wires once the cold-build of the surrealdb fork is taken; the contract surface is available today. Plus `SurrealContainerError::BlockedColdBuild` — typed signal for callers to pattern-match the cold-build gate (distinct from the pre-existing `Blocked` variant which signals coordinate/API gaps). Zero-dep contract additions (+7 hhtl tests, 632 lib green); cognitive-shader-driver +1 driving-loop test (86 lib green); lance-graph::scheduler new module (+5 tests, real tempdir Lance); surreal_container::view new module (+4 tests). All four green; clippy `-D warnings` clean on the new files. EPIPHANIES `E-UNBLOCK-CASCADE-1` records the convergence of three independent landings onto the single `MailboxSoaView` trait surface.
 
 > **2026-06-09 — ADDED (D-IDENTITY-1, Phase A of identity-architecture)**: `lance_graph_contract::identity::{NodeGuid([u8;16]), IDENTITY_LAYOUT_VERSION}` — the workspace's first **stable binary instance identity**: a structured 128-bit UUIDv8 (RFC 9562) = the HHTL nibble-address **formalized + namespaced**. **Composed from existing committed scalars, never re-invented** (Agent A sweep confirmed the 128-bit id space was empty): octets carry `namespace:u8 | entity_type:u16 | kind:u8` (the `SchemaPtr.packed` convention) ⊕ a truncated `NiblePath` routing prefix (`PREFIX_NIBBLES=4`) ⊕ a 22-bit `shape_hash` (truncated `StructuralSignature`) ⊕ a 24-bit `local`, with UUIDv8 version(=8)/variant(=0b10) at their RFC-fixed positions + an `IDENTITY_LAYOUT_VERSION` stamp. **Eineindeutigkeit**: `entity_type` is the canonical exact class identity; the `NiblePath` prefix is the bijective DERIVED view (a *truncated* prefix can't be the identity — deep classes collide past it; the prefix `is_ancestor_of` the full path). Five readings: resolve (`entity_type`) / route (`niblepath`) / witness (frozen bytes + merkle) / ground-truth (`shape_hash` drift) / dispatch-to-store (`as_bytes` → `EntityKey`). Also added `hhtl::NiblePath::from_packed` (inverse of `packed`). Zero-dep; 599 contract lib tests (+15: field-isolation matrix, UUIDv8 gates, ancestor-prefix invariant, Display=canonical-UUID); clippy `-D warnings` clean; fmt clean. Plans: `identity-architecture-exists-vs-needs-v1.md` (exists-vs-needs map + phases A→H), `cognitive-write-roundtrip-substrate-v1.md`. Epiphany: E-IDENTITY-WHITEBOX-1.

.claude/plans/transcode-extend-core-probe-v1.md

@@ -403,3 +403,35 @@ names. It touches operator-locked canon (additively), so unlike D and the
 scaffold (ruff-internal correctness/codegen) it is the deliberate-Core-growth
 step the doctrine says to file + review before landing. Then: wire the generated
 crate in tesseract-rs and run byte-parity (Option B, operator's leptonica host).
+
+### MethodSig EXTEND-CORE — LANDED (2026-06-17, AdaWorldAPI/lance-graph)
+
+`lance_graph_contract::codegen_manifest` shipped (the council pre-review =
+file + review; container-architect ADDITIVE-CONFIRMED):
+
+- **`MethodSig`** — the dispatch signature in a `const`-constructible shape (all
+  fields `&'static`: `name`, `params: &'static [&'static str]`, `ret`,
+  `is_const`, `is_static`, `overrides`). This is the exact literal
+  `ruff_cpp_codegen::render` emits, so the generated text now has a real compile
+  target. The `&'static` shape is the whole point — `class_view::FieldRef` is
+  `String`-backed and cannot appear in a `const`; `MethodSig` is the method-axis
+  sibling that can.
+- **`ClassMethods{classid, methods}`** + **`methods_for(registry, classid)`** —
+  the registry-entry type + pure zero-fallback lookup. classid is bound
+  OGAR-side (never minted here); the runtime `classid→methods` registry DATA is
+  generated downstream (consumer repo), NOT stored in lance-graph — the
+  honest-tester's "defer the runtime registry" honored.
+- **Additive**: a sibling module, zero `NodeRow`/`ValueTenant`/`ValueSchema`/
+  stride/`ENVELOPE_LAYOUT_VERSION` impact. Board hygiene: LATEST_STATE Contract
+  Inventory updated in the same commit (D-CPP-CODEGEN-1). +2 tests
+  (const-constructibility proof — the load-bearing property — + zero-fallback
+  lookup); 640 contract lib green; clippy `-D warnings` clean.
+
+**C-FIRST status:** D ✓ → emitter scaffold ✓ → MethodSig EXTEND-CORE ✓. The
+in-env, lance-graph-internal arc of the pipeline is complete: a C++ harvest now
+flows harvest → reassemble → project → render → a `MethodSig` manifest whose
+type exists in the Core. **Remaining (operator-gated, out of this env):** wire
+the generated crate into tesseract-rs (needs the leptonica build env) and run
+`PROBE-OGAR-ADAPTER-UNICHARSET` byte-parity (Option B) — the only path to
+CONJECTURE→FINDING. Everything to here is CONJECTURE per the doctrine; the
+`PARITY: UNRUN` markers on every generated file say so.

crates/lance-graph-contract/src/codegen_manifest.rs

@@ -0,0 +1,144 @@
+//! Codegen manifest types — the Core-side target of the C++ method-resolution
+//! manifest emitted by `ruff_cpp_codegen` (the AST-DLL pipeline's stage 2).
+//!
+//! `ruff_cpp_spo` harvests a C++ corpus into SPO triples; `ruff_spo_triplet`
+//! reassembles the method plane; `ruff_cpp_codegen` renders it as Rust source
+//! that names [`MethodSig`]. This module is the **compile target** of that
+//! generated text.
+//!
+//! # Why `&'static`, not `String`
+//!
+//! Every field is `&'static` so a generated
+//! `const X: &[MethodSig] = &[MethodSig { .. }]` compiles. The render-side
+//! manifest could not target [`crate::class_view::ClassView`]'s `fields()`
+//! because `FieldRef` is `String`-backed (not `const`-constructible);
+//! `MethodSig` is the method-axis sibling, deliberately all-`&'static`.
+//!
+//! # What lives here vs. downstream
+//!
+//! This module provides the **type + lookup**. The **data** — the per-class
+//! `const … : &[MethodSig]` tables and the `&[ClassMethods]` registry — is
+//! generated downstream (in the consumer repo, e.g. tesseract-rs) and is NOT
+//! held here; lance-graph mints no C++ classids and stores no method tables.
+//! The classid is bound OGAR-side (the `ocr.rs::to_node_row(classid, …)`
+//! precedent — classid is a parameter, never minted by the manifest). A runtime
+//! `classid → methods` registry is intentionally deferred: this is the minimal
+//! additive Core growth (`MethodSig` is the dispatch signature; the body
+//! adapters and a populated registry come later).
+//!
+//! `MethodSig` carries only the dispatch-relevant signature (name, ordered
+//! params, return, `is_const`/`is_static`, override target). The body-shaping
+//! flags the harvest also captures (`is_pure_virtual` / `constexpr` /
+//! `noexcept` / operator-kind / `requires`) drive body generation, not the
+//! signature manifest, and are not represented here.
+
+/// One C++ method's dispatch-relevant signature, in a `const`-constructible
+/// shape (all fields `&'static`). This is the exact literal
+/// `ruff_cpp_codegen::render` emits.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct MethodSig {
+    /// Bare method name (e.g. `unichar_to_id`, `operator==`).
+    pub name: &'static str,
+    /// Parameter types in signature order, verbatim
+    /// (e.g. `&["const char *", "int"]`).
+    pub params: &'static [&'static str],
+    /// Return type, verbatim. `None` for void / constructors / destructors.
+    pub ret: Option<&'static str>,
+    /// `T method() const;` — a const-qualified (read-accessor) member.
+    pub is_const: bool,
+    /// `static T method();` — a class-level member (no implicit `this`).
+    pub is_static: bool,
+    /// The fully-qualified overridden base method (cv-aware), if any.
+    pub overrides: Option<&'static str>,
+}
+
+impl MethodSig {
+    /// Number of parameters.
+    #[must_use]
+    pub const fn arity(&self) -> usize {
+        self.params.len()
+    }
+
+    /// Whether this method overrides a virtual base method.
+    #[must_use]
+    pub const fn is_override(&self) -> bool {
+        self.overrides.is_some()
+    }
+}
+
+/// One class's method manifest, keyed by classid — the registry ENTRY the
+/// generated code emits. The classid is bound OGAR-side; this type only
+/// associates an already-minted classid with its `const` method table.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ClassMethods {
+    /// The OGAR classid this manifest belongs to.
+    pub classid: u32,
+    /// The class's methods (a generated `const` table).
+    pub methods: &'static [MethodSig],
+}
+
+/// Resolve a classid to its method manifest within a generated `registry`
+/// slice. The Core provides the lookup; the `registry` data is generated
+/// downstream. Returns an empty slice for an unregistered classid (the
+/// zero-fallback ladder: an unknown class resolves to "no methods", never a
+/// panic).
+#[must_use]
+pub fn methods_for(registry: &[ClassMethods], classid: u32) -> &'static [MethodSig] {
+    registry
+        .iter()
+        .find(|entry| entry.classid == classid)
+        .map_or(&[], |entry| entry.methods)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The load-bearing property: `MethodSig` is `const`-constructible. This is
+    /// the exact shape `ruff_cpp_codegen::render` emits — if it ever stopped
+    /// compiling in a `const`, the generated manifests would too. (Contrast
+    /// `FieldRef`, which is `String`-backed and cannot appear in a `const`.)
+    const SAMPLE: &[MethodSig] = &[
+        MethodSig {
+            name: "unichar_to_id",
+            params: &["const char *"],
+            ret: Some("UNICHAR_ID"),
+            is_const: true,
+            is_static: false,
+            overrides: None,
+        },
+        MethodSig {
+            name: "kSpaceId",
+            params: &[],
+            ret: Some("UNICHAR_ID"),
+            is_const: false,
+            is_static: true,
+            overrides: None,
+        },
+    ];
+
+    const REGISTRY: &[ClassMethods] = &[ClassMethods {
+        classid: 0x0001,
+        methods: SAMPLE,
+    }];
+
+    #[test]
+    fn const_manifest_constructs_and_reads() {
+        assert_eq!(SAMPLE.len(), 2);
+        assert_eq!(SAMPLE[0].name, "unichar_to_id");
+        assert_eq!(SAMPLE[0].arity(), 1);
+        assert!(SAMPLE[0].is_const);
+        assert!(!SAMPLE[0].is_override());
+        assert!(SAMPLE[1].is_static);
+        assert_eq!(SAMPLE[1].arity(), 0);
+    }
+
+    #[test]
+    fn methods_for_resolves_classid_with_zero_fallback() {
+        assert_eq!(methods_for(REGISTRY, 0x0001).len(), 2);
+        assert!(
+            methods_for(REGISTRY, 0xDEAD).is_empty(),
+            "an unregistered classid resolves to no methods (zero-fallback)"
+        );
+    }
+}

crates/lance-graph-contract/src/lib.rs

@@ -44,6 +44,7 @@ pub mod callcenter;
 pub mod cam;
 pub mod canonical_node;
 pub mod class_view;
+pub mod codegen_manifest;
 pub mod codegen_spine;
 pub mod cognitive_shader;
 pub mod collapse_gate;