test(cli): full generative cross-backend walk (embedded vs CLI) via omnigraph-dst

The same seeded DST op stream now drives BOTH the embedded Omnigraph SDK and
the omnigraph CLI subprocess (Embedded + Cli Backend impls from omnigraph-dst,
binary via CARGO_BIN_EXE_omnigraph), asserting per-step black-box agreement on
the Person/Doc slug sets + traversable edge count, plus op-kind and op-success
parity. Two lockstep walks (same seed + identical reference Model) stay in sync
because both wrap the same engine; any divergence fails before they desync.

Completes the cross-backend item the plan deferred at the crate boundary
(harness in the engine, binary in the CLI). White-box battery stays
embedded-only by construction; the CLI arm gets the black-box oracles.

The walk surfaced one genuine cross-backend behavioral difference, allow-listed
as a known contract (not a transport bug): embedded repair(force=false) returns
Ok and leaves suspicious/unverifiable drift (e.g. RC-1's) in place, while the
CLI `repair --confirm` (no --force) exits non-zero refusing to publish it —
both no-ops on logical data, so the state oracles still agree. Every other op's
success/failure matches exactly, including through RC-1 errors and optimize.

cargo test -p omnigraph-cli --test cli_cross_backend_walk -> 1 passed.

Author: ragnorc

Cargo.lock

@@ -34,3 +34,5 @@ serde_json = { workspace = true }
 tempfile = { workspace = true }
 lance = { workspace = true }
 lance-index = { workspace = true }
+omnigraph-dst = { path = "../omnigraph-dst" }
+futures = { workspace = true }

crates/omnigraph-cli/Cargo.toml

@@ -0,0 +1,111 @@
+//! Cross-backend generative walk (PR-E): the SAME seeded DST op sequence driven
+//! against the embedded `Omnigraph` SDK AND the `omnigraph` CLI subprocess must
+//! agree, per step, on the black-box state (Person/Doc slug sets + traversable
+//! edge count).
+//!
+//! Honest scope: the CLI wraps the SAME engine, so this is NOT a second engine
+//! implementation — it verifies the CLI transport layer (arg parsing, output
+//! serialization, `--store` addressing, `--as` actor resolution) faithfully
+//! reflects the embedded engine across a realistic generative sequence. The
+//! white-box invariant battery stays embedded-only (it needs the real handle);
+//! this is the black-box half the CLI arm can satisfy. Complements the
+//! single-op `parity_matrix.rs` (CLI-local vs CLI-HTTP) and the fixed-sequence
+//! `cli_dst_parity.rs` smoke with a generated, model-driven op stream.
+//!
+//! Lockstep determinism: both walks use the same seed and an identical reference
+//! `Model`, and both wrap the same engine, so the op stream matches step-for-
+//! step. Any divergence in op-kind, success, or resulting state fails the assert
+//! immediately — before the two RNGs/models could desync.
+
+use std::collections::BTreeSet;
+use std::path::PathBuf;
+
+use omnigraph_dst::op::OpKind;
+use omnigraph_dst::{step, Backend, BackendError, Cli, Embedded, Model, Rng};
+
+/// All slug values for a node type, normalized to an order-independent set. The
+/// slug key is matched by suffix so the same parse works for the embedded
+/// `to_rust_json` (`"x.slug"`) and the CLI `--json` shape.
+async fn slugs<B: Backend>(b: &B, ty: &str) -> BTreeSet<String> {
+    let q = format!("query q() {{ match {{ $x: {ty} }} return {{ $x.slug }} }}");
+    let rows = b.query("main", &q).await.expect("slug query");
+    rows.iter()
+        .filter_map(|r| {
+            r.as_object()?
+                .iter()
+                .find(|(k, _)| k.ends_with("slug"))
+                .and_then(|(_, v)| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .collect()
+}
+
+/// The traversable `Knows` edge count (`$a knows $b`) — the black-box edge oracle.
+async fn edge_count<B: Backend>(b: &B) -> usize {
+    let rows = b
+        .query(
+            "main",
+            "query q() { match { $a: Person $a knows $b } return { $a.slug, $b.slug } }",
+        )
+        .await
+        .expect("edge query");
+    rows.len()
+}
+
+#[tokio::test]
+async fn embedded_and_cli_agree_on_seeded_walk() {
+    let bin = PathBuf::from(env!("CARGO_BIN_EXE_omnigraph"));
+
+    for seed in 0..2u64 {
+        let emb_dir = tempfile::tempdir().unwrap();
+        let cli_dir = tempfile::tempdir().unwrap();
+        let emb = Embedded::open_clean(emb_dir.path().to_str().unwrap()).await;
+        let cli = Cli::new(bin.clone(), cli_dir.path().to_str().unwrap().to_string());
+        cli.init().await.expect("cli init");
+
+        let mut emb_rng = Rng::new(seed);
+        let mut cli_rng = Rng::new(seed);
+        let mut emb_model = Model::new();
+        let mut cli_model = Model::new();
+
+        for i in 0..18 {
+            let (ek, eres) = step(&emb, &mut emb_rng, &mut emb_model).await;
+            let (ck, cres) = step(&cli, &mut cli_rng, &mut cli_model).await;
+
+            assert_eq!(ek, ck, "seed={seed} step={i}: op-kind diverged");
+            // Repair's success FLAG legitimately differs across backends and is
+            // NOT asserted: embedded `repair(force=false)` returns Ok and simply
+            // leaves suspicious/unverifiable drift in place (e.g. the drift RC-1
+            // strands), whereas the CLI `repair --confirm` (no --force) EXITS
+            // NON-ZERO when it refuses to publish such drift. A known contract
+            // difference, not a transport bug — repair is a no-op on logical
+            // data either way, so the STATE assertions below must still match.
+            // Every other op's success/failure must agree exactly (same engine).
+            if ek != OpKind::Repair {
+                assert_eq!(
+                    eres.is_ok(),
+                    cres.is_ok(),
+                    "seed={seed} step={i} op[{ek:?}]: success diverged (emb={:?} cli={:?})",
+                    eres.as_ref().err().map(BackendError::message),
+                    cres.as_ref().err().map(BackendError::message),
+                );
+            }
+
+            assert_eq!(
+                slugs(&emb, "Person").await,
+                slugs(&cli, "Person").await,
+                "seed={seed} step={i} op[{ek:?}]: Person slug set diverged"
+            );
+            assert_eq!(
+                slugs(&emb, "Doc").await,
+                slugs(&cli, "Doc").await,
+                "seed={seed} step={i} op[{ek:?}]: Doc slug set diverged"
+            );
+            assert_eq!(
+                edge_count(&emb).await,
+                edge_count(&cli).await,
+                "seed={seed} step={i} op[{ek:?}]: traversable edge count diverged"
+            );
+        }
+    }
+}