Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

adr: ADR-123 β€” sublinear-time-solver integration into RuFlo

ruv06cbb77dcf52
diff --git a/v3/docs/adr/ADR-123-sublinear-integration.md b/v3/docs/adr/ADR-123-sublinear-integration.md
new file mode 100644
index 0000000000..0a4170980a
--- /dev/null
+++ b/v3/docs/adr/ADR-123-sublinear-integration.md
@@ -0,0 +1,513 @@
+# ADR-123 β€” Sublinear-time-solver integration: signed, federatable PageRank as a RuFlo substrate primitive
+
+**Status**: Proposed (2026-05-18)
+**Date**: 2026-05-18
+**Authors**: claude (drafted with rUv)
+**Related**: [`[email protected]`](https://www.npmjs.com/package/sublinear-time-solver) ([crates.io](https://crates.io/crates/sublinear), [github](https://github.com/ruvnet/sublinear-time-solver), [announcement gist](https://gist.github.com/ruvnet/342518ef950348c376bc7c04ffeb5337)), [eleven-wedge research gist](https://gist.github.com/ruvnet/61d6d04af514b3c81ad0abf1e37fe116), ADR-103 (witness temporal history), ADR-104 (federation wire transport), ADR-105 (federation state snapshot), ADR-118 (AIDefence 2.3.0), ADR-121 (embeddings RuVector upgrade), ADR-122 (browser substrate). Library lineage: [Andoni–Krauthgamer–Pogrow ITCS 2019 (SDD sublinear)](https://arxiv.org/abs/1809.02995), [Kyng–Sachdeva FOCS 2016 (approx Cholesky)](https://rasmuskyng.com/research.html), [Asymmetric DD sublinear (2025)](https://arxiv.org/abs/2509.13891), [Friedkin–Johnsen application (2025)](https://arxiv.org/abs/2509.13112).
+**Supersedes**: nothing (additive)
+
+## Core thesis (beyond-SOTA wedge, stated first)
+
+RuFlo is the only agent platform in the field that already ships **Ed25519-signed witness chains** (ADR-103), **portable RVF cognitive containers** (`@ruvector/[email protected]`), and a **federated peer mesh with budgeted transport** (ADR-104/105/111). Layer `[email protected]` on top of that substrate and RuFlo gains a capability that LangGraph, AutoGen, Letta, MemGPT, Mem0, HippoRAG, and every browser-agent vendor structurally cannot produce: **signed, replayable, federatable personalized-PageRank artifacts**.
+
+A signed PR artifact is a single small object that says:
+
+> "Installation A, witness key X, computed personalized PageRank Ο€ over graph G at timestamp T, with Ξ±=0.85, Ξ΅=10⁻³, using single-entry forward-push at row r. Vector hash H. Signature S over (X, T, G-id, Ξ±, Ξ΅, r, H)."
+
+Federation peers can request this object instead of re-walking the graph. A peer that trusts X's witness key can use Ο€ directly. A peer that doesn't can verify the structure, replay the computation locally (single-entry forward-push at `r` over the *same* G is deterministic given Ξ±, Ξ΅), and confirm the byte-for-byte hash. The provenance moat from ADR-122 (signed browser trajectories) generalizes to signed graph-reasoning vectors β€” every PageRank over a causal graph, every transitive-trust closure, every cost-attribution roll-up, every blast-radius score becomes a verifiable, portable artifact rather than an ephemeral local computation.
+
+This is the architectural claim. It is novel against the current literature on agent-memory frameworks ([no existing system combines portability, cryptographic integrity, capability-based access, injection-resistant rehydration, and quantitative fidelity](https://arxiv.org/html/2605.11032v1)) and against the current literature on verifiable inference (which signs *model outputs* via zk-SNARKs, not *graph-reasoning artifacts*; [ZK-DeepSeek, ZKPROV](https://arxiv.org/abs/2511.19902) prove "the model emitted this token" but not "the agent's causal-graph said this span was to blame"). Phase 7 below promotes this primitive to a federation-distributable object.
+
+The rest of the ADR enumerates the eleven graphs RuFlo already runs (from the research gist), the integration mechanics that turn each into a sublinear primitive, and the eight-phase rollout that lands the substrate without regressing ADR-122.
+
+## SOTA exploration
+
+Five axes were surveyed before committing to this design. Each axis closes with the "beyond-SOTA" insight the ADR commits to.
+
+### 1. Sublinear algorithms for diagonally-dominant systems
+
+The foundational result is [Andoni, Krauthgamer, Pogrow, ITCS 2019](https://arxiv.org/abs/1809.02995): a single coordinate of `x` in an SDD system `M x = b` can be approximated in `Γ•(polylog n / Ρ²)` time without materializing the full solution, by combining random-walk sampling with local push. Earlier, [Kyng & Sachdeva, FOCS 2016](https://rasmuskyng.com/research.html) shipped approximate Cholesky factorization for SDD systems, the practical workhorse for full-solve when you need *every* coordinate. The 2025 follow-ups close two important gaps: [Cheng et al. 2509.13891](https://arxiv.org/abs/2509.13891) extends single-entry sublinear solving to **asymmetric** (row- and column-) diagonally-dominant systems by unifying Forward Push and Backward Push under a "maximum p-norm gap" complexity measure, and [Friedkin–Johnsen application 2509.13112](https://arxiv.org/abs/2509.13112) proves a sublinear opinion-estimation algorithm on directed weighted graphs. `[email protected]` is the production-engineered embodiment of this line, with measured 816 ns Conjugate-Gradient solves on n=256 SPD systems and 47% Neumann throughput improvement over 1.5.0 from corrected convergence-exit logic.
+
+**Beyond-SOTA insight committed:** the asymmetric-DD result is load-bearing for RuFlo. Most of the eleven RuFlo graphs are *not* symmetric (federation trust is one-way, span causality is one-way, file imports are one-way, cost attribution is one-way). Many integrations would have stalled on "your matrix is not SDD". The 2025 RDD/CDD result makes them all in-scope.
+
+### 2. GOAP / hierarchical task planning at scale
+
+The classical planning stack β€” Fast Downward, Pyperplan, PDDL β€” gives rigorous guarantees but struggles on long-horizon ambiguous goals. The 2024–2026 wave of work, exemplified by [LaMMA-P](https://arxiv.org/html/2602.21670) and [GoalAct (NCIIP 2025 Best Paper)](https://github.com/cjj826/GoalAct), tightly couples an LLM-driven subtask extraction layer with Fast Downward A\* search to get the best of both. The recurring failure mode in this literature: planners enumerate *every* precondition state as if all edges in the action graph are equally weighted, then take seconds-to-minutes to backtrack out of dead-end branches. [Why Do LLM-based Web Agents Fail?](https://arxiv.org/pdf/2603.14248) attributes most observed failures to hierarchical-planning bottlenecks rather than action-grounding errors.
+
+**Beyond-SOTA insight committed:** RuFlo's `ruflo-goals` plugin can short-circuit dead-end enumeration by formulating the relaxed precondition feasibility problem as a Kyng–Sachdeva packing/covering LP (Wedge 9). Microsecond feasibility checks before invoking A\* search dominate any "smart LLM subgoal proposer" β€” you prune the branch *before* you spawn the LLM call, not after.
+
+### 3. PageRank / personalized PageRank as the agent-substrate primitive
+
+Personalized PageRank (PPR) has quietly become the dominant primitive for agentic memory and retrieval. [HippoRAG](https://graphwise.ai/blog/from-retrieval-to-reasoning-enhancing-hipporag-with-graph-based-semantics/) ([RAG paper, neurobiologically-inspired](https://www.researchgate.net/publication/397199630_HippoRAG_Neurobiologically_Inspired_Long-Term_Memory_for_Large_Language_Models)) uses PPR over an LLM-extracted knowledge graph as a single-step retrieval substitute for multi-hop iterative RAG. Pinterest's Pixie graph-recommendation engine and Microsoft's enterprise search both ship PPR in production for multi-hop entity reasoning. The current frontier is **single-entry** PPR β€” you don't need the full vector, you only need Ο€[r] for a query node r. AKP19 makes this `Γ•(polylog n)`; the 2025 asymmetric extension makes it work on directed/weighted graphs. No agent memory framework in the [2026 comparison surveys](https://vectorize.io/articles/mem0-vs-letta) (Letta, Mem0, MemGPT, LangMem, Zep) ships single-entry PPR β€” they all do full-vector PR (or skip it entirely for vanilla cosine k-NN).
+
+**Beyond-SOTA insight committed:** RuFlo's substrate has *eleven* live graphs (research gist). Every one of them admits a single-entry PPR formulation. The cost is not "build a graph" β€” the graphs already exist; the cost is just plumbing the PPR query through. That's a 100Γ— to 2000Γ— speedup per query against the current baseline implementations (full PR walks), achieved by *substitution*, not by inventing new memory primitives.
+
+### 4. Cryptographic provenance for AI computations
+
+The 2025–2026 verifiable-inference wave centers on **proving the model emitted what it emitted**. [ZK-DeepSeek](https://arxiv.org/abs/2511.19902) translates DeepSeek-V3 (671B params) into a SNARK-verifiable circuit with constant-size proofs; [ZKPROV](https://arxiv.org/html/2506.20915) proves an LLM was trained on a specific authorized dataset; [Lagrange DeepProve](https://lagrange.dev/blog/dynamic-zk-snarks) ships dynamic zk-SNARKs that allow incremental retraining proofs. Separately, the agent-memory security literature has converged on a different conclusion: [memory poisoning is the dominant threat](https://arxiv.org/html/2603.20357v1) and [the failure mode is misattribution of externally injected content as own experience](https://arxiv.org/html/2604.16548v1). Existing defenses fail because they detect malicious actions, not corrupted beliefs.
+
+**Beyond-SOTA insight committed:** RuFlo already has the right primitive to address *both* problems and neither problem is currently addressed by signed model outputs alone. ADR-103's witness chain plus ADR-122's RVF-signed trajectories are domain-specific provenance objects. Extending them to cover signed PageRank vectors (Phase 7 below) means a federation peer can prove "this is the trust-closure I computed over this attested federation membership snapshot at this time with these parameters" β€” a memory-poisoning attack that mutates the trust graph upstream becomes detectable in O(verify) time because the recomputation produces a different hash. zk-SNARK over a sublinear-PR computation is **not** required; an Ed25519 signature over the inputs + hash of the output suffices because the computation is publicly replayable and deterministic given Ξ± and Ξ΅. This is dramatically cheaper than SNARK-circuit-encoded PageRank.
+
+### 5. Competitive landscape for AI-agent memory + planning substrates
+
+| System | Memory tier | Planning | Graph primitive | Cryptographic provenance | Federation |
+|---|---|---|---|---|---|
+| LangGraph + LangMem | Structured store, namespaced | LLM-only | none | none | none |
+| AutoGen | In-context + ext store | LLM-only | none | none | none |
+| Letta (MemGPT) | Three-tier (core / archival / recall) | LLM-managed | none | none | none |
+| Mem0 | Framework-agnostic SDK | none | none | none | none |
+| HippoRAG | KG + PPR retrieval | none | **PPR (full)** | none | none |
+| Zep | Temporal KG | none | partial | none | none |
+| RuFlo (today) | RVF + AgentDB + HNSW | GOAP + MCTS (ADR-122 Phase 4) | partial (HNSW vector) | **Ed25519 + RVF** | **ADR-104/105/111** |
+| **RuFlo (after ADR-123)** | + signed PR artifacts | + microsecond feasibility | **single-entry PPR over 11 graphs** | **signed PR vectors** | **federation-distributable PR cache** |
+
+LangGraph and Letta are locked into their own runtimes; switching means rebuilding the memory layer ([Letta vs LangChain Memory comparison](https://vectorize.io/articles/letta-vs-langchain-memory)). HippoRAG ships PPR but only one (full-vector) and only over one graph. None of the surveyed systems ship cryptographic provenance for *any* memory artifact, let alone graph-reasoning artifacts.
+
+**Beyond-SOTA insight committed:** the comparative gap is not "RuFlo has a sublinear solver while others don't" (that's a library swap any competitor can make in a sprint). The gap is "RuFlo has eleven live graphs *already wired into the substrate* AND it has the cryptographic primitives to sign their reductions AND it has the federation transport to distribute them". The combination is the moat.
+
+## Context β€” the eleven graphs RuFlo already runs
+
+The research gist enumerates eleven plugins whose internals are graph computations that today are paid for in `O(n)` or `O(nnz)` walks. Each one is restated below with the matrix form, the sublinear op that replaces it, the current cost, and the wired-up call site in the repo.
+
+| # | Plugin | Graph | Matrix form | Sublinear op | Today's cost | After |
+|---|---|---|---|---|---|---|
+| 1 | `@claude-flow/browser` (ADR-122 Phase 2) | Selector-break ↔ DOM-mutation causal graph | `(I βˆ’ Ξ±P^T)Ο€ = (1βˆ’Ξ±)e` | Single-entry forward-push | O(N) walk per snapshot | O(log N) per element-ref |
+| 2 | `@claude-flow/browser` (ADR-122 Phases 4 + 7) | MCTS tree | `v = r + Ξ³Pv` (Bellman) | Single-entry PR (value approx) | depth-O(d) UCT-only | O(log branches) global value augment |
+| 3 | `ruflo-federation` | Peer trust mesh | `(I βˆ’ Ξ±T)Ο„ = e` (Ξ±=0.7) | Single-entry forward-push | O(NΒ²) closure walk | O(log peers) |
+| 4 | `ruflo-knowledge-graph` | Entity-relation graph | Standard PR (Ξ±=0.85) | Single-entry PR | O(nnz) per query (β‰₯100 ms @ 10k) | sub-ms |
+| 5 | `ruflo-rag-memory` | Graph-RAG chunk connectivity | Personalized PR seeded by query embedding | Single-entry PPR (top-K) | flat-MMR rerank | O(log chunks) per candidate |
+| 6 | `ruflo-cost-tracker` | Prompt β†’ agent β†’ MCP β†’ model causation | `(I βˆ’ Ξ±P^T)blame = e` | Single-entry PR | O(traces) | O(log traces) |
+| 7 | `ruflo-observability` | Span dependency graph | Standard PR on spans | Single-entry forward-push | O(spans) | O(log spans) |
+| 8 | `ruflo-neural-trader` | n/a (covariance matrix Ξ£ β€” SPD) | `Ξ£x = ΞΌ` | CG full solve | Neumann ~50 Β΅s @ n=256 | CG **816 ns** (40–60Γ—) |
+| 9 | `ruflo-goals` | n/a (precondition LP) | Kyng–Sachdeva packing/covering LP | Ξ΅-feasibility check | O(states) A\* enumeration | microsecond infeasibility detection |
+| 10 | `ruflo-aidefence` | Syscall call graph | `(I βˆ’ Ξ±P^T)suspicion = e` (Ξ±=0.95) | Single-entry PR from flagged syscall | full trace walk | O(log calls) |
+| 11 | `ruflo-jujutsu` (`diff-analyze`) | File-import graph | `(I βˆ’ Ξ±P^T)impact = e` (Ξ±=0.8) | Single-entry PR from changed file | O(LOC Γ— imports) per push | O(log files) PR-time |
+
+Cross-cutting addendum from the gist: `@claude-flow/embeddings` currently ships a hand-rolled Johnson–Lindenstrauss projection with a documented dimension bug. `[email protected]` ships a hardened JL with the `target_dim ≀ nβˆ’1` cap correctly enforced. This is a correctness fix, not a performance fix, and closes the [ADR-121](./ADR-121-embeddings-ruvector-upgrade.md) Phase 4 follow-up.
+
+## Architecture
+
+### Layered substrate placement
+
+```
+β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
+β”‚ Application plugins (eleven graph owners) β”‚
+β”‚ browser β€’ federation β€’ knowledge-graph β€’ rag-memory β€’ cost-tracker β”‚
+β”‚ observability β€’ neural-trader β€’ goals β€’ aidefence β€’ jujutsu β€’ emb β”‚
+β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
+ β”‚ exportAsSparseMatrix(opts) ← adapter contract
+ β–Ό
+β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
+β”‚ ruflo-sublinear (new plugin) β”‚
+β”‚ ───────────────────────────────────────────────────────────────────── β”‚
+β”‚ β€’ MCP tools: page-rank-entry / solve / feasibility / jl-embed / analyzeβ”‚
+β”‚ β€’ Memoization layer (TTL + content-hash key) β”‚
+β”‚ β€’ Witness-signed PR artifact emitter ◀── Phase 7 beyond-SOTA wedge β”‚
+β”‚ β€’ Adapter registry (plugin-id β†’ exportAsSparseMatrix fn) β”‚
+β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
+ β”‚
+ β–Ό
+β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
+β”‚ [email protected] (npm + crate, WASM + native node addon) β”‚
+β”‚ Neumann β€’ Conjugate Gradient β€’ adaptive random walk β€’ single-entry β”‚
+β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
+ β–²
+ β”‚ signed PR artifacts (RVF container, Ed25519)
+ β–Ό
+β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
+β”‚ Substrate primitives (already shipped) β”‚
+β”‚ ADR-103 witness manifest β€’ @ruvector/rvf β€’ ADR-104/105/111 federation β”‚
+β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜
+```
+
+`ruflo-sublinear` sits between the eleven graph-owner plugins and the solver. It does not own any graphs of its own β€” every graph stays in its owning plugin's storage (AgentDB, HNSW index, span store, etc.). The adapter contract is the load-bearing boundary.
+
+### Plugin module layout
+
+```
+plugins/ruflo-sublinear/
+β”œβ”€β”€ plugin.json
+β”œβ”€β”€ package.json
+β”œβ”€β”€ src/
+β”‚ β”œβ”€β”€ index.ts
+β”‚ β”œβ”€β”€ adapter-registry.ts # plugin-id β†’ exportAsSparseMatrix fn
+β”‚ β”œβ”€β”€ solver-bridge.ts # wraps sublinear-time-solver Node API
+β”‚ β”œβ”€β”€ memoization.ts # content-hash + TTL cache
+β”‚ β”œβ”€β”€ witness-signer.ts # Phase 7: signs PR artifacts via ADR-103
+β”‚ β”œβ”€β”€ mcp/
+β”‚ β”‚ β”œβ”€β”€ page-rank-entry.ts # MCP tool: single-entry PR
+β”‚ β”‚ β”œβ”€β”€ solve.ts # MCP tool: full solve (CG / Neumann)
+β”‚ β”‚ β”œβ”€β”€ feasibility.ts # MCP tool: LP feasibility
+β”‚ β”‚ β”œβ”€β”€ jl-embed.ts # MCP tool: JL projection
+β”‚ β”‚ └── analyze.ts # MCP tool: condition number, DD check, sparsity
+β”‚ └── types.ts
+β”œβ”€β”€ tests/
+└── README.md
+```
+
+The plugin ships as `@claude-flow/plugin-sublinear` on IPFS (Pinata) and follows the existing plugin registry mechanics in `v3/@claude-flow/cli/src/plugins/store/discovery.ts`.
+
+### Adapter contract
+
+Each graph-owning plugin exposes a per-graph exporter:
+
+```ts
+// In every owning plugin, e.g. plugins/ruflo-federation/src/sublinear-adapter.ts
+export interface SparseMatrixExport {
+ // CSR triplet form, matching sublinear-time-solver's SparseMatrix
+ nRows: number;
+ nCols: number;
+ rowPtr: Uint32Array;
+ colIdx: Uint32Array;
+ values: Float32Array;
+ // Identification (used for content-hash and signed artifact provenance)
+ graphId: string; // "ruflo-federation:trust-mesh"
+ graphHash: string; // content hash of the graph state at export time
+ graphTimestamp: number; // unix ms
+ // PageRank-specific hints (omitted for non-PR ops)
+ alpha?: number; // damping
+ // Asymmetry hint β€” selects forward-push vs backward-push vs CG
+ isSymmetric: boolean;
+ isDiagonallyDominant: boolean;
+ // Row mapping back into plugin-native node IDs
+ rowToNodeId: (row: number) => string;
+ nodeIdToRow: (nodeId: string) => number | undefined;
+}
+
+export interface SublinearAdapter {
+ exportAsSparseMatrix(opts: {
+ purpose: "page-rank" | "solve" | "feasibility" | "jl";
+ seedNodes?: string[]; // for personalized PR
+ }): Promise<SparseMatrixExport>;
+}
+```
+
+Adapters live in the owning plugins (not centralised in `ruflo-sublinear`) β€” see Open Question 1. The registry in `ruflo-sublinear` is just a thin `Map<graphId, SublinearAdapter>` populated at plugin-load time via the existing plugin manifest's `exports` field.
+
+### MCP tool surface
+
+Five new tools, mounted under the `sublinear/*` namespace:
+
+| Tool | Purpose | Inputs | Output |
+|---|---|---|---|
+| `sublinear/page-rank-entry` | Single-entry PR (Wedges 1, 3, 4, 5, 6, 7, 10, 11) | `{ graphId, nodeId, alpha?, epsilon?, seedNodes? }` | `{ score, queriedAt, witnessId? }` |
+| `sublinear/solve` | Full linear solve (Wedge 8) | `{ graphId, rhs, algorithm: "cg" \| "neumann" }` | `{ x, residual, iterations }` |
+| `sublinear/feasibility` | LP packing/covering feasibility (Wedge 9) | `{ constraints, tolerance }` | `{ feasible, witness?, certificateOfInfeasibility? }` |
+| `sublinear/jl-embed` | Johnson–Lindenstrauss projection (embeddings fix) | `{ vectors, targetDim, epsilon }` | `{ projected, distortionBound }` |
+| `sublinear/analyze` | Matrix diagnostics | `{ graphId }` | `{ conditionNumber, diagDominance, sparsity, isSymmetric, recommendedAlgorithm }` |
+
+`sublinear/page-rank-entry` is the workhorse β€” eight of eleven wedges call it. Its memoization key is `(graphHash, graphTimestamp, nodeId, alpha, epsilon, seedNodes?)`; TTL is configurable per `graphId` (default 60 s for fast-mutating graphs like span causality, 24 h for slow-mutating graphs like file-import).
+
+### Witness-signed PR artifact (Phase 7 / 8 β€” beyond-SOTA)
+
+A signed PR artifact extends the RVF container schema from ADR-122 Phase 1. Schema:
+
+```rust
+pub struct SignedPageRankArtifact {
+ pub installation_id: InstallationId,
+ pub witness_key_id: WitnessKeyId, // ADR-103 key reference
+ pub graph_id: GraphId, // e.g. "ruflo-federation:trust-mesh"
+ pub graph_hash: Hash256, // content hash of the input matrix
+ pub graph_timestamp: Timestamp,
+ pub algorithm: SolverAlgorithm, // "forward-push" / "backward-push" / "bidirectional"
+ pub alpha: f64,
+ pub epsilon: f64,
+ pub query_node: Option<String>, // None for full-vector artifacts
+ pub seed_nodes: Vec<String>, // empty for plain PR; populated for PPR
+ pub result: PageRankResult, // either a single score or a sparse vector
+ pub result_hash: Hash256, // hash of `result`
+ pub solver_version: String, // "[email protected]"
+ pub signature: Ed25519Signature, // over all of the above
+}
+```
+
+Replayability: any peer with the same input matrix (or a content-hash match against its own export) can re-run single-entry forward-push and confirm the hash byte-for-byte. The computation is deterministic given `(graph, alpha, epsilon, query_node, seed_nodes, algorithm)`. No SNARK circuit required β€” the verifier replays in microseconds because the underlying algorithm is sublinear.
+
+Federation distribution: a peer requests `sublinear/page-rank-entry` over a remote `graphId`; the holder serves the signed artifact (if cached + fresh) or computes-and-signs on demand. The federation transport (ADR-104) carries the artifact as a single small payload (typically <2 KB for a single-entry PR, <100 KB for a sparse PPR vector with 1k seeds). Trust gating: the requesting peer's `verifyAttestation()` returns true iff the holder's `witness_key_id` is in the requester's trust set. Otherwise the requester falls back to local re-computation.
+
+### Production-aware UCT extension story (ADR-122 Phase 4 / 7)
+
+ADR-122 Phase 7's production-aware UCT formula is
+
+```
+score = Q + C·√(ln(parent_visits) / child_visits) + R βˆ’ λ·risk βˆ’ ΞΌΒ·cost βˆ’ Ξ±Β·auth
+```
+
+Wedge 2 augments `Q` with a globally-aware value approximation `Q_global = Ξ²Β·single_entry_PR(branch_node, mcts_tree, Ξ±=0.85)`. The UCT score becomes
+
+```
+score = Q + Q_global + C·√(ln(N)/n) + R βˆ’ λ·risk βˆ’ ΞΌΒ·cost βˆ’ Ξ±Β·auth
+```
+
+`Q_global` is computed via `sublinear/page-rank-entry` on the MCTS tree's reward-weighted transition matrix, treated as a directed weighted graph (asymmetric β€” uses the 2025 RDD result, not the AKP19 SDD result). Cost: O(log branches) per UCT step; cache hit rate is high because most UCT steps reuse the same parent's `Q_global`.
+
+This unblocks "MCTS at depth 30" β€” the local UCT regret bound degrades with depth, but the global value augmentation is depth-agnostic. The result is a parallel federation-MCTS that does not lose value information at depth and does not require deep simulation rollouts.
+
+## GOAP plan for the integration itself
+
+The integration is itself a planning problem. Treating it as such:
+
+**Initial state**: `{adr_122_merged: true, sublinear_npm_published: true, plugin_ruflo_sublinear_exists: false, eleven_adapters_exist: false, signed_pr_artifact_schema: undefined, witness_signer_available: true, federation_transport_available: true, browser_tests_passing: 230}`.
+
+**Goal state**: `{plugin_ruflo_sublinear_published: true, all_eleven_adapters_shipped: true, signed_pr_artifact_schema_defined: true, federation_can_request_signed_pr: true, browser_tests_passing: 230, no_adr_122_regression: true}`.
+
+**Action graph (preconditions β†’ action β†’ effects):**
+
+```
+A1 add-npm-dep {sublinear_npm_published}
+ β†’ {dep_added} cost=0.25d, risk=low
+A2 scaffold-plugin {dep_added}
+ β†’ {plugin_skeleton_exists} cost=0.5d, risk=low
+A3 define-adapter-contract {plugin_skeleton_exists}
+ β†’ {adapter_contract_frozen} cost=0.5d, risk=med (touches all 11 plugins)
+A4 build-solver-bridge {adapter_contract_frozen}
+ β†’ {solver_bridge_works, mcp_tools_5_shipped} cost=1.0d, risk=low
+A5a wedge1-causal-browser {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge1_live, adr_122_phase_2_upgraded} cost=0.5d, risk=low
+A5b wedge3-federation {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge3_live} cost=0.5d, risk=low
+A5c wedge6-cost {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge6_live} cost=0.5d, risk=low
+A6 wedge2-mcts-browser {wedge1_live, adr_122_phase_4_merged}
+ β†’ {wedge2_live, mcts_global_value_augment} cost=1.0d, risk=med (touches UCT formula)
+A7a wedge4-kg {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge4_live} cost=0.5d, risk=low
+A7b wedge5-rag {wedge4_live}
+ β†’ {wedge5_live} cost=0.5d, risk=low (PPR shares scaffolding with PR)
+A8 wedge8-trader {solver_bridge_works}
+ β†’ {wedge8_live} cost=0.5d, risk=low (CG full solve, no graph)
+A9a wedge7-observability {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge7_live} cost=0.5d, risk=low
+A9b wedge10-aidefence {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge10_live} cost=0.5d, risk=low
+A9c wedge11-jujutsu {adapter_contract_frozen, solver_bridge_works}
+ β†’ {wedge11_live} cost=0.5d, risk=low
+A10 wedge9-goap {solver_bridge_works}
+ β†’ {wedge9_live, microsecond_feasibility} cost=1.5d, risk=med (LP feasibility is the trickiest math)
+A11 jl-fix-embeddings {solver_bridge_works}
+ β†’ {jl_dimension_bug_fixed, adr_121_phase_4_done} cost=0.5d, risk=low
+A12 signed-pr-schema {witness_signer_available, solver_bridge_works}
+ β†’ {signed_pr_artifact_schema_defined} cost=1.0d, risk=med (cross-plugin contract)
+A13 federation-distribution {signed_pr_artifact_schema_defined, federation_transport_available}
+ β†’ {federation_can_request_signed_pr} cost=1.5d, risk=med (transport extension)
+A14 verify-no-regression {all_wedges_live, signed_pr_schema_defined, federation_distribution}
+ β†’ {no_adr_122_regression, browser_tests_passing: 230} cost=0.5d, risk=low (gating)
+```
+
+**Critical path** (shortest chain to the highest-leverage outcome β€” "RuFlo browser MCTS branch selection uses sublinear globally-aware value scoring"):
+
+```
+A1 β†’ A2 β†’ A3 β†’ A4 β†’ A5a β†’ A6
+0.25d 0.5d 0.5d 1.0d 0.5d 1.0d = 3.75 engineering-days
+```
+
+This is the path the rollout below optimizes for. Wedge 6 (cost), Wedge 8 (trader), Wedge 9 (GOAP), and the JL fix are independent of the critical path and parallelize. Phase 7 (signed PR artifact) and Phase 8 (federation distribution) depend on the critical path completing but unlock the beyond-SOTA moat β€” they are scheduled last so the moat lands on top of working primitives, not in front of them.
+
+**Edges between wedges:**
+- A5a (Wedge 1, browser causal) β†’ A6 (Wedge 2, MCTS value augment): the MCTS work reuses the causal-graph adapter glue and the page-rank-entry MCP tool path
+- A7a (Wedge 4, KG) β†’ A7b (Wedge 5, RAG): personalized PR over the RAG chunk graph reuses the KG adapter's CSR plumbing β€” same matrix shape, different graph
+- A12 (signed PR schema) β†’ A13 (federation distribution): the artifact must exist before it can be distributed
+- A14 gates merge β€” runs ADR-122's 230 browser tests on each phase tag
+
+**Dependencies on existing ADRs:**
+- ADR-103 witness signer must be invokable from a new plugin (it already is β€” `mcp__claude-flow__witness` is shipped)
+- ADR-104/105 federation transport must allow a new message type β€” falls under existing extensibility, no new ADR needed for in-mesh distribution; cross-installation cross-domain distribution may need ADR-124 (see Open Question 7)
+- ADR-122 Phase 2 (causal recovery, browser) and Phase 4 (federated MCTS) must be merged before A5a and A6 respectively β€” both are merged as of 2026-05-18
+
+## Decision: phased rollout (8 phases)
+
+Phases compose monotonically. Each ships behind a feature flag, ships its own version tag, and clears its own acceptance criteria before the next phase merges.
+
+### Phase 1 β€” Foundation: `ruflo-sublinear` plugin scaffold + adapter contract + solver bridge + five MCP tools
+
+Lay the substrate. No wedges go live yet β€” this is the platform.
+
+- Scaffold `plugins/ruflo-sublinear/` with `plugin.json`, package manifest, MCP tool entry points
+- Add `[email protected]` as a runtime dep
+- Freeze the `SublinearAdapter` and `SparseMatrixExport` types in a new `@claude-flow/shared` export so all eleven owning plugins can import them
+- Implement the solver bridge (`solver-bridge.ts`) wrapping Neumann, CG, single-entry forward-push, single-entry backward-push, bidirectional (RDD case)
+- Ship the five MCP tools β€” `page-rank-entry`, `solve`, `feasibility`, `jl-embed`, `analyze` β€” with no live adapters yet (they return `{error: "no adapter for graphId"}`)
+- Ship the memoization layer with content-hash keying and per-`graphId` TTL config
+- Ship to npm + IPFS registry as `@claude-flow/[email protected]`
+
+**Acceptance:**
+- `ruflo plugins list` shows `@claude-flow/plugin-sublinear`
+- All five MCP tools registered; `analyze` returns correct diagnostics on a hand-rolled test matrix
+- Tests: β‰₯30 unit tests covering the solver bridge against the solver's reference outputs; condition-number / DD-check tests against known matrices
+- Latency: solver bridge p99 < 5 ms on n=256 SPD test matrix (the solver's own headline number is 816 ns; the bridge adds Node↔WASM marshalling overhead but stays well under the 100 ms MCP target)
+
+### Phase 2 β€” Wedge 1: browser causal-recovery PR (the critical path begins)
+
+Replace the O(N) break-count ratio in `@claude-flow/browser`'s Phase-2 causal-recovery code path with O(log N) single-entry PR.
+
+- Ship `plugins/ruflo-browser/src/sublinear-adapter.ts` exposing `exportAsSparseMatrix({purpose: "page-rank", seedNodes: <breaking-selector-ids>})` over the AgentDB causal graph for the current domain
+- Wire `mcp__claude-flow__browser_explain_recovery` to call `sublinear/page-rank-entry` instead of walking the full break-event history
+- Annotate snapshot element-refs with `_causalRiskScore` sourced from the PR-entry result
+- Cross-domain isolation: per-domain graphIds keep the matrix exports scoped
+
+**Acceptance:**
+- p99 latency on causal-risk annotation for an N=10k break-event graph: <5 ms (vs ~100 Β΅s at N=100 today, ~10 ms at N=10k today)
+- Correctness: top-3 risky element-refs match (Jaccard β‰₯0.9) between the old full-walk algorithm and the PR-entry algorithm on a recorded benchmark of 1000 sessions
+- ADR-122 Phase 2 acceptance row passes unchanged (causal-explain still returns β‰₯1 prior break event)
+- Feature flag `RUFLO_BROWSER_PR_CAUSAL` defaults to false in 0.1; flips to true in 0.2 after benchmark confirms
+
+### Phase 3 β€” Wedges 3 + 6 + 7: federation trust + cost attribution + observability spans (independent fan-out)
+
+Three independent adapters; each lands behind its own flag. All three are O(log N) replacements for O(N) or O(NΒ²) walks.
+
+- `ruflo-federation`: trust-mesh adapter with Ξ±=0.7; replaces transitive-trust closure walks
+- `ruflo-cost-tracker`: prompt→agent→MCP→model causation adapter; α=0.85; powers real-time "blame this prompt" UI
+- `ruflo-observability`: span dependency adapter; Ξ±=0.85; powers "most-influential span" debugging queries
+
+**Acceptance:**
+- Federation: trust-closure query on a 1000-peer mesh: ≀10 ms p99 (vs ~10 seconds at NΒ²=10⁢ today)
+- Cost-tracker: "blame top-K prompts for this session's spend" returns in <50 ms on a 100k-trace session
+- Observability: `observe-trace --explain-influence <span-id>` returns ranked influencing spans in <20 ms on a 50k-span trace
+- No regression in plugin's existing MCP tool surface (covered by each plugin's own tests)
+
+### Phase 4 β€” Wedges 4 + 5: knowledge-graph PR + RAG personalized-PR
+
+- `ruflo-knowledge-graph`: entity-relation graph adapter; Ξ±=0.85; replaces full-graph PR on every entity-importance query
+- `ruflo-rag-memory`: graph-RAG chunk connectivity adapter; Ξ±=0.85; PPR seeded by query embedding; replaces flat MMR rerank in `memory_search_unified`'s graph-RAG mode
+
+**Acceptance:**
+- KG entity-importance query on 10k-node graph: <2 ms (vs ~100 ms today)
+- RAG: PPR-reranked top-10 chunks on a 100k-chunk corpus: <50 ms (vs ~2 s for full-PR rerank today)
+- nDCG@10 on the LongMemEval benchmark (ADR-088): no regression vs the existing MMR baseline; aspirationally +5% from graph-awareness
+
+### Phase 5 β€” Wedge 8: neural-trader portfolio CG solve
+
+- `ruflo-neural-trader`: portfolio mean-variance adapter; `Ξ£x = ΞΌ` via CG (no graph involved β€” direct SPD solve)
+- Replaces the existing Neumann-series solve in `trader-portfolio` with CG; expected 40–60Γ— speedup per solver benchmarks
+- Wraps the CG residual + iteration count into the existing risk-report output
+
+**Acceptance:**
+- Portfolio optimization for n=256 assets: <2 Β΅s solve time (CG headline is 816 ns; expect ~1 Β΅s after marshalling)
+- Risk metrics (VaR / CVaR / Sharpe) computed downstream from the new solver match the old solver's outputs within Ρ=10⁻⁢
+- Unblocks "intra-day rebalancing" use case (was previously too slow for sub-minute cadence)
+
+### Phase 6 β€” Wedges 9 + 10 + 11 + JL fix: GOAP feasibility, AIDefence suspicion, jujutsu blast-radius, embeddings JL
+
+Four independent landings; all are sublinear-time queries against pre-existing graphs (or, for the JL fix, a direct library swap).
+
+- `ruflo-goals`: precondition-LP adapter; `sublinear/feasibility` short-circuits A\* on infeasible goals
+- `ruflo-aidefence`: syscall-call-graph adapter; Ξ±=0.95 (high decay so suspicion can travel far); single-entry PR from flagged syscall back to root agent
+- `ruflo-jujutsu`: file-import-graph adapter; Ξ±=0.8; single-entry PR from changed file β†’ "blast radius" score in PR review
+- `@claude-flow/embeddings`: replace hand-rolled JL with `sublinear/jl-embed`; this is a correctness fix not a performance fix, but it closes ADR-121 Phase 4
+
+**Acceptance:**
+- GOAP: infeasible-goal detection on a 100-action plan: <100 Β΅s (vs minutes of A\* enumeration today)
+- AIDefence: "trace suspicion from flagged syscall to root agent" on a 10k-syscall trace: <20 ms
+- Jujutsu: blast-radius score per-changed-file on a 50k-file repo: <50 ms (feasible per-push; today it's O(LOC Γ— imports) which is multi-second)
+- Embeddings JL: distortion bound certificate matches the Ξ΅ parameter on a known test set; `target_dim ≀ nβˆ’1` no longer silently violated
+
+### Phase 7 β€” Beyond-SOTA: witness-signed PageRank artifact (the moat)
+
+This is the architectural claim. Now that all eleven wedges are live and producing PR-entry / solve outputs, wrap the outputs in `SignedPageRankArtifact` and sign them with the project's witness key.
+
+- Implement `witness-signer.ts` in `ruflo-sublinear`; reuse the existing ADR-103 witness machinery via `mcp__claude-flow__witness`
+- Add the `SignedPageRankArtifact` schema as a versioned export in `@claude-flow/shared`
+- Every successful `sublinear/page-rank-entry` and `sublinear/solve` call optionally emits a signed artifact (controlled by a per-call `sign: true` flag; default false to keep the hot path cheap)
+- Ship a `sublinear/verify-artifact` MCP tool that takes a `SignedPageRankArtifact` and confirms signature + replays the computation byte-for-byte
+- Persist signed artifacts into an RVF container (`*.pr.rvf`); the container is a first-class deliverable from MCTS rollouts, cost attribution reports, and CI blast-radius checks
+
+**Acceptance:**
+- A signed PR artifact round-trips through `compute β†’ sign β†’ distribute β†’ verify β†’ replay` with byte-exact reproduction
+- Forging a value (modifying `result_hash` or `result` in the artifact) fails `verify-artifact`
+- A signed artifact produced by Installation A can be opened on Installation B and verified iff B trusts A's witness key (matches the ADR-103 trust model)
+- CI integration: a `.pr.rvf` artifact produced by a CI job can be checked into a repo and replayed by a downstream consumer
+
+### Phase 8 β€” Beyond-SOTA: federation-distributable PR vectors
+
+Promote signed PR artifacts to a federation-distributable object. A federation peer can request a precomputed PR vector by `(graphId, nodeId, alpha, epsilon)` and receive a `SignedPageRankArtifact` from any peer in its trust set.
+
+- Add a new federation message type `pr_artifact_request` / `pr_artifact_response` (transport extension over ADR-104; see Open Question 7 on whether this needs an ADR-124 transport addendum or fits cleanly under ADR-104's extensibility)
+- Cache fanout: the holding peer serves from its memoization cache when the requested `(graphHash, graphTimestamp, ...)` matches a cached signed artifact; otherwise it computes, signs, and serves
+- Trust gating: requester verifies `witness_key_id ∈ trust_set` before consuming; otherwise it falls back to local recomputation against its own export of the graph
+- Cost: federation peers can bill PR-artifact serving via the existing ADR-097 / ADR-110 production spend reporter (each served artifact records a small spend event)
+
+**Acceptance:**
+- A peer A can request a federation-trust-mesh PR-entry from peer B; B returns a signed artifact; A verifies and uses it
+- Cache hit rate on a representative federation workload (100-peer mesh, 1 req/s/peer): β‰₯70% after warm-up
+- Spend reporter logs each served artifact; per-peer budget enforcement blocks abusive request patterns
+- Trust mismatch: requester refuses to consume an artifact signed by a key not in its trust set; falls back to local recomputation
+
+### Phase summary
+
+| Phase | Wedges landed | Cumulative composed primitives | Ships as |
+|---|---|---|---|
+| 1 | foundation | `[email protected]` + 5 MCP tools | alpha.1 |
+| 2 | W1 (browser causal) | + browser adapter | alpha.2 |
+| 3 | W3, W6, W7 | + federation, cost-tracker, observability adapters | alpha.3 |
+| 4 | W4, W5 | + KG, RAG adapters | alpha.4 |
+| 5 | W8 | + neural-trader CG path | alpha.5 |
+| 6 | W9, W10, W11, JL | + GOAP feasibility, AIDefence, jujutsu, embeddings JL fix | alpha.6 |
+| 7 | **signed PR artifact** | + witness-signed PR / replay round-trip | **alpha.7** ← beyond-SOTA wedge |
+| 8 | **federation distribution** | + `pr_artifact_request`/`pr_artifact_response` over ADR-104 | **alpha.8** ← beyond-SOTA moat |
+
+Wedge 2 (browser MCTS global value augment) lands as a separate `@claude-flow/[email protected].{N+1}` release tied to ADR-122's Phase 4/7 β€” it's an upgrade to the substrate consumer, not a new phase of `ruflo-sublinear` itself.
+
+## Acceptance rubric β€” substrate-level
+
+| Dimension | Phase 1 | Phase 4 (W1–W7 live) | Phase 7 (signed artifacts) | Phase 8 (federated PR) |
+|---|---|---|---|---|
+| Speedups achieved over baselines (per gist) | n/a | β‰₯6/11 wedges measured against gist's claimed gains, β‰₯80% confirmation | β‰₯10/11 confirmed | n/a |
+| Cryptographic provenance | n/a | n/a | round-trip pass | + cross-installation verify |
+| Federation distribution | n/a | n/a | n/a | β‰₯70% cache hit on warm mesh |
+| ADR-122 230-test regression | 0 fail | 0 fail | 0 fail | 0 fail |
+| MCP p99 response | <100 ms | <100 ms | <150 ms (sign adds <50 ms) | <200 ms (network) |
+| Plugin published to IPFS | yes | yes | yes | yes |
+
+## Open questions
+
+1. **Adapter ownership: plugin-local vs centralised in `ruflo-sublinear`.** This ADR commits to **plugin-local adapters** (e.g. `plugins/ruflo-federation/src/sublinear-adapter.ts`) because the owning plugin already understands its own storage layout. The cost is that `ruflo-sublinear` cannot ship adapter logic on its own β€” it depends on adapter installation by the owning plugin. The alternative (centralised adapters in `ruflo-sublinear`) reduces moving parts but tightly couples `ruflo-sublinear` to every owning plugin's internal schema. Decided: plugin-local. Reversible if adapter drift becomes a maintenance burden.
+
+2. **Memoization layer + TTL.** Per-`graphId` TTL config is in scope for Phase 1; what's not in scope is **distributed cache invalidation** when a federation peer's local graph changes. For Phase 8, a stale signed artifact (graph changed since signing) is detected by `graphHash` mismatch on the consumer side β€” the consumer falls back to recomputation. There is no proactive invalidation broadcast. This is the cheaper design and is acceptable as long as recomputation is sublinear. Revisit if measured fallback rates exceed 30%.
+
+3. **Witness-signed PageRank artifact lifecycle + rotation.** ADR-103 covers project-key rotation for witness signatures but not the "what happens to in-flight signed PR artifacts when the key rotates" question. Proposal: artifacts carry `witness_key_id` (key version, not key identity); consumers honor any historically-trusted key version unless explicitly revoked. Revocation publishes a CRL-style entry through the federation; consumers refresh on a 1-hour cadence. This may want its own follow-up ADR if it grows complicated; for Phase 7 stick to "single key version per installation, no rotation in-flight".
+
+4. **Benchmark target matrices β€” what's "representative" for each plugin?** Each owning plugin must supply a benchmark fixture matrix (or a recorded production trace) for its own wedge. The acceptance numbers in Phases 2–6 assume reasonable target matrices; if a plugin lacks an honest fixture, the benchmark is a placeholder and the acceptance number is provisional. Phase 1 ships a "benchmark fixture catalog" doc that lists missing fixtures.
+
+5. **Failure modes β€” what happens when the source matrix is NOT diagonally-dominant?** `sublinear/analyze` returns the diagnostic; `sublinear/page-rank-entry` and `sublinear/solve` reject the call with a structured error if `isDiagonallyDominant` is false and the algorithm requires DD. Specifically: forward-push assumes column-stochastic + Ξ±-damped (always DD); backward-push assumes row-stochastic + Ξ±-damped (always DD); CG requires SPD (covariance matrices are by construction SPD; trader case is safe); LP feasibility checks have their own preconditions. If a plugin's graph drifts to non-DD (e.g. an asymmetric trust update that introduces negative weights), the adapter must either preprocess (clamp, renormalise) or report `not applicable`. The owning plugin is responsible for the preprocessing decision because it understands the semantic meaning of the weights.
+
+6. **Node-Rust binding strategy β€” WASM, native node addon, or both?** `[email protected]` ships both. The plugin defaults to **native node addon when available, WASM as a fallback**. The detection is at plugin-load time, mirroring how `@claude-flow/embeddings` handles ONNX runtime detection. The WASM path serves Edge runtimes (Cloudflare Workers, Deno Deploy) where native modules are unavailable; the native path is the hot path in the v3 monorepo. Latency budgets above assume native; WASM has ~3Γ— overhead.
+
+7. **Federation distribution of PR vectors β€” does this need an ADR-104 transport extension?** Most likely **no**, because ADR-104's message-type extensibility was designed for this. The new `pr_artifact_request` / `pr_artifact_response` message types fit cleanly under the existing wire framing. However, **cross-installation federation** (i.e. an Installation A in one org talking to Installation B in another org) may want stricter rate-limiting + capability-token authorization than the within-mesh case β€” and that may want an **ADR-124-federation-graph-artifact-distribution** as a follow-up. Flagged as a Phase 8 prerequisite.
+
+## Updates to assumptions discovered during research
+
+Two SOTA findings updated working assumptions mid-flight; recorded here explicitly per the brief's standing instructions:
+
+- **Asymmetric DD result (arXiv 2509.13891, 2025) supersedes the implicit AKP19-SDD assumption.** Several of the eleven RuFlo graphs (federation trust, span causality, file imports, cost attribution) are *not* symmetric. Under a strict AKP19 reading, those wedges would have required transformation to symmetric form (e.g. by adding `M + M^T`) with attendant approximation loss. The 2025 paper proves single-entry sublinear time for the asymmetric case directly, using the "maximum p-norm gap" complexity parameter and a bidirectional Forward/Backward Push unification. **The ADR commits to the 2025 result, not the 2019 result.** `[email protected]` already implements both forward-push and backward-push primitives, so this is a configuration choice (not a code-change) at integration time.
+
+- **The right comparison object is not zk-SNARK-of-PageRank; it's "Ed25519-signed inputs + hash-of-output + deterministic replay".** Initial drafting assumed the cryptographic-provenance angle would parallel ZK-DeepSeek and ZKPROV. After re-reading those papers it became clear they target a different threat model β€” proprietary models, hidden weights, untrusted compute. RuFlo's threat model is the *opposite*: the algorithm is public, the inputs are content-addressable, and the federation peer is semi-trusted via a witness-key trust set. A SNARK circuit over Neumann or CG would be enormously expensive for no marginal security gain in this threat model. Ed25519-over-inputs-and-output-hash is sufficient because the verifier can replay the computation in microseconds. This shifts Phase 7 from "build a SNARK circuit" to "extend ADR-103 schema with PR-specific fields" β€” a ~1-day task instead of a multi-week one.
+
+## References
+
+- `[email protected]` npm: https://www.npmjs.com/package/sublinear-time-solver
+- `sublinear` crate: https://crates.io/crates/sublinear
+- Library github: https://github.com/ruvnet/sublinear-time-solver
+- 1.6.0 announcement gist: https://gist.github.com/ruvnet/342518ef950348c376bc7c04ffeb5337
+- Eleven-wedge research gist (foundational): https://gist.github.com/ruvnet/61d6d04af514b3c81ad0abf1e37fe116
+- Andoni, Krauthgamer, Pogrow β€” "On Solving Linear Systems in Sublinear Time" (ITCS 2019): https://arxiv.org/abs/1809.02995
+- Asymmetric DD sublinear (2025): https://arxiv.org/abs/2509.13891
+- Friedkin–Johnsen application (2025): https://arxiv.org/abs/2509.13112
+- Kyng & Sachdeva approx-Cholesky and follow-ups: https://rasmuskyng.com/research.html
+- Robust & Practical Solution of Laplacian Equations by Approximate Elimination (Gao–Kyng–Spielman, 2023): https://arxiv.org/abs/2303.00709
+- LaMMA-P hierarchical LLM + PDDL: https://arxiv.org/html/2602.21670
+- GoalAct (NCIIP 2025 Best Paper): https://github.com/cjj826/GoalAct
+- Why Do LLM-based Web Agents Fail? (hierarchical-planning perspective): https://arxiv.org/pdf/2603.14248
+- HippoRAG (PPR-on-KG retrieval): https://graphwise.ai/blog/from-retrieval-to-reasoning-enhancing-hipporag-with-graph-based-semantics/
+- HippoRAG paper: https://www.researchgate.net/publication/397199630_HippoRAG_Neurobiologically_Inspired_Long-Term_Memory_for_Large_Language_Models
+- ZK-DeepSeek (zk-SNARK verifiable inference): https://arxiv.org/abs/2511.19902
+- ZKPROV (dataset provenance for LLMs): https://arxiv.org/html/2506.20915
+- Lagrange DeepProve (dynamic zk-SNARKs): https://lagrange.dev/blog/dynamic-zk-snarks
+- Portable Agent Memory provenance protocol: https://arxiv.org/html/2605.11032v1
+- Memory poisoning in multi-agent systems: https://arxiv.org/html/2603.20357v1
+- Mnemonic Sovereignty survey (long-term memory security): https://arxiv.org/html/2604.16548v1
+- 2026 agent-memory framework comparisons: https://vectorize.io/articles/mem0-vs-letta, https://vectorize.io/articles/letta-vs-langchain-memory
+- ADR-103 (witness temporal history): `v3/docs/adr/ADR-103-witness-temporal-history.md`
+- ADR-104 (federation wire transport): `v3/docs/adr/ADR-104-federation-wire-transport.md`
+- ADR-105 (federation state snapshot): `v3/docs/adr/ADR-105-federation-v1-state-snapshot.md`
+- ADR-121 (embeddings RuVector upgrade β€” JL fix follow-up): `v3/docs/adr/ADR-121-embeddings-ruvector-upgrade.md`
+- ADR-122 (browser substrate): `v3/docs/adr/ADR-122-browser-beyond-sota.md`