osint: promote the dual-use axes to the 0xFFFF global-category pole

Slice-2 prototype (1 of 2) on aiwar. The 12 SchemaAxis dimensions are
promoted to the CEILING pole — HEEL=HIP=0xFFFF, the axis index in TWIG — so
they are cross-cutting GLOBAL categories addressable across every basin, not
stranded basin-local (which is what islanded them). The address says
"global" before any edge does.

Bake (osint-bake):
- SchemaAxis nodes get HEEL=HIP=0xFFFF, TWIG=axis grain (stable order among
  the axes); entities/values keep theme/anchor in HEEL/HIP, TWIG=0; family/
  identity unchanged. New const GLOBAL_CEILING; the 0x0000 floor pole and the
  leaf grain (sentinel run through TWIG) follow the same lattice.

Cockpit (OsintGraph.tsx):
- Read the ceiling marker straight off the GUID (HEEL @4, HIP @6).
- Render ceiling nodes as bright gold diamonds (the cross-cutting hubs),
  prominent in every mode (class / facet lens / reasoning). Legend entry.

Verified: osint-bake 9/9 tests (new schema_axes_are_ceiling_pole_global_
categories), clippy clean, asset deterministic (3/3 SHA). Asset decode: 12
ceiling nodes, all cls 6, distinct twigs 0..11, 0 entities promoted. Cockpit
`tsc && vite build` clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TzqvDqbFRzyx17EkLKBoZF

Author: claude

cockpit/src/OsintGraph.tsx

@@ -74,6 +74,9 @@ const facetColor = (code: number) =>
 const DIM_NODE = { background: 'rgba(10,14,23,0.55)', border: '#26323f' };
 const DIM_EDGE = 'rgba(50,66,84,0.12)';
 const ACTIVE = '#6cf0ff';
