diff --git a/crates/gf-api/tests/bdd/tck_steps.rs b/crates/gf-api/tests/bdd/tck_steps.rs
index f8b7d31c..3f45d9c6 100644
--- a/crates/gf-api/tests/bdd/tck_steps.rs
+++ b/crates/gf-api/tests/bdd/tck_steps.rs
@@ -8,7 +8,9 @@
 //! steps. Tiers are added (and `@skip-rust` removed feature-by-feature) as more
 //! step vocabulary and result-value types are supported (#598–#601).
 
-use arrow::array::{Array, BooleanArray, Float64Array, Int64Array, StringArray};
+use arrow::array::{
+    Array, BooleanArray, Float64Array, Int64Array, ListArray, StringArray, StructArray,
+};
 use arrow::datatypes::DataType;
 use cucumber::gherkin::Step;
 use cucumber::{given, then, when};
@@ -30,6 +32,26 @@ async fn given_any_graph(world: &mut GraphForgeWorld) {
     world.last_exec = None;
 }
 
+/// `And having executed:` followed by a `"""…"""` setup query (typically a
+/// `CREATE`). Runs it against the forge and asserts it succeeded — the graph
+/// state it builds is what the scenario's main query then reads. (`Given an
+/// empty graph` is provided by `api_steps`; reused here to avoid a duplicate.)
+#[given("having executed:")]
+async fn given_having_executed(world: &mut GraphForgeWorld, step: &Step) {
+    let query = step
+        .docstring
+        .as_deref()
+        .expect("`And having executed:` requires a doc-string query")
+        .trim();
+    let forge = world
+        .forge
+        .as_ref()
+        .expect("a forge must exist (set up by a Given step)");
+    forge
+        .execute(query)
+        .unwrap_or_else(|e| panic!("setup `having executed` failed for {query:?}: {e}"));
+}
+
 // ---------------------------------------------------------------------------
 // WHEN
 // ---------------------------------------------------------------------------
@@ -165,9 +187,87 @@ fn render_cell(array: &dyn Array, row: usize) -> String {
                 .expect("Utf8 array");
             format!("'{}'", a.value(row))
         }
+        // A whole node value (#785/#889): `Struct{node_uuid, labels, <props>}`.
+        DataType::Struct(fields) if fields.iter().any(|f| f.name() == "labels") => {
+            let s = array
+                .as_any()
+                .downcast_ref::<StructArray>()
+                .expect("Struct array");
+            render_node_struct(s, row)
+        }
+        // A list value (`collect(...)`, `nodes(p)`): render each element.
+        DataType::List(_) => {
+            let l = array
+                .as_any()
+                .downcast_ref::<ListArray>()
+                .expect("List array");
+            let elems = l.value(row);
+            let parts: Vec<String> = (0..elems.len())
+                .map(|i| render_cell(elems.as_ref(), i))
+                .collect();
+            format!("[{}]", parts.join(", "))
+        }
         other => panic!(
             "TCK result rendering is not implemented for Arrow type {other:?} \
-             — extend render_cell() as new tiers are un-skipped"
+             — extend render_cell() as new tiers are un-skipped (relationship / \
+             path / map values are #889 slice 3)"
         ),
     }
 }
+
+/// Render a node-value `Struct` (#785/#889) as the openCypher TCK node literal
+/// `(:Label {key: value, …})`.
+///
+/// - `node_uuid` is omitted: a non-deterministic identity the TCK never
+///   references in expected results.
+/// - Labels come from the `labels` `List<Utf8>` field (`:L1:L2`); a node with no
+///   labels renders none.
+/// - Property keys are emitted in **sorted** order so an actual node compares
+///   equal regardless of the struct's physical field order. (Features are only
+///   un-skipped when their expected node literals are written sorted / have ≤1
+///   property, until a structural comparison lands.)
+fn render_node_struct(s: &StructArray, row: usize) -> String {
+    use std::collections::BTreeMap;
+
+    let mut labels = String::new();
+    if let Some(labels_arr) = s.column_by_name("labels") {
+        let list = labels_arr
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .expect("labels is a List");
+        if !list.is_null(row) {
+            let vals = list.value(row);
+            let strs = vals
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .expect("labels are Utf8");
+            for i in 0..strs.len() {
+                if !strs.is_null(i) {
+                    labels.push(':');
+                    labels.push_str(strs.value(i));
+                }
+            }
+        }
+    }
+
+    let mut props: BTreeMap<String, String> = BTreeMap::new();
+    for (i, field) in s.fields().iter().enumerate() {
+        let name = field.name();
+        if name == "node_uuid" || name == "labels" {
+            continue;
+        }
+        props.insert(name.clone(), render_cell(s.column(i).as_ref(), row));
+    }
+
+    let props_str = if props.is_empty() {
+        String::new()
+    } else {
+        let body = props
+            .iter()
+            .map(|(k, v)| format!("{k}: {v}"))
+            .collect::<Vec<_>>()
+            .join(", ");
+        format!(" {{{body}}}")
+    };
+    format!("({labels}{props_str})")
+}
diff --git a/crates/gf-api/tests/tck_coverage.rs b/crates/gf-api/tests/tck_coverage.rs
index d3b0aa1f..7ac8947e 100644
--- a/crates/gf-api/tests/tck_coverage.rs
+++ b/crates/gf-api/tests/tck_coverage.rs
@@ -2,15 +2,19 @@
 //! vendored TCK feature files. Runs as part of the `BDD — Rust` CI gate, so no
 //! separate CI job is needed.
 //!
