fix(osint): PR #560 codex P2 — gremlin bag semantics + aiwar cross-family edges

(1) graph_gremlin: step() silently deduped reached targets via a `seen` set,
breaking Gremlin bag/multiset semantics — g.v(["A","C"]).out().count() gave
1 not 2 when both reach B. Rewrote to per-traverser emission (duplicates
preserved); set semantics is now the explicit `dedup()` step. +test
out_preserves_bag_multiplicity.

(2) aiwar: aiwar_node_rows wrote cross-category adapter bytes into the first
12 in_family slots (labeled `linked` by project_snapshot), so `references`
queries missed them and the label flipped with sorted fan-out count. aiwar
edges are ALL cross-family (built from tf != fam) → write them to the 4
out_family slots (`references`), cap 4. Test asserts `references` present and
no `linked`.

contract aiwar 3/3; callcenter gremlin 8/8 (+1 bag test); clippy clean (new
files; pre-existing TD-CALLCENTER-QUERY-CLIPPY untouched).

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

Author: claude

.claude/board/AGENT_LOG.md

@@ -1,3 +1,7 @@
+## 2026-06-20 (cont.⁹) — PR #560 codex P2 review fixes (gremlin bag semantics + aiwar cross-family edges)
+
+**Main thread (Opus), autoattended.** Two unresolved P2 codex threads on PR #560, both fixed: (1) `graph_gremlin.rs` `step()` silently deduped targets via a `seen` set — broke Gremlin bag/multiset semantics (`v(["A","C"]).out().count()` = 1 not 2 when both reach B). Rewrote to per-traverser emission (duplicates preserved); added explicit `dedup()` step + `out_preserves_bag_multiplicity` test. (2) `aiwar.rs` `aiwar_node_rows` put cross-category adapter bytes into the first 12 `in_family` slots (labeled `linked`), so `references` queries missed them and the label flipped with fan-out count — aiwar edges are ALL cross-family, so they now go to the 4 `out_family` slots (`references`), cap 4; test asserts `references` present + no `linked`. contract aiwar 3/3, callcenter gremlin 8/8 (+1 bag test), clippy clean (my files; pre-existing TD-CALLCENTER-QUERY-CLIPPY untouched). Pushed to #560; both review threads resolved. **558/559 (NOT mine — OpenProject/Redmine ontology bridges) checked: NOT all resolved** — #558 2 open (codex P2 seed-context-id + CodeRabbit unit-tests), #559 1 open P1 (Redmine/OpenProject entity_type_id convergence). Surfaced to operator (different arc); not auto-fixed.
+
 ## 2026-06-20 (cont.⁸) — D-GV2-1 shipped: GUID v2 tail (leaf·family·identity 3×u16), feature-gated
 
 **Main thread (Opus), autoattended.** Operator "go" on the guid-v2-tail plan (canon version bump + capacity numbers accepted). Built **D-GV2-1** additive + `#[cfg(feature="guid-v2-tail")]` + NON-breaking (v1 untouched): `canonical_node::{new_v2, leaf() 10..12, family_v2() 12..14, identity_v2() 14..16, local_key_v2, decode_v2/GuidPartsV2, to_hex_v2, GUID_TAIL_LAYOUT_VERSION_V2=2}`; `hhtl::from_guid_prefix_v2` (HEEL·HIP·TWIG·leaf, 16 nibbles — leaf in path, family/identity in basin tail). Per `I-LEGACY-API-FEATURE-GATED`: distinct v2 names (no silent semantic swap), field-isolation matrix test (vary one tier → only that accessor changes), v1/v2 coexistence test, version-gate const. **Verified BOTH configs:** default `cargo test -p lance-graph-contract --lib` = **703** (unchanged, non-breaking); `--features guid-v2-tail` = **706** (+3 v2 tests); clippy `-D warnings` clean on both. Cutover (rename v2→canonical, deprecate v1, ENVELOPE_LAYOUT_VERSION bump) = D-GV2-5, after D-GV2-2 (family→Codebook registry) / D-GV2-3 (soa_graph per-family edges) / D-GV2-4 (aiwar re-key) consume the v2 accessors. Pushed to jirak (extends PR #560). Plan D-GV2-1 marked SHIPPED.

crates/lance-graph-callcenter/src/graph_gremlin.rs

@@ -83,27 +83,41 @@ impl<'a> Traversal<'a> {
     }
 
     fn step(&mut self, label: Option<&str>, outgoing: bool) {
-        let cur: HashSet<&str> = self.current.iter().map(String::as_str).collect();
+        // Bag/multiset semantics (Gremlin): each current traverser independently
+        // emits its reached targets, so duplicates are PRESERVED — `count()` and
+        // downstream steps reflect edge multiplicity / fan-in. Set semantics is
+        // the explicit `dedup()` step, never implicit (codex P2, PR #560).
+        let cur = std::mem::take(&mut self.current);
         let mut next: Vec<String> = Vec::new();
-        let mut seen: HashSet<String> = HashSet::new();
-        for e in &self.snap.edges {
-            if let Some(l) = label {
-                if e.label != l {
-                    continue;
+        for from_v in &cur {
+            for e in &self.snap.edges {
+                if let Some(l) = label {
+                    if e.label != l {
+                        continue;
+                    }
+                }
+                let (from, to) = if outgoing {
+                    (&e.source, &e.target)
+                } else {
+                    (&e.target, &e.source)
+                };
+                if from == from_v {
+                    next.push(to.clone());
                 }
-            }
-            let (from, to) = if outgoing {
-                (&e.source, &e.target)
-            } else {
-                (&e.target, &e.source)
-            };
-            if cur.contains(from.as_str()) && seen.insert(to.clone()) {
-                next.push(to.clone());
             }
         }
         self.current = next;
     }
 
+    /// Gremlin `dedup()` — collapse to distinct vertices (set semantics). The
+    /// explicit opt-in; every other step preserves bag/multiset multiplicity.
+    #[must_use]
+    pub fn dedup(mut self) -> Self {
+        let mut seen: HashSet<String> = HashSet::new();
+        self.current.retain(|id| seen.insert(id.clone()));
+        self
+    }
+
     /// Terminal `values("kind")` — project the `kind` of each reached vertex
     /// (skips ids that are not present as nodes, e.g. a dangling adapter target).
     #[must_use]
@@ -218,6 +232,21 @@ mod tests {
         assert_eq!(g(&s).v(&["A"]).out_e("member-of").values_kind(), vec!["Family"]);
     }
 
+    #[test]
+    fn out_preserves_bag_multiplicity() {
+        // A→B and C→B: from {A,C}, out() reaches B TWICE (bag semantics);
+        // dedup() collapses to one. No implicit dedup (codex P2, PR #560).
+        let s = GraphSnapshot {
+            nodes: vec![node("A", "X"), node("B", "X"), node("C", "X")],
+            edges: vec![edge("A", "B", "r"), edge("C", "B", "r")],
+            inferences: vec![],
+            contradictions: vec![],
+            timestamp: 0,
+        };
+        assert_eq!(g(&s).v(&["A", "C"]).out().count(), 2);
+        assert_eq!(g(&s).v(&["A", "C"]).out().dedup().count(), 1);
+    }
+
     #[test]
     fn unknown_label_yields_empty() {
         let s = sample();

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

@@ -89,13 +89,15 @@ pub fn aiwar_node_rows(graph: &LiteralGraph) -> Vec<NodeRow> {
                 .collect();
             slots.sort_unstable();
             slots.dedup();
+            // aiwar entities connect ACROSS categories (Nation→System, …); every
+            // adapter here is cross-family (built from `tf != fam`), so they go in
+            // the 4 OUT-of-family slots (labeled `references`), never in-family
+            // (`linked`) — otherwise the label would flip with fan-out count and
+            // `references` queries would miss them (codex P2, PR #560). Cap at the
+            // 4 canonical out-of-family slots.
             let mut edges = EdgeBlock::default();
-            for (k, &b) in slots.iter().take(16).enumerate() {
-                if k < 12 {
-                    edges.in_family[k] = b;
-                } else {
-                    edges.out_family[k - 12] = b;
-                }
+            for (k, &b) in slots.iter().take(4).enumerate() {
+                edges.out_family[k] = b;
             }
             NodeRow {
                 key: NodeGuid::new(
@@ -167,12 +169,17 @@ mod tests {
         // every entity → member-of edge to its category family hub
         let member_of = snap.edges.iter().filter(|e| e.label == "member-of").count();
         assert_eq!(member_of, g.node_count());
-        // Israel (Nation) → the PredictiveAnalytics family hub: a cross-category
-        // family-adapter edge (resolves to a family node, not an individual member)
+        // Israel (Nation) → the PredictiveAnalytics family hub: a cross-CATEGORY
+        // edge, so it carries the out-of-family `references` label — never the
+        // in-family `linked` (aiwar edges are all cross-category).
         assert!(snap
             .edges
             .iter()
-            .any(|e| e.label == "linked" && e.target.starts_with("family:")));
+            .any(|e| e.label == "references" && e.target.starts_with("family:")));
+        assert!(
+            !snap.edges.iter().any(|e| e.label == "linked"),
+            "aiwar edges are all cross-category ⇒ none are in-family `linked`"
+        );
     }
 
     #[test]