+// the cross-cutting global-category hubs (HEEL=HIP=0xFFFF ceiling pole) — drawn
+// as bright diamonds so the dual-use axes read as global, not basin-local.
+const CEILING_COLOR = '#ffd166';
 
 interface Soa {
   nodeCount: number;
@@ -84,6 +87,8 @@ interface Soa {
   // per-node facet tenant: 6 codes (value[1..=6]) × nodeCount, or null if the
   // asset predates the tenant tail. The dynamic attribute the facet lens groups by.
   tenants: Uint8Array | null;
+  // per-node global-category flag (HEEL=HIP=0xFFFF ceiling pole): 1 = cross-cutting.
+  ceiling: Uint8Array;
 }
 
 /** One readable step of the reasoning traversal, streamed into the readout. */
@@ -120,7 +125,14 @@ function decodeSoa(buf: ArrayBuffer): Soa {
   const edgeCount = dv.getUint32(8, true);
   let off = 12;
   const cls = new Uint8Array(nodeCount);
+  // ceiling[i] = 1 when the GUID's HEEL and HIP are both the 0xFFFF sentinel —
+  // the node is a cross-cutting GLOBAL category (the dual-use axes), not
+  // basin-local. Read straight off the 16-byte GUID (HEEL @4, HIP @6).
+  const ceiling = new Uint8Array(nodeCount);
   for (let i = 0; i < nodeCount; i++) {
+    const heel = dv.getUint16(off + 4, true);
+    const hip = dv.getUint16(off + 6, true);
+    if (heel === 0xffff && hip === 0xffff) ceiling[i] = 1;
     cls[i] = dv.getUint8(off + 16);
     off += 17;
   }
@@ -150,7 +162,7 @@ function decodeSoa(buf: ArrayBuffer): Soa {
     tenants = new Uint8Array(buf, off, nodeCount * 6);
     off += nodeCount * 6;
   }
-  return { nodeCount, edgeCount, cls, edges, labels, tenants };
+  return { nodeCount, edgeCount, cls, edges, labels, tenants, ceiling };
 }
 
 // vis-network options tuned to the Palantir look: hollow ring nodes (dark fill
@@ -348,22 +360,26 @@ export function OsintGraph() {
     // code on that axis (categorical, computed live across every node); else the
     // class colour. This is the dynamic group-by — no baked edges involved.
     const nodeBorder = (i: number) => {
+      if (soa.ceiling[i]) return CEILING_COLOR; // global hubs stay prominent in every mode
       const ax = facetAxisRef.current;
       if (ax != null && soa.tenants) return facetColor(soa.tenants[i * 6 + ax]);
       return classColor(soa.cls[i]);
     };
+    const nodeKind = (i: number) =>
+      soa.ceiling[i] ? '◈ global category (cross-cutting)' : CLASS[soa.cls[i]]?.name ?? 'concept';
     const baseNode = (i: number) => ({
       id: i,
       label: soa.labels[i] || `#${i}`,
+      shape: soa.ceiling[i] ? 'diamond' : 'dot',
       color: {
-        background: 'rgba(10,14,23,0.88)',
+        background: soa.ceiling[i] ? 'rgba(255,209,102,0.14)' : 'rgba(10,14,23,0.88)',
         border: nodeBorder(i),
         highlight: { background: 'rgba(10,14,23,0.96)', border: '#9fe8ff' },
         hover: { background: 'rgba(10,14,23,0.82)', border: nodeBorder(i) },
       },
-      size: baseSize(i),
-      font: { color: '#d9e9f9' },
-      title: `${soa.labels[i] || `#${i}`}\n${CLASS[soa.cls[i]]?.name ?? 'concept'} · ${degree.get(i) ?? 0} links`,
+      size: baseSize(i) + (soa.ceiling[i] ? 7 : 0),
+      font: { color: soa.ceiling[i] ? '#ffe9b0' : '#d9e9f9' },
+      title: `${soa.labels[i] || `#${i}`}\n${nodeKind(i)} · ${degree.get(i) ?? 0} links`,
     });
     const baseEdge = (e: { id: number; s: number; t: number; r: number }) => ({
       id: e.id,
@@ -993,6 +1009,20 @@ export function OsintGraph() {
             {k.name}
           </span>
         ))}
+        <span style={{ marginRight: 12, whiteSpace: 'nowrap' }}>
+          <span
+            style={{
+              display: 'inline-block',
+              width: 9,
+              height: 9,
+              border: `2px solid ${CEILING_COLOR}`,
+              marginRight: 5,
+              verticalAlign: 'middle',
+              transform: 'rotate(45deg)',
+            }}
+          />
+          ◈ global axis
+        </span>
       </div>
 
       {/* alternative-view link */}

crates/cockpit-server/assets/osint_scene.soa

@@ -507,6 +507,14 @@ fn plan_basins(graph: &AiWarGraph, rounds: &[EncounterRound]) -> BasinPlan {
     }
 }
 
+/// The CEILING global-category pole. `HEEL = HIP = 0xFFFF` marks a node as a
+/// **cross-cutting global category** (not basin-local); the first non-sentinel
+/// tier below — here TWIG — sets its grain (run the sentinel deeper, through
+/// TWIG, to reach a leaf-limited category). Mirrors the existing `0xFF` hub
+/// convention lifted from the basin byte to the HHTL tiers; `0x0000` is the
+/// opposite **floor** pole (default / fall-through).
+const GLOBAL_CEILING: u16 = 0xFFFF;
+
 /// Build the classid-`0x0700` OSINT node rows (one per entity, in `graph.nodes`
 /// order so `identity == index`). The GUID-v2 tail is `leaf=0 | family=basin |
 /// identity=index`; HEEL/HIP carry the theme/anchor for deterministic HHTL
@@ -525,14 +533,31 @@ pub fn osint_node_rows(graph: &AiWarGraph, plan: &BasinPlan) -> Vec<NodeRow> {
             .push(e.target.as_str());
     }
 
+    // SchemaAxis nodes (the dual-use dimensions) are promoted to the CEILING
+    // global-category pole at TWIG grain: each gets a stable TWIG (its order
+    // among the SchemaAxis nodes, in graph.nodes order — deterministic). They
+    // become cross-cutting categories addressable across every basin, instead
+    // of being stranded basin-local (which is what islanded them).
+    let axis_twig: HashMap<&str, u16> = graph
+        .nodes
+        .iter()
+        .filter(|n| n.node_type == "SchemaAxis")
+        .enumerate()
+        .map(|(k, n)| (n.id.as_str(), k as u16))
+        .collect();
+
     graph
         .nodes
         .iter()
         .enumerate()
         .map(|(i, n)| {
             let basin = basin_of(&n.id);
-            let theme_hi = u16::from(basin >> 4);
-            let anchor_lo = u16::from(basin & 0x0F);
+            // ceiling pole (HEEL=HIP=0xFFFF, TWIG=axis grain) for the dimensions;
+            // theme/anchor (TWIG=0) for everything basin-local.
+            let (heel, hip, twig) = match axis_twig.get(n.id.as_str()) {
+                Some(&t) => (GLOBAL_CEILING, GLOBAL_CEILING, t),
+                None => (u16::from(basin >> 4), u16::from(basin & 0x0F), 0),
+            };
 
             // 16×8bit mixin-node adapters (FLAT — the old 12+4 in/out split is
             // waived). The distinct nonzero *other* basins this node connects
@@ -571,9 +596,9 @@ pub fn osint_node_rows(graph: &AiWarGraph, plan: &BasinPlan) -> Vec<NodeRow> {
             NodeRow {
                 key: NodeGuid::new_v2(
                     NodeGuid::CLASSID_OSINT, // classid 0x0700 — the ONE OSINT class
-                    theme_hi,                // HEEL — coarse HHTL routing by theme
-                    anchor_lo,               // HIP  — anchor tier
-                    0,                       // TWIG
+                    heel,                    // HEEL — theme, or 0xFFFF ceiling for a dimension
+                    hip,                     // HIP  — anchor, or 0xFFFF ceiling for a dimension
+                    twig,                    // TWIG — axis grain for a ceiling-pole dimension
                     0,                       // LEAF (4th HHTL tier)
                     u16::from(basin),        // family = basin relay (mixin)
                     i as u16,                // identity = node index
@@ -1097,4 +1122,48 @@ mod tests {
             "basin hubs carry a zero tenant"
         );
     }
+
+    #[test]
+    fn schema_axes_are_ceiling_pole_global_categories() {
+        // The dual-use dimensions are promoted to the 0xFFFF CEILING pole at
+        // TWIG grain: cross-cutting global categories (HEEL=HIP=sentinel), the
+        // axis index in TWIG. Entities stay basin-local (theme/anchor in
+        // HEEL/HIP, TWIG unused). The address says "global" without an edge.
+        let node = |id: &str, ty: &str| aiwar_ingest::GraphNode {
+            id: id.to_string(),
+            label: id.to_string(),
+            node_type: ty.to_string(),
+            properties: HashMap::new(),
+        };
+        let g = AiWarGraph {
+            nodes: vec![
+                node("Lattice", "System"),
+                node("militaryUse", "SchemaAxis"),
+                node("civicUse", "SchemaAxis"),
+            ],
+            edges: vec![],
+        };
+        let plan = plan_basins(&g, &[]);
+        let rows = osint_node_rows(&g, &plan);
+
+        let mu = g.nodes.iter().position(|n| n.id == "militaryUse").unwrap();
+        let cu = g.nodes.iter().position(|n| n.id == "civicUse").unwrap();
+        // both axes sit at the ceiling pole, with DISTINCT twig grains.
+        assert_eq!(rows[mu].key.heel(), 0xFFFF, "axis HEEL = ceiling sentinel");
+        assert_eq!(rows[mu].key.hip(), 0xFFFF, "axis HIP = ceiling sentinel");
+        assert_eq!(rows[cu].key.heel(), 0xFFFF);
+        assert_eq!(rows[cu].key.hip(), 0xFFFF);
+        assert_ne!(
+            rows[mu].key.twig(),
+            rows[cu].key.twig(),
+            "each axis is a distinct twig-grain category"
+        );
+        // identity/family are still the fine address (unchanged).
+        assert_eq!(rows[mu].key.identity_v2(), mu as u16);
+
+        // a normal entity stays basin-local — NOT the ceiling sentinel.
+        let sys = g.nodes.iter().position(|n| n.id == "Lattice").unwrap();
+        assert_ne!(rows[sys].key.heel(), 0xFFFF, "entity is basin-local");
+        assert_eq!(rows[sys].key.twig(), 0, "entity TWIG unused");
+    }
 }