-//! Invariant: a feature's `rust_status` is `"passing"` **iff** it carries no
-//! `@skip-rust` tag (i.e. it actually runs in the BDD suite, which uses
-//! `fail_on_skipped` — so an un-skipped feature that did not pass would already
-//! fail CI). Combined, that gives: `rust_status == "passing"` ⟹ the feature runs
-//! and passes. The matrix also must cover every feature file exactly once.
+//! Per-scenario aware (#889 slice 2): a scenario RUNS unless the feature OR the
+//! scenario carries `@skip-rust` (mirroring the BDD runner's filter, which uses
+//! `fail_on_skipped` — so a runnable scenario that did not pass would already
+//! fail CI). For each feature the matrix records `scenarios` (total expanded)
+//! and `scenarios_passing` (the runnable subset), and a `rust_status` of:
+//!   - `passing` — all scenarios run (feature un-skipped, none tagged);
+//!   - `skip`    — none run;
+//!   - `partial` — some run (per-scenario `@skip-rust` on the rest).
+//! So `scenarios_passing > 0` ⟹ that many scenarios run and pass.
 //!
-//! **Regression floor:** moving a feature `passing` → `skip` requires editing
-//! both the tag and this matrix, which is visible in review and rejected by
-//! policy (see `docs/reference/tck-compliance.md`).
+//! **Regression floor:** lowering a feature's `scenarios_passing` (re-tagging a
+//! runnable scenario `@skip-rust`) requires editing both the tag and this matrix,
+//! visible in review and rejected by policy (see `docs/reference/tck-compliance.md`).
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
@@ -22,89 +26,141 @@ fn workspace_root() -> PathBuf {
         .expect("workspace root must exist")
 }
 
-/// The number of scenarios cucumber actually **runs** for one feature file: a
-/// plain `Scenario` counts once; a `Scenario Outline` (or `Scenario Template`)
-/// counts one per `Examples` data row (summed across multiple `Examples`
-/// blocks). This is the *expanded* count — the denominator the 100% gate
-/// (#609/#742) is defined against — not the count of authored blocks.
+/// `(total, passing)` expanded scenarios for one feature file: `total` counts
+/// every scenario cucumber would expand (a `Scenario` = 1; a `Scenario Outline`
+/// / `Scenario Template` = one per `Examples` data row); `passing` counts those
+/// that actually RUN — i.e. neither the feature nor the scenario carries
+/// `@skip-rust`.
 ///
