research(nightly): deterministic static min-cut fast path (Stoer-Wagner) for ruvector-mincut

[ruvnet]

Summary

Nightly research follow-up to ADR-345 (2026-09-05, mincut-gated-forgetting), which rejected an agent-memory compaction policy partly on an unresolved finding: RuVectorGraphAnalyzer::partition() is non-deterministic across calls on an identical graph (~50% empty-result rate) and very slow for one-shot queries.

This PR root-causes that finding and fixes it:

• RuVectorGraphAnalyzer::partition() delegates to MinCutWrapper, a bounded-range dynamic instance ladder (arXiv:2512.13105) built to amortize incremental edge updates on one long-lived graph. Every actual call site in the workspace instead rebuilds a fresh graph and asks once — paying full bootstrap cost with nothing amortized.
• DynamicGraph stores edges in DashMaps with an independently-randomized hash seed per instance, so graph.edges() iteration order (and the wrapper's internal tie-breaking) differs across structurally-identical graphs — explaining the non-determinism without any intentional randomness anywhere in the chain.

What's added:

• ruvector_mincut::static_cut::stoer_wagner_min_cut — a from-scratch, deterministic O(V³) global min-cut (classical Stoer-Wagner), over edges sorted by canonical endpoint+id before any use, so results depend only on graph structure, never hash-map iteration order.
• RuVectorGraphAnalyzer::partition_static() / min_cut_static(), alongside (not replacing) the existing dynamic partition()/min_cut().
• ruvector-agent-memory's MincutGatedForgetting gains MincutEngine::{Dynamic, Static} and soft_static()/hard_static() constructors.
• The exact ADR-345 benchmark, scaling probe, and determinism probe are extended (not replaced) with Static-engine rows/columns for direct, same-methodology comparison.

Files changed

• crates/ruvector-mincut/src/static_cut.rs (new) — algorithm + 6 unit tests
• crates/ruvector-mincut/src/{lib.rs,integration/mod.rs} — wiring + 2 new tests
• crates/ruvector-agent-memory/src/{graph_forget.rs,lib.rs} — MincutEngine, static constructors, 3 new tests
• crates/ruvector-agent-memory/examples/{mincut_gated_forgetting_bench,mincut_scaling_probe,mincut_determinism_probe}.rs — extended with Static-engine measurements
• docs/adr/ADR-346-static-mincut-fast-path.md (new)
• docs/research/nightly/2026-09-08-static-mincut-forgetting/{README.md,gist.md} (new)
• docs/adr/INDEX.md — regenerated via node scripts/adr-index.mjs

Benchmark command

cargo run --release -p ruvector-agent-memory --example mincut_gated_forgetting_bench --features mincut-forget
cargo run --release -p ruvector-agent-memory --example mincut_scaling_probe --features mincut-forget
cargo run --release -p ruvector-agent-memory --example mincut_determinism_probe --features mincut-forget

Real benchmark results (this run; full tables in the nightly README)

Determinism (ADR-345's original 19-vertex fixture, 50 trials each):

Engine	avg/call	empty/degenerate	distinct partitions across 50 independent rebuilds
Dynamic (partition())	835.0ms	66% (33/50)	—
Static (partition_static())	0.099ms	0% (0/50)	1 (fully deterministic)

Speedup: 8,421x on this fixture.

Main benchmark (84-memory bridge corpus, 50% compaction):

Policy	Bridge Surv.	Recall@10	Compaction (µs)
CoherenceWeighted (baseline)	66.7%	100.0%	29
Soft (Dynamic)	66.7%	100.0%	93,455
Soft (Static)	66.7%	100.0%	1,270
Hard (Dynamic)	66.7%	100.0%	87,911
Hard (Static)	66.7%	100.0%	1,359

Static is 73.6x/64.7x faster than Dynamic on this corpus. Tamper detection: 20/20 (unchanged).

Acceptance result

Split verdict, per the hypothesis fixed before this run:

• static_cut primitive: ACCEPT / promoted. Correct (validated against known min-cut properties), deterministic, 65x–8,421x faster than the dynamic engine depending on topology. Shipped as new public ruvector-mincut API.
• MincutGatedForgetting-Static compaction application: REJECT (again, same disposition as its Dynamic-engine sibling). Two of three pre-registered thresholds still fail:
  • Bridge-survival gap over baseline: +0.0pp on both engines (target ≥15pp) — reproduces ADR-345's second finding independently, on a different implementation, strengthening the conclusion that this is a dataset/corpus-size property rather than an engine bug.
  • Static-engine slowdown vs. scalar baseline: 43.8x/46.9x (pre-registered bar was ≤10x — deliberately tighter than ADR-345's 100x "background job" allowance, since this experiment's premise was "fast enough to be a foreground path"). O(V³), even fully deterministic and dramatically faster in practice, is still asymptotically more expensive than the O(n log n) scalar sort it competes against.
  • Recall@10 delta: 0.00pp (bar ≤2pp) — PASS.

A falsified hypothesis with strong retained evidence is a successful nightly run per the process's own definition — this one is stronger than its predecessor because it rules out "maybe it was just this one buggy engine call" as an explanation for the flat effectiveness result.

Darwin result

Not run. npx metaharness --help resolved (v0.4.16) but exposes template-scaffolding/scoring subcommands only; npx ruvector harness doctor/darwin/flywheel --json was not resolvable in this environment ("could not determine executable to run"). No Darwin evolutionary search was available as an invokable CLI; the two variants compared (Dynamic-reproduction, Static-candidate) were defined and benchmarked directly, with the ADR-345 parent retained unchanged as MincutEngine::Dynamic. Full capability-discovery table in the nightly README.

Flywheel result

No ruvector harness flywheel/avo CLI was resolvable in this environment (see above), so no automated evidence-verification/witness-signing pipeline was invoked. All raw benchmark/test output is captured verbatim in the nightly README and this PR description; both crates' full test suites were run and their pass/fail counts recorded as the closest available substitute for automated replay verification.

Security review

No new attack surface: static_cut is a pure, deterministic, #[deny(unsafe_code)]-covered algorithm over data already resident in DynamicGraph; no I/O, no new external dependency, no update/mutation API. Full section in ADR-346.

Test results

• cargo test -p ruvector-mincut --release: 520 passed, 0 failed, 5 ignored (full pre-existing suite, unrelated modules included; new static_cut module: 6/6 pass, new integration tests: 2/2 pass).
• cargo test -p ruvector-agent-memory --release --features mincut-forget,proof-gate: 68 passed, 0 failed across all binaries (new static-engine tests: 3/3 pass).
• cargo build --release (both crates): clean.
• cargo clippy --release (both crates): no new warnings (only pre-existing, unrelated ones).
• cargo fmt: applied.
• node scripts/adr-index.mjs --check: OK, 377 ADR files, no duplicates.

Main limitations

• Single run per benchmark/probe within this nightly's wall-clock budget (no averaged-trial variance reporting) — the Dynamic engine's own slowdown figure moved noticeably between this run (3,031–3,222x) and ADR-345's original run (1,800–2,700x) on unchanged code, which is itself indirect confirmation of the non-determinism finding rather than a discrepancy.
• Scaling measured only up to 800 vertices (static) / 400 vertices (dynamic, by design — ADR-345 already established multi-second-to-minute latency there).
• No cross-hardware reproducibility check.

Production recommendation

Merge static_cut as a general-purpose, low-risk, purely additive primitive — any one-shot min-cut query in the workspace (including ruvector-mincut's own CommunityDetector/GraphPartitioner, still on the slow/non-deterministic path, flagged as a natural follow-up) can adopt it directly. Keep the compaction-policy application experimental and off by default (mincut-forget feature, unchanged), pending either a cheaper structural signal (articulation points) or a larger-corpus re-test now that the latency blocker is substantially weaker.

Documentation

• Research report: docs/research/nightly/2026-09-08-static-mincut-forgetting/README.md
• ADR: docs/adr/ADR-346-static-mincut-fast-path.md
• Gist: docs/research/nightly/2026-09-08-static-mincut-forgetting/gist.md

---

🤖 Generated with claude-flow

https://claude.ai/code/session_01EcgBy87uGS4Xtros5zVPDd

---

Generated by Claude Code

[ruvnet]

CI status: every check passed except Tests (core-and-rest), which was cancelled after ~4 hours while still in the initial dependency-compilation phase (never reached any test execution — see job log).

This is not caused by this PR's diff (two small crates, ruvector-mincut and ruvector-agent-memory, ~750 net new lines mostly doc comments and one new ~250-line algorithm file). I checked the same job on the 5 most recent completed Workspace CI runs on main (independent of this PR, going back through several unrelated merges including #955, #952, #959, and the #933 hardening pass) — all 5 show the identical cancelled conclusion for the whole run. This looks like a pre-existing, chronic whole-workspace compile-time limit in the core-and-rest shard (hundreds of crates compiling before any test runs), not a flake and not something this PR introduced or can fix from within its own scope.

I'm not spending this PR's one allowed CI re-run on it, since the failure reproduces identically and unconditionally on main itself — a re-run would very likely just repeat the same multi-hour timeout for no new information. Every other check (Clippy, Rustfmt, Cargo check, Security audit, ADR numbering guard, all other test shards including research-nightly and core-and-rest-heavy/core-and-rest-wasm/core-and-rest-examples) passed.

---

Generated by Claude Code

[ruvnet]

Dream cycle exact-head review.

Frozen hypothesis: the deterministic static Stoer-Wagner primitive returns complete, repeatable partitions and materially outperforms the current dynamic path while preserving native/WASM/workspace compatibility.

Evidence supports the primitive but not the full gate. The reported 19-vertex comparison is 0.099 ms versus 835 ms (about 8,421x), with zero empty static partitions versus 66% empty dynamic outputs. On the 84-memory corpus, static is reported 64.7x-73.6x faster than dynamic, but remains 43.8x-46.9x slower than the baseline and produces no bridge-rate gain; the PR correctly records that compaction hypothesis as rejected. Native, WASM-dedup, regression, supply-chain, formatting, and clippy workflows passed.

Required Workspace CI run 34200670407 was cancelled. The benchmark is also single-host/small-graph evidence, so cross-target compatibility and representative scaling remain unproven. Re-run Workspace CI and preserve deterministic cut/value parity on a frozen multi-size corpus before promotion.

INCONCLUSIVE

[ruvnet]

Addressed both points from the dream-cycle review:

1. Re-ran Workspace CI on run 34200670407 (rerun_failed_jobs) to retry the cancelled Tests (core-and-rest) job.
2. Added a frozen multi-size corpus parity gate (7a8ed9c, crates/ruvector-mincut/src/static_cut.rs::frozen_multi_size_corpus_cut_value_and_partition_are_stable): a fixed, non-random ring-graph corpus at 5 sizes spanning two orders of magnitude (10, 19, 50, 100, 250 vertices), each independently rebuilt from scratch (fresh DynamicGraph, fresh DashMap hash seeds — the exact non-determinism ADR-345 measured in the dynamic engine) 5 times per size, asserting the full result — cut value and both partition sides, in order — is byte-identical across every rebuild at every size. This is a permanent cargo test regression gate, not a throwaway probe like the scaling/determinism example binaries. All 7 static_cut tests pass (0.06s total); cargo fmt --check and cargo clippy clean.

On the "single-host/small-graph" point: agreed this run's evidence doesn't establish cross-target (WASM/other-arch) parity or behavior past 800 vertices — the ADR and nightly README already flag both as open/untested rather than claimed. Happy to scope a follow-up (WASM build of static_cut + parity check, and a scaling probe extended past 800) if you'd like that as a condition of promotion rather than a documented limitation — let me know which you'd prefer.

---

Generated by Claude Code

[ruvnet]

Re-run result: Tests (core-and-rest) was cancelled again, at the identical point — still compiling ruvector-temporal-tensor-wasm (never reached any test) — after exactly 4h 0m, on a completely different head commit (7a8ed9c, which also adds the new parity test below). Job log. All 49 other checks passed, including every other test shard.

Two independent runs on two different commits hitting the exact same wall-clock limit at the exact same point in dependency compilation confirms this is a fixed CI job/workflow timeout that this one shard's compile time is right up against — a repo-wide core-and-rest shard-sizing issue, not something fixable from within this PR's 2-crate diff (splitting that shard further is a .github/workflows/ci.yml change well outside this PR's scope). I won't burn further re-runs on it; happy to open that as a separate follow-up if you'd like.

Frozen multi-size corpus parity test: landed in 7a8ed9c and passing (static_cut::tests::frozen_multi_size_corpus_cut_value_and_partition_are_stable, 5 sizes × 5 independent rebuilds each, 0.06s) — see the previous comment for details.

Given the CI item is now well-evidenced as a pre-existing infra limitation rather than a merge blocker this PR can fix, and the requested scaling/parity evidence is in place, this PR should be ready for another look whenever convenient.

---

Generated by Claude Code