-/// Done by line scanning (not a full gherkin parse) so it is robust to the
-/// `And`/`But`-continuation quirk the runner normalizes at load time (#886);
-/// counting `Scenario`/`Examples`/table lines needs no such normalization.
-fn expanded_scenarios(text: &str) -> usize {
+/// Line-scanned (not a full gherkin parse) so it is robust to the `And`/`But`
+/// continuation quirk the runner normalizes at load time (#886). Tags are the
+/// contiguous `@…` lines immediately above a `Feature:`/`Scenario:` line.
+fn feature_breakdown(text: &str) -> (usize, usize) {
     let lines: Vec<&str> = text.lines().collect();
     let n = lines.len();
+    let mut total = 0usize;
+    let mut passing = 0usize;
+    let mut feature_skipped = false;
+    // `@skip-rust` seen in the current contiguous tag block (above the next
+    // Feature/Scenario line).
+    let mut pending_skip = false;
     let mut i = 0;
-    let mut count = 0usize;
     while i < n {
         let t = lines[i].trim_start();
-        if t.starts_with("Scenario Outline:") || t.starts_with("Scenario Template:") {
-            // Sum the data rows of every Examples block until the next
-            // scenario/feature boundary (an outline contributes one run per row).
-            let mut rows = 0usize;
-            let mut j = i + 1;
-            while j < n {
-                let u = lines[j].trim_start();
-                if u.starts_with("Scenario:")
-                    || u.starts_with("Scenario Outline:")
-                    || u.starts_with("Scenario Template:")
-                    || u.starts_with("Feature:")
-                {
-                    break;
-                }
-                if u.starts_with("Examples:") || u.starts_with("Scenarios:") {
-                    j += 1;
-                    let mut header_seen = false;
-                    while j < n {
-                        let v = lines[j].trim_start();
-                        if v.starts_with('|') {
-                            // The first table row is the header, not a run.
-                            if header_seen {
-                                rows += 1;
+        if t.starts_with('@') {
+            pending_skip |= t.contains("skip-rust");
+            i += 1;
+            continue;
+        }
+        if t.starts_with("Feature:") {
+            feature_skipped = pending_skip;
+            pending_skip = false;
+            i += 1;
+            continue;
+        }
+        let is_outline = t.starts_with("Scenario Outline:") || t.starts_with("Scenario Template:");
+        if is_outline || t.starts_with("Scenario:") {
+            let scenario_skipped = feature_skipped || pending_skip;
+            pending_skip = false;
+            let expanded = if is_outline {
+                // Sum the data rows of every Examples block until the next
+                // scenario/feature boundary.
+                let mut rows = 0usize;
+                let mut j = i + 1;
+                while j < n {
+                    let u = lines[j].trim_start();
+                    if u.starts_with("Scenario:")
+                        || u.starts_with("Scenario Outline:")
+                        || u.starts_with("Scenario Template:")
+                        || u.starts_with("Feature:")
+                    {
+                        break;
+                    }
+                    // A tag block: tags that introduce the NEXT scenario/feature
+                    // must NOT be consumed here (the outer loop needs to see them
+                    // to set `pending_skip`); tags on an Examples block belong to
+                    // this outline and are scanned through. Look past the
+                    // contiguous `@…` block to decide.
+                    if u.starts_with('@') {
+                        let mut k = j;
+                        while k < n && lines[k].trim_start().starts_with('@') {
+                            k += 1;
+                        }
+                        let after = lines.get(k).map_or("", |l| l.trim_start());
+                        if after.starts_with("Scenario:")
+                            || after.starts_with("Scenario Outline:")
+                            || after.starts_with("Scenario Template:")
+                            || after.starts_with("Feature:")
+                        {
+                            break;
+                        }
+                        j = k;
+                        continue;
+                    }
+                    if u.starts_with("Examples:") || u.starts_with("Scenarios:") {
+                        j += 1;
+                        let mut header_seen = false;
+                        while j < n {
+                            let v = lines[j].trim_start();
+                            if v.starts_with('|') {
+                                if header_seen {
+                                    rows += 1;
+                                } else {
+                                    header_seen = true;
+                                }
+                                j += 1;
                             } else {
-                                header_seen = true;
+                                break;
                             }
-                            j += 1;
-                        } else {
-                            break;
                         }
+                        continue;
                     }
-                    continue;
+                    j += 1;
                 }
-                j += 1;
+                i = j;
+                rows
+            } else {
+                i += 1;
+                1
+            };
+            total += expanded;
+            if !scenario_skipped {
+                passing += expanded;
             }
-            count += rows;
-            i = j;
-        } else if t.starts_with("Scenario:") {
-            count += 1;
-            i += 1;
-        } else {
-            i += 1;
+            continue;
         }
+        // Any other line (step / blank / table / docstring) ends a tag block.
+        pending_skip = false;
+        i += 1;
+    }
+    (total, passing)
+}
+
+/// The `rust_status` a feature's `(total, passing)` breakdown implies.
+fn status_for(total: usize, passing: usize) -> &'static str {
+    if passing == 0 {
+        "skip"
+    } else if passing == total {
+        "passing"
+    } else {
+        "partial"
     }
-    count
 }
 
-/// (`relative path`, (has `@skip-rust`, expanded-scenario count)) for every
-/// `.feature` under `dir`.
-fn collect_features(dir: &Path, root: &Path, out: &mut BTreeMap<String, (bool, usize)>) {
+/// `relative path` → `(total, passing)` for every `.feature` under `dir`.
+fn collect_features(dir: &Path, root: &Path, out: &mut BTreeMap<String, (usize, usize)>) {
     for entry in std::fs::read_dir(dir).expect("read TCK feature dir") {
         let path = entry.expect("dir entry").path();
         if path.is_dir() {
             collect_features(&path, root, out);
         } else if path.extension().is_some_and(|x| x == "feature") {
             let text = std::fs::read_to_string(&path).expect("read feature file");
-            let skipped = text.lines().any(|l| {
-                let t = l.trim_start();
-                t.starts_with('@') && t.contains("skip-rust")
-            });
-            let scenarios = expanded_scenarios(&text);
             let rel = path
                 .strip_prefix(root)
                 .expect("under features root")
                 .to_string_lossy()
                 .replace('\\', "/");
-            out.insert(rel, (skipped, scenarios));
+            out.insert(rel, feature_breakdown(&text));
         }
     }
 }
@@ -138,27 +194,91 @@ fn coverage_matrix_matches_feature_tags() {
         "coverage_matrix.json has entries with no feature file: {extra:?}"
     );
 
-    // 2. rust_status and scenario counts agree with the feature files.
-    for (rel, (skipped, scenarios)) in &actual {
+    // 2. rust_status, total scenarios, and passing scenarios agree with the
+    //    feature files' @skip-rust tags.
+    let mut meta_passing = 0u64;
+    for (rel, (total, passing)) in &actual {
         let entry = &entries[rel];
         let status = entry["rust_status"].as_str().expect("rust_status string");
-        let expected = if *skipped { "skip" } else { "passing" };
         assert_eq!(
             status,
-            expected,
-            "{rel}: coverage matrix says rust_status={status:?} but the feature is {}. \
-             A 'passing' feature must have its @skip-rust tag removed (and vice versa); \
-             regression floor: do not move a feature passing -> skip.",
-            if *skipped {
-                "tagged @skip-rust"
-            } else {
-                "un-skipped"
-            }
+            status_for(*total, *passing),
+            "{rel}: matrix rust_status={status:?} but the file has {passing}/{total} runnable. \
+             Un-skip/skip a scenario by editing its @skip-rust tag AND this matrix; \
+             regression floor: do not lower a feature's passing count."
         );
         let m_scen = entry["scenarios"].as_u64().expect("scenarios number") as usize;
         assert_eq!(
-            m_scen, *scenarios,
-            "{rel}: matrix scenarios={m_scen} but the file has {scenarios} — regenerate the matrix"
+            m_scen, *total,
+            "{rel}: matrix scenarios={m_scen} but the file has {total} — regenerate the matrix"
         );
+        let m_pass = entry["scenarios_passing"]
+            .as_u64()
+            .expect("scenarios_passing number") as usize;
+        assert_eq!(
+            m_pass, *passing,
+            "{rel}: matrix scenarios_passing={m_pass} but the file has {passing} runnable — \
+             regenerate the matrix"
+        );
+        meta_passing += *passing as u64;
     }
+
+    // 3. `_meta.scenarios_passing` is the corpus-wide total of the per-feature
+    //    passing counts.
+    let meta = matrix["_meta"]
+        .get("scenarios_passing")
+        .and_then(serde_json::Value::as_u64)
+        .expect("_meta.scenarios_passing");
+    assert_eq!(
+        meta, meta_passing,
+        "_meta.scenarios_passing={meta} but the per-feature passing counts sum to {meta_passing}"
+    );
+}
+
+#[test]
+fn breakdown_respects_scenario_tag_after_outline() {
+    // Regression guard (#899): a scenario-scoped `@skip-rust` that FOLLOWS an
+    // outline's Examples must still be seen — the outline scan must stop before
+    // the next scenario's tag block, not consume it.
+    let text = "\
+@skip-node
+Feature: F
+  Scenario Outline: O
+    When something
+    Examples:
+      | x |
+      | 1 |
+      | 2 |
+
+  @skip-rust
+  Scenario: S
+    When something
+";
+    assert_eq!(
+        feature_breakdown(text),
+        (3, 2),
+        "2 outline rows + 1 scenario = 3 total; S is @skip-rust so passing = 2"
+    );
+}
+
+#[test]
+fn breakdown_keeps_tagged_examples_in_the_outline() {
+    // The converse: a tag block on an Examples block belongs to the outline —
+    // its rows are still counted (the scan must not stop at that tag).
+    let text = "\
+@skip-node
+Feature: F
+  Scenario Outline: O
+    When something
+    @some-tag
+    Examples:
+      | x |
+      | 1 |
+      | 2 |
+";
+    assert_eq!(
+        feature_breakdown(text),
+        (2, 2),
+        "tagged Examples rows still counted"
+    );
 }
diff --git a/docs/reference/tck-compliance.md b/docs/reference/tck-compliance.md
index fbd7a49d..18bbdaa7 100644
--- a/docs/reference/tck-compliance.md
+++ b/docs/reference/tck-compliance.md
@@ -21,13 +21,17 @@ So "100%" means **every scenario passes or is an explicit, justified xfail**.
 
 | | runnable scenarios (expanded) |
 |---|---|
-| Passing | **6** |
-| Skipped (`@skip-rust`, pending tiers) | 3,874 |
+| Passing | **9** |
+| Skipped (`@skip-rust`, pending tiers) | 3,871 |
 | **Total** | **3,880** (1,615 authored blocks) |
 
-Only `expressions/literals/Literals1.feature` (boolean / null literals) is un-skipped so far. The
-remaining tiers (#598–#601) un-skip feature-by-feature as the engine's Cypher coverage lands. The
-coverage matrix is the source of truth for per-feature status.
+Un-skipped so far: `expressions/literals/Literals1.feature` (6, boolean/null literals) and
+`clauses/with/With1.feature` (3 of 6 — node/null forwarding through `WITH`; the relationship/path/
+optional-match scenarios stay tagged). Un-skipping is now **per-scenario**: the corpus features
+interleave supported and unsupported scenarios, so a feature is un-skipped by removing its
+feature-level `@skip-rust` and tagging only the still-unsupported scenarios. The remaining tiers
+(#598–#601) grow this as the engine's Cypher coverage lands. The coverage matrix is the source of
+truth for per-feature status.
 
 ## How it works
 
@@ -35,36 +39,40 @@ coverage matrix is the source of truth for per-feature status.
   corpus filtered to scenarios **not** tagged `@skip-rust`, under `fail_on_skipped` +
   `filter_run_and_exit` — so an un-skipped scenario that does not pass fails the `BDD — Rust` CI gate.
 - **Coverage matrix.** `tests/tck/coverage_matrix.json` records each feature's `rust_status`
-  (`passing` | `skip`) and its expanded scenario count (`_meta.scenarios_total` = 3,880, the gate
-  denominator). `crates/gf-api/tests/tck_coverage.rs` asserts the matrix stays in sync with the
-  `@skip-rust` tags, covers every feature exactly once, and that each count matches the corpus.
-  Together that gives: `rust_status == "passing"` ⟹ the feature runs and passes.
-- **Un-skipping a tier.** Remove `@skip-rust` from the feature(s), regenerate the matrix, and confirm
+  (`passing` = all scenarios run, `partial` = some run, `skip` = none), its expanded `scenarios`
+  count, and `scenarios_passing` (the runnable subset). `_meta.scenarios_total` = 3,880 (the gate
+  denominator) and `_meta.scenarios_passing` is the corpus-wide passing total.
+  `crates/gf-api/tests/tck_coverage.rs` recomputes all of this from the feature files' `@skip-rust`
+  tags and fails CI on any drift. Together that gives: `scenarios_passing` ⟹ that many scenarios run
+  and pass.
+- **Un-skipping (per-scenario).** Remove the feature-level `@skip-rust` (keep `@skip-node`), add
+  `@skip-rust` above each still-unsupported scenario, regenerate the matrix, and confirm
   `cargo test -p gf-api --test bdd` is green.
 
 ## Regression floor
 
-Once a feature is `passing` it **must not** regress to `skip` or failing. Mechanically: a passing
-feature carries no `@skip-rust` tag and runs under `fail_on_skipped`, so it cannot silently fail; and
-moving it back to `skip` requires editing **both** the tag and the matrix — visible in review and
-rejected by policy. (This revives the v0.3.x regression-floor policy for the Rust core.)
+A feature's `scenarios_passing` **must not** drop: a runnable scenario carries no `@skip-rust` and
+runs under `fail_on_skipped`, so it cannot silently fail; re-tagging one `@skip-rust` requires editing
+**both** the tag and the matrix — visible in review and rejected by policy. (This revives the v0.3.x
+regression-floor policy for the Rust core, now at scenario granularity.)
 
 ## Documented xfails
 
 Scenarios for features GraphForge does not implement as Cypher are recorded here as their tiers are
-un-skipped. None are formally tracked yet (only `Literals1` is un-skipped). Known intended exclusions
-to record when reached:
+un-skipped. None are formally tracked yet (only `Literals1` and part of `With1` are un-skipped).
+Known intended exclusions to record when reached:
 
 - `CALL` procedures — graph algorithms are `db.gds.*` analyst verbs (M18/M19), not Cypher procedures.
 - *(extended as encountered.)*
 
 ## Regenerating the matrix
 
-The matrix is derived from the corpus: for each `tests/tck/features/**/*.feature`, `rust_status` is
-`skip` when an `@skip-rust` feature tag is present (else `passing`), and `scenarios` is the **expanded**
-runnable count (a `Scenario` counts 1; a `Scenario Outline` counts one per `Examples` data row, summed
-across blocks). Re-walk the corpus to regenerate, then run `cargo test -p gf-api --test tck_coverage`
-— it recomputes both from the feature files and fails on any drift.
+The matrix is derived from the corpus: for each `tests/tck/features/**/*.feature`, `scenarios` is the
+**expanded** count (a `Scenario` = 1; a `Scenario Outline` = one per `Examples` data row),
+`scenarios_passing` is the subset that runs (neither the feature nor the scenario carries
+`@skip-rust`), and `rust_status` is `passing`/`partial`/`skip` accordingly. Re-walk the corpus to
+regenerate, then run `cargo test -p gf-api --test tck_coverage` — it recomputes all of this from the
+feature files and fails on any drift.
 
 ---
 
diff --git a/tests/tck/coverage_matrix.json b/tests/tck/coverage_matrix.json
index 462e63f0..b4b7fec1 100644
--- a/tests/tck/coverage_matrix.json
+++ b/tests/tck/coverage_matrix.json
@@ -3,890 +3,1110 @@
     "corpus": "openCypher TCK tag 2024.3 (vendored, #874)",
     "feature_files": 220,
     "scenarios_total": 3880,
-    "scenarios_passing": 6,
+    "scenarios_passing": 9,
     "scenarios_written": 1615,
-    "note": "rust_status: 'passing' = no @skip-rust tag; runs and passes in the BDD suite (crates/gf-api/tests/bdd, fail_on_skipped). 'skip' = @skip-rust. 'scenarios' is the EXPANDED scenario count cucumber runs: a Scenario counts 1, a Scenario Outline counts its Examples data rows. scenarios_total (3880) is the 100%-gate denominator (#609/#742); scenarios_written (1615) is the authored Scenario/Outline block count, for reference. Regression floor: a feature MUST NOT move passing -> skip (see docs/reference/tck-compliance.md). The Rust consistency test (crates/gf-api/tests/tck_coverage.rs) recomputes these from the feature files and fails CI on any drift."
+    "note": "Per-scenario aware (#889). 'scenarios' is the EXPANDED runnable count cucumber runs (Scenario=1; Scenario Outline=one per Examples data row). 'scenarios_passing' is the subset that RUNS: a scenario runs unless the feature OR the scenario carries @skip-rust (the BDD runner uses fail_on_skipped, so a runnable scenario that failed would fail CI). rust_status: 'passing'=all run, 'partial'=some run (per-scenario @skip-rust on the rest), 'skip'=none. scenarios_total (3880) is the 100%-gate denominator (#609/#742). Regression floor: do not lower a feature's scenarios_passing. crates/gf-api/tests/tck_coverage.rs recomputes all of this from the feature files and fails CI on drift."
   },
   "features": {
     "clauses/call/Call1.feature": {
       "rust_status": "skip",
-      "scenarios": 16
+      "scenarios": 16,
+      "scenarios_passing": 0
     },
     "clauses/call/Call2.feature": {
       "rust_status": "skip",
-      "scenarios": 6
+      "scenarios": 6,
+      "scenarios_passing": 0
     },
     "clauses/call/Call3.feature": {
       "rust_status": "skip",
-      "scenarios": 6
+      "scenarios": 6,
+      "scenarios_passing": 0
     },
     "clauses/call/Call4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/call/Call5.feature": {
       "rust_status": "skip",
-      "scenarios": 19
+      "scenarios": 19,
+      "scenarios_passing": 0
     },
     "clauses/call/Call6.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/create/Create1.feature": {
       "rust_status": "skip",
-      "scenarios": 20
+      "scenarios": 20,
+      "scenarios_passing": 0
     },
     "clauses/create/Create2.feature": {
       "rust_status": "skip",
-      "scenarios": 24
+      "scenarios": 24,
+      "scenarios_passing": 0
     },
     "clauses/create/Create3.feature": {
       "rust_status": "skip",
-      "scenarios": 13
+      "scenarios": 13,
+      "scenarios_passing": 0
     },
     "clauses/create/Create4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/create/Create5.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/create/Create6.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete1.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete2.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete3.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete4.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete5.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "clauses/delete/Delete6.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere1.feature": {
       "rust_status": "skip",
-      "scenarios": 15
+      "scenarios": 15,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere2.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere5.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "clauses/match-where/MatchWhere6.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "clauses/match/Match1.feature": {
       "rust_status": "skip",
-      "scenarios": 86
+      "scenarios": 86,
+      "scenarios_passing": 0
     },
     "clauses/match/Match2.feature": {
       "rust_status": "skip",
-      "scenarios": 86
+      "scenarios": 86,
+      "scenarios_passing": 0
     },
     "clauses/match/Match3.feature": {
       "rust_status": "skip",
-      "scenarios": 30
+      "scenarios": 30,
+      "scenarios_passing": 0
     },
     "clauses/match/Match4.feature": {
       "rust_status": "skip",
-      "scenarios": 10
+      "scenarios": 10,
+      "scenarios_passing": 0
     },
     "clauses/match/Match5.feature": {
       "rust_status": "skip",
-      "scenarios": 29
+      "scenarios": 29,
+      "scenarios_passing": 0
     },
     "clauses/match/Match6.feature": {
       "rust_status": "skip",
-      "scenarios": 97
+      "scenarios": 97,
+      "scenarios_passing": 0
     },
     "clauses/match/Match7.feature": {
       "rust_status": "skip",
-      "scenarios": 31
+      "scenarios": 31,
+      "scenarios_passing": 0
     },
     "clauses/match/Match8.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/match/Match9.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge1.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge2.feature": {
       "rust_status": "skip",
-      "scenarios": 6
+      "scenarios": 6,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge3.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge5.feature": {
       "rust_status": "skip",
-      "scenarios": 29
+      "scenarios": 29,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge6.feature": {
       "rust_status": "skip",
-      "scenarios": 6
+      "scenarios": 6,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge7.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge8.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/merge/Merge9.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "clauses/remove/Remove1.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "clauses/remove/Remove2.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/remove/Remove3.feature": {
       "rust_status": "skip",
-      "scenarios": 21
+      "scenarios": 21,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy1.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy2.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy3.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy5.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/return-orderby/ReturnOrderBy6.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/return-skip-limit/ReturnSkipLimit1.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "clauses/return-skip-limit/ReturnSkipLimit2.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "clauses/return-skip-limit/ReturnSkipLimit3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/return/Return1.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/return/Return2.feature": {
       "rust_status": "skip",
-      "scenarios": 18
+      "scenarios": 18,
+      "scenarios_passing": 0
     },
     "clauses/return/Return3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/return/Return4.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "clauses/return/Return5.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/return/Return6.feature": {
       "rust_status": "skip",
-      "scenarios": 21
+      "scenarios": 21,
+      "scenarios_passing": 0
     },
     "clauses/return/Return7.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/return/Return8.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/set/Set1.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "clauses/set/Set2.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/set/Set3.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "clauses/set/Set4.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/set/Set5.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/set/Set6.feature": {
       "rust_status": "skip",
-      "scenarios": 21
+      "scenarios": 21,
+      "scenarios_passing": 0
     },
     "clauses/union/Union1.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/union/Union2.feature": {
       "rust_status": "skip",
-      "scenarios": 5
+      "scenarios": 5,
+      "scenarios_passing": 0
     },
     "clauses/union/Union3.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/unwind/Unwind1.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "clauses/with-orderBy/WithOrderBy1.feature": {
       "rust_status": "skip",
-      "scenarios": 96
+      "scenarios": 96,
+      "scenarios_passing": 0
     },
     "clauses/with-orderBy/WithOrderBy2.feature": {
       "rust_status": "skip",
-      "scenarios": 83
+      "scenarios": 83,
+      "scenarios_passing": 0
     },
     "clauses/with-orderBy/WithOrderBy3.feature": {
       "rust_status": "skip",
-      "scenarios": 93
+      "scenarios": 93,
+      "scenarios_passing": 0
     },
     "clauses/with-orderBy/WithOrderBy4.feature": {
       "rust_status": "skip",
-      "scenarios": 20
+      "scenarios": 20,
+      "scenarios_passing": 0
     },
     "clauses/with-skip-limit/WithSkipLimit1.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/with-skip-limit/WithSkipLimit2.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "clauses/with-skip-limit/WithSkipLimit3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere1.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere2.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere5.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere6.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/with-where/WithWhere7.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "clauses/with/With1.feature": {
-      "rust_status": "skip",
-      "scenarios": 6
+      "rust_status": "partial",
+      "scenarios": 6,
+      "scenarios_passing": 3
     },
     "clauses/with/With2.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/with/With3.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "clauses/with/With4.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "clauses/with/With5.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "clauses/with/With6.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "clauses/with/With7.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation1.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation2.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation3.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation4.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation5.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation6.feature": {
       "rust_status": "skip",
-      "scenarios": 13
+      "scenarios": 13,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation7.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/aggregation/Aggregation8.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "expressions/boolean/Boolean1.feature": {
       "rust_status": "skip",
-      "scenarios": 30
+      "scenarios": 30,
+      "scenarios_passing": 0
     },
     "expressions/boolean/Boolean2.feature": {
       "rust_status": "skip",
-      "scenarios": 30
+      "scenarios": 30,
+      "scenarios_passing": 0
     },
     "expressions/boolean/Boolean3.feature": {
       "rust_status": "skip",
-      "scenarios": 30
+      "scenarios": 30,
+      "scenarios_passing": 0
     },
     "expressions/boolean/Boolean4.feature": {
       "rust_status": "skip",
-      "scenarios": 52
+      "scenarios": 52,
+      "scenarios_passing": 0
     },
     "expressions/boolean/Boolean5.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "expressions/comparison/Comparison1.feature": {
       "rust_status": "skip",
-      "scenarios": 43
+      "scenarios": 43,
+      "scenarios_passing": 0
     },
     "expressions/comparison/Comparison2.feature": {
       "rust_status": "skip",
-      "scenarios": 19
+      "scenarios": 19,
+      "scenarios_passing": 0
     },
     "expressions/comparison/Comparison3.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/comparison/Comparison4.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/conditional/Conditional1.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/conditional/Conditional2.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "expressions/existentialSubqueries/ExistentialSubquery1.feature": {
       "rust_status": "skip",
-      "scenarios": 4
+      "scenarios": 4,
+      "scenarios_passing": 0
     },
     "expressions/existentialSubqueries/ExistentialSubquery2.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "expressions/existentialSubqueries/ExistentialSubquery3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph1.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph2.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph3.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph4.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph5.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph6.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph7.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph8.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "expressions/graph/Graph9.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "expressions/list/List1.feature": {
       "rust_status": "skip",
-      "scenarios": 23
+      "scenarios": 23,
+      "scenarios_passing": 0
     },
     "expressions/list/List10.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/list/List11.feature": {
       "rust_status": "skip",
-      "scenarios": 67
+      "scenarios": 67,
+      "scenarios_passing": 0
     },
     "expressions/list/List12.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "expressions/list/List2.feature": {
       "rust_status": "skip",
-      "scenarios": 15
+      "scenarios": 15,
+      "scenarios_passing": 0
     },
     "expressions/list/List3.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "expressions/list/List4.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/list/List5.feature": {
       "rust_status": "skip",
-      "scenarios": 46
+      "scenarios": 46,
+      "scenarios_passing": 0
     },
     "expressions/list/List6.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/list/List7.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/list/List8.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/list/List9.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals1.feature": {
       "rust_status": "passing",
-      "scenarios": 6
+      "scenarios": 6,
+      "scenarios_passing": 6
     },
     "expressions/literals/Literals2.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals3.feature": {
       "rust_status": "skip",
-      "scenarios": 16
+      "scenarios": 16,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals4.feature": {
       "rust_status": "skip",
-      "scenarios": 10
+      "scenarios": 10,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals5.feature": {
       "rust_status": "skip",
-      "scenarios": 27
+      "scenarios": 27,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals6.feature": {
       "rust_status": "skip",
-      "scenarios": 13
+      "scenarios": 13,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals7.feature": {
       "rust_status": "skip",
-      "scenarios": 20
+      "scenarios": 20,
+      "scenarios_passing": 0
     },
     "expressions/literals/Literals8.feature": {
       "rust_status": "skip",
-      "scenarios": 27
+      "scenarios": 27,
+      "scenarios_passing": 0
     },
     "expressions/map/Map1.feature": {
       "rust_status": "skip",
-      "scenarios": 19
+      "scenarios": 19,
+      "scenarios_passing": 0
     },
     "expressions/map/Map2.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "expressions/map/Map3.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical1.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical10.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical11.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical12.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical13.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical14.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical15.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical16.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical17.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical2.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical3.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical4.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical5.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical6.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical7.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical8.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/mathematical/Mathematical9.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/null/Null1.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/null/Null2.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/null/Null3.feature": {
       "rust_status": "skip",
-      "scenarios": 10
+      "scenarios": 10,
+      "scenarios_passing": 0
     },
     "expressions/path/Path1.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/path/Path2.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "expressions/path/Path3.feature": {
       "rust_status": "skip",
-      "scenarios": 3
+      "scenarios": 3,
+      "scenarios_passing": 0
     },
     "expressions/pattern/Pattern1.feature": {
       "rust_status": "skip",
-      "scenarios": 39
+      "scenarios": 39,
+      "scenarios_passing": 0
     },
     "expressions/pattern/Pattern2.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "expressions/precedence/Precedence1.feature": {
       "rust_status": "skip",
-      "scenarios": 55
+      "scenarios": 55,
+      "scenarios_passing": 0
     },
     "expressions/precedence/Precedence2.feature": {
       "rust_status": "skip",
-      "scenarios": 26
+      "scenarios": 26,
+      "scenarios_passing": 0
     },
     "expressions/precedence/Precedence3.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "expressions/precedence/Precedence4.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier1.feature": {
       "rust_status": "skip",
-      "scenarios": 105
+      "scenarios": 105,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier10.feature": {
       "rust_status": "skip",
-      "scenarios": 8
+      "scenarios": 8,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier11.feature": {
       "rust_status": "skip",
-      "scenarios": 22
+      "scenarios": 22,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier12.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier2.feature": {
       "rust_status": "skip",
-      "scenarios": 106
+      "scenarios": 106,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier3.feature": {
       "rust_status": "skip",
-      "scenarios": 105
+      "scenarios": 105,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier4.feature": {
       "rust_status": "skip",
-      "scenarios": 105
+      "scenarios": 105,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier5.feature": {
       "rust_status": "skip",
-      "scenarios": 31
+      "scenarios": 31,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier6.feature": {
       "rust_status": "skip",
-      "scenarios": 21
+      "scenarios": 21,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier7.feature": {
       "rust_status": "skip",
-      "scenarios": 36
+      "scenarios": 36,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier8.feature": {
       "rust_status": "skip",
-      "scenarios": 31
+      "scenarios": 31,
+      "scenarios_passing": 0
     },
     "expressions/quantifier/Quantifier9.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/string/String1.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/string/String10.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/string/String11.feature": {
       "rust_status": "skip",
-      "scenarios": 2
+      "scenarios": 2,
+      "scenarios_passing": 0
     },
     "expressions/string/String12.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String13.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String14.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String2.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String3.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/string/String4.feature": {
       "rust_status": "skip",
-      "scenarios": 1
+      "scenarios": 1,
+      "scenarios_passing": 0
     },
     "expressions/string/String5.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String6.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String7.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/string/String8.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/string/String9.feature": {
       "rust_status": "skip",
-      "scenarios": 9
+      "scenarios": 9,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal1.feature": {
       "rust_status": "skip",
-      "scenarios": 207
+      "scenarios": 207,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal10.feature": {
       "rust_status": "skip",
-      "scenarios": 131
+      "scenarios": 131,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal2.feature": {
       "rust_status": "skip",
-      "scenarios": 53
+      "scenarios": 53,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal3.feature": {
       "rust_status": "skip",
-      "scenarios": 183
+      "scenarios": 183,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal4.feature": {
       "rust_status": "skip",
-      "scenarios": 39
+      "scenarios": 39,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal5.feature": {
       "rust_status": "skip",
-      "scenarios": 7
+      "scenarios": 7,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal6.feature": {
       "rust_status": "skip",
-      "scenarios": 17
+      "scenarios": 17,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal7.feature": {
       "rust_status": "skip",
-      "scenarios": 18
+      "scenarios": 18,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal8.feature": {
       "rust_status": "skip",
-      "scenarios": 27
+      "scenarios": 27,
+      "scenarios_passing": 0
     },
     "expressions/temporal/Temporal9.feature": {
       "rust_status": "skip",
-      "scenarios": 322
+      "scenarios": 322,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion1.feature": {
       "rust_status": "skip",
-      "scenarios": 10
+      "scenarios": 10,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion2.feature": {
       "rust_status": "skip",
-      "scenarios": 12
+      "scenarios": 12,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion3.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion4.feature": {
       "rust_status": "skip",
-      "scenarios": 14
+      "scenarios": 14,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion5.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "expressions/typeConversion/TypeConversion6.feature": {
       "rust_status": "skip",
-      "scenarios": 0
+      "scenarios": 0,
+      "scenarios_passing": 0
     },
     "useCases/countingSubgraphMatches/CountingSubgraphMatches1.feature": {
       "rust_status": "skip",
-      "scenarios": 11
+      "scenarios": 11,
+      "scenarios_passing": 0
     },
     "useCases/triadicSelection/TriadicSelection1.feature": {
       "rust_status": "skip",
-      "scenarios": 19
+      "scenarios": 19,
+      "scenarios_passing": 0
     }
   }
 }
diff --git a/tests/tck/features/clauses/with/With1.feature b/tests/tck/features/clauses/with/With1.feature
index 7a0da4ca..3485dab0 100644
--- a/tests/tck/features/clauses/with/With1.feature
+++ b/tests/tck/features/clauses/with/With1.feature
@@ -28,7 +28,7 @@
 
 #encoding: utf-8
 
-@skip-rust @skip-node
+@skip-node
 Feature: With1 - Forward single variable
   # correctly forward of values according to their type, no other effects
 
@@ -69,6 +69,7 @@ Feature: With1 - Forward single variable
       | (:A) | (:B) | (:X) |
     And no side effects
 
+  @skip-rust
   Scenario: [3] Forwarding a relationship variable
     Given an empty graph
     And having executed:
@@ -90,6 +91,7 @@ Feature: With1 - Forward single variable
       | [:T2] |
     And no side effects
 
+  @skip-rust
   Scenario: [4] Forwarding a path variable
     Given an empty graph
     And having executed:
@@ -120,6 +122,7 @@ Feature: With1 - Forward single variable
       | a | b |
     And no side effects
 
+  @skip-rust
   Scenario: [6] Forwarding a node variable possibly null
     Given an empty graph
     And having executed: