ruflo-graph-intelligence 0.1.0-alpha.1

package/tests/mcp-tools.test.ts

@@ -0,0 +1,169 @@
+/**
+ * ruflo-graph-intelligence — MCP Tool Tests (ADR-123 Phase 1)
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { graphIntelligenceTools } from '../src/mcp-tools/index.js';
+import { getRegistry, resetRegistry } from '../src/domain/adapter.js';
+import type { SublinearAdapter } from '../src/domain/adapter.js';
+import type { SparseMatrix } from '../src/domain/types.js';
+
+function ddTestAdapter(): SublinearAdapter {
+  return {
+    graphId: 'test:dd',
+    ownerPlugin: 'test',
+    async exportAsSparseMatrix(): Promise<SparseMatrix> {
+      const entries = [];
+      const nodeIndex: Record<string, number> = {};
+      const indexNode: string[] = [];
+      const n = 6;
+      for (let i = 0; i < n; i++) {
+        nodeIndex[`n${i}`] = i;
+        indexNode.push(`n${i}`);
+        entries.push({ row: i, col: i, value: 5 });
+        if (i > 0) entries.push({ row: i, col: i - 1, value: -1 });
+        if (i < n - 1) entries.push({ row: i, col: i + 1, value: -1 });
+      }
+      return {
+        graphId: 'test:dd',
+        size: n,
+        entries,
+        nodeIndex,
+        indexNode,
+        capturedAt: 't',
+      };
+    },
+  };
+}
+
+function findTool(name: string) {
+  const tool = graphIntelligenceTools.find((t) => t.name === name);
+  if (!tool) throw new Error(`tool ${name} not found`);
+  return tool;
+}
+
+describe('MCP tools — surface', () => {
+  it('exports six tools under sublinear/*', () => {
+    const names = graphIntelligenceTools.map((t) => t.name);
+    expect(names).toEqual([
+      'sublinear/page-rank-entry',
+      'sublinear/solve',
+      'sublinear/solve-on-change',
+      'sublinear/analyze',
+      'sublinear/feasibility',
+      'sublinear/jl-embed',
+    ]);
+  });
+
+  it('each tool has an input schema with type:object', () => {
+    for (const t of graphIntelligenceTools) {
+      expect(t.inputSchema.type).toBe('object');
+    }
+  });
+});
+
+describe('sublinear/page-rank-entry', () => {
+  beforeEach(() => {
+    resetRegistry();
+    getRegistry().register(ddTestAdapter());
+  });
+
+  it('returns a result on the happy path', async () => {
+    const tool = findTool('sublinear/page-rank-entry');
+    // Phase 1 forward-push is a reference impl — observed iterations on small DD
+    // matrices may exceed the `linear` default budget. Use `polynomial` here to
+    // exercise the happy path; the budget-exceeded path has its own dedicated test.
+    const r = (await tool.handler({
+      graphId: 'test:dd',
+      nodeId: 'n3',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: unknown };
+    expect(r.success).toBe(true);
+    expect(r.result).toBeDefined();
+  });
+
+  it('returns complexity-budget-exceeded when budget is too tight', async () => {
+    const tool = findTool('sublinear/page-rank-entry');
+    const r = (await tool.handler({
+      graphId: 'test:dd',
+      nodeId: 'n3',
+      maxComplexityClass: 'constant',
+    })) as { success: boolean; error?: { kind: string } };
+    expect(r.success).toBe(false);
+    expect(r.error?.kind).toBe('complexity-budget-exceeded');
+  });
+
+  it('returns graph-not-found for an unknown graphId', async () => {
+    const tool = findTool('sublinear/page-rank-entry');
+    const r = (await tool.handler({ graphId: 'missing', nodeId: 'n0' })) as { success: boolean; error?: { kind: string } };
+    expect(r.success).toBe(false);
+    expect(r.error?.kind).toBe('graph-not-found');
+  });
+
+  it('returns coherence-rejected when threshold not met', async () => {
+    const tool = findTool('sublinear/page-rank-entry');
+    const r = (await tool.handler({
+      graphId: 'test:dd',
+      nodeId: 'n0',
+      coherenceThreshold: 0.99,
+    })) as { success: boolean; error?: { kind: string } };
+    expect(r.success).toBe(false);
+    expect(r.error?.kind).toBe('coherence-rejected');
+  });
+});
+
+describe('sublinear/analyze', () => {
+  beforeEach(() => {
+    resetRegistry();
+    getRegistry().register(ddTestAdapter());
+  });
+
+  it('reports coherence + recommended algorithm', async () => {
+    const tool = findTool('sublinear/analyze');
+    const r = (await tool.handler({ graphId: 'test:dd' })) as { success: boolean; result?: Record<string, unknown> };
+    expect(r.success).toBe(true);
+    expect(r.result?.size).toBe(6);
+    expect(r.result?.coherenceScore).toBeGreaterThan(0);
+    expect(r.result?.recommendedAlgorithm).toBeDefined();
+  });
+});
+
+describe('sublinear/solve', () => {
+  beforeEach(() => {
+    resetRegistry();
+    getRegistry().register(ddTestAdapter());
+  });
+
+  it('solves A·x = b with CG', async () => {
+    const tool = findTool('sublinear/solve');
+    const r = (await tool.handler({
+      graphId: 'test:dd',
+      rhs: [1, 1, 1, 1, 1, 1],
+      algorithm: 'cg',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { x: number[]; residualNorm: number } };
+    expect(r.success).toBe(true);
+    expect(r.result?.x).toHaveLength(6);
+    expect(r.result?.residualNorm).toBeLessThan(1e-3);
+  });
+});
+
+describe('sublinear/solve-on-change', () => {
+  beforeEach(() => {
+    resetRegistry();
+    getRegistry().register(ddTestAdapter());
+  });
+
+  it('handles a single-node delta', async () => {
+    const tool = findTool('sublinear/solve-on-change');
+    const r = (await tool.handler({
+      graphId: 'test:dd',
+      prevSolution: [0, 0, 0, 0, 0, 0],
+      delta: { indices: [2], values: [0.5] },
+      algorithm: 'cg',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { x: number[] } };
+    expect(r.success).toBe(true);
+    expect(r.result?.x).toHaveLength(6);
+  });
+});

package/tests/phase3-adapters.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Phase 3 Adapter Tests — federation trust + cost attribution + observability
+ *
+ * Acceptance:
+ *  - Each adapter exports a DD SparseMatrix
+ *  - Each adapter registers under its canonical graphId
+ *  - sublinear/page-rank-entry routes through each end-to-end
+ *  - Stale federation edges are pruned
+ *  - Cost rows are L1-normalised so PR weights are proportional shares
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  FederationTrustAdapter,
+  FEDERATION_TRUST_GRAPH_ID,
+  registerFederationTrustAdapter,
+} from '../src/adapters/federation-trust-adapter.js';
+import {
+  CostAttributionAdapter,
+  costAttributionGraphId,
+  registerCostAttributionAdapter,
+} from '../src/adapters/cost-attribution-adapter.js';
+import {
+  ObservabilitySpanAdapter,
+  observabilityGraphId,
+  registerObservabilitySpanAdapter,
+} from '../src/adapters/observability-span-adapter.js';
+import { resetRegistry, getRegistry } from '../src/domain/adapter.js';
+import { coherenceScore } from '../src/infrastructure/solver-bridge.js';
+import { graphIntelligenceTools } from '../src/mcp-tools/index.js';
+
+describe('FederationTrustAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('exports a DD matrix from peer trust edges', async () => {
+    const adapter = new FederationTrustAdapter({
+      source: {
+        async listTrustEdges() {
+          return [
+            { fromPeer: 'A', toPeer: 'B', confidence: 0.8, updatedAt: new Date().toISOString() },
+            { fromPeer: 'B', toPeer: 'C', confidence: 0.6, updatedAt: new Date().toISOString() },
+            { fromPeer: 'A', toPeer: 'C', confidence: 0.3, updatedAt: new Date().toISOString() },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    expect(m.size).toBe(3);
+    expect(coherenceScore(m)).toBeGreaterThan(0);
+  });
+
+  it('prunes stale edges past the freshness window', async () => {
+    const old = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+    const fresh = new Date().toISOString();
+    const adapter = new FederationTrustAdapter({
+      freshnessMs: 7 * 24 * 60 * 60 * 1000,
+      source: {
+        async listTrustEdges() {
+          return [
+            { fromPeer: 'A', toPeer: 'B', confidence: 0.8, updatedAt: old },
+            { fromPeer: 'B', toPeer: 'C', confidence: 0.6, updatedAt: fresh },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    expect(Object.keys(m.nodeIndex).sort()).toEqual(['B', 'C']);
+  });
+
+  it('registers under the canonical graphId', () => {
+    const registry = getRegistry();
+    registerFederationTrustAdapter({
+      source: { async listTrustEdges() { return []; } },
+      registry,
+    });
+    expect(registry.get(FEDERATION_TRUST_GRAPH_ID)).toBeDefined();
+  });
+
+  it('end-to-end via sublinear/page-rank-entry', async () => {
+    const registry = getRegistry();
+    registerFederationTrustAdapter({
+      source: {
+        async listTrustEdges() {
+          return [
+            { fromPeer: 'A', toPeer: 'B', confidence: 0.9, updatedAt: new Date().toISOString() },
+            { fromPeer: 'B', toPeer: 'C', confidence: 0.7, updatedAt: new Date().toISOString() },
+          ];
+        },
+      },
+      registry,
+    });
+    const tool = graphIntelligenceTools.find((t) => t.name === 'sublinear/page-rank-entry');
+    const r = (await tool!.handler({
+      graphId: FEDERATION_TRUST_GRAPH_ID,
+      nodeId: 'C',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { score: number } };
+    expect(r.success).toBe(true);
+    expect(r.result?.score).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('CostAttributionAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('builds a DD matrix from causation edges', async () => {
+    const adapter = new CostAttributionAdapter({
+      sessionId: 'sess-1',
+      source: {
+        async listCausationEdges() {
+          return [
+            { parentId: 'prompt-1', childId: 'agent-1', costUsd: 0.5 },
+            { parentId: 'prompt-1', childId: 'agent-2', costUsd: 0.2 },
+            { parentId: 'agent-1', childId: 'model-call-1', costUsd: 0.05 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    expect(m.size).toBeGreaterThan(0);
+    expect(coherenceScore(m)).toBeGreaterThan(0);
+  });
+
+  it('L1-normalises costs into proportional shares per parent', async () => {
+    const adapter = new CostAttributionAdapter({
+      source: {
+        async listCausationEdges() {
+          return [
+            { parentId: 'p', childId: 'a', costUsd: 1.0 },
+            { parentId: 'p', childId: 'b', costUsd: 3.0 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const pIdx = m.nodeIndex['p'];
+    const aIdx = m.nodeIndex['a'];
+    const bIdx = m.nodeIndex['b'];
+    const pa = m.entries.find((e) => e.row === pIdx && e.col === aIdx)?.value ?? 0;
+    const pb = m.entries.find((e) => e.row === pIdx && e.col === bIdx)?.value ?? 0;
+    expect(pa + pb).toBeCloseTo(1.0, 6);
+    expect(pb / pa).toBeCloseTo(3, 2);
+  });
+
+  it('registers under the canonical session-scoped graphId', () => {
+    const registry = getRegistry();
+    registerCostAttributionAdapter({
+      sessionId: 's',
+      source: { async listCausationEdges() { return []; } },
+      registry,
+    });
+    expect(registry.get(costAttributionGraphId('s'))).toBeDefined();
+  });
+});
+
+describe('ObservabilitySpanAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('builds a DD matrix from span tree', async () => {
+    const adapter = new ObservabilitySpanAdapter({
+      traceId: 't1',
+      source: {
+        async listSpans() {
+          return [
+            { spanId: 'root', traceId: 't1', selfTimeUs: 100 },
+            { spanId: 'child-a', parentSpanId: 'root', traceId: 't1', selfTimeUs: 60 },
+            { spanId: 'child-b', parentSpanId: 'root', traceId: 't1', selfTimeUs: 40 },
+            { spanId: 'leaf', parentSpanId: 'child-a', traceId: 't1', selfTimeUs: 10 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    expect(m.size).toBe(4);
+    expect(coherenceScore(m)).toBeGreaterThan(0);
+  });
+
+  it('honours cross-trace causedBy links', async () => {
+    const adapter = new ObservabilitySpanAdapter({
+      traceId: 't1',
+      source: {
+        async listSpans() {
+          return [
+            { spanId: 'a', traceId: 't1', selfTimeUs: 100 },
+            { spanId: 'b', traceId: 't1', selfTimeUs: 50, causedBySpanId: 'a' },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const aIdx = m.nodeIndex['a'];
+    const bIdx = m.nodeIndex['b'];
+    const ab = m.entries.find((e) => e.row === aIdx && e.col === bIdx);
+    expect(ab?.value).toBeGreaterThan(0);
+  });
+
+  it('registers under the canonical graphId', () => {
+    const registry = getRegistry();
+    registerObservabilitySpanAdapter({
+      traceId: 't',
+      source: { async listSpans() { return []; } },
+      registry,
+    });
+    expect(registry.get(observabilityGraphId('t'))).toBeDefined();
+  });
+});

package/tests/phase4-adapters.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Phase 4 Adapter Tests — knowledge graph + RAG memory
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  KnowledgeGraphAdapter,
+  KNOWLEDGE_GRAPH_ID,
+  registerKnowledgeGraphAdapter,
+} from '../src/adapters/knowledge-graph-adapter.js';
+import {
+  RagMemoryAdapter,
+  ragMemoryGraphId,
+  registerRagMemoryAdapter,
+} from '../src/adapters/rag-memory-adapter.js';
+import { resetRegistry, getRegistry } from '../src/domain/adapter.js';
+import { coherenceScore } from '../src/infrastructure/solver-bridge.js';
+import { graphIntelligenceTools } from '../src/mcp-tools/index.js';
+
+describe('KnowledgeGraphAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('exports a DD matrix from KG edges', async () => {
+    const adapter = new KnowledgeGraphAdapter({
+      source: {
+        async listEdges() {
+          return [
+            { fromEntity: 'Claude', toEntity: 'Anthropic', relation: 'createdBy', confidence: 0.95 },
+            { fromEntity: 'Anthropic', toEntity: 'AI Safety', relation: 'focuses-on', confidence: 0.9 },
+            { fromEntity: 'Claude', toEntity: 'AI Safety', relation: 'aligned-with', confidence: 0.8 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    expect(m.size).toBe(3);
+    expect(coherenceScore(m)).toBeGreaterThan(0);
+  });
+
+  it('combines multiple relations between same entities', async () => {
+    const adapter = new KnowledgeGraphAdapter({
+      source: {
+        async listEdges() {
+          return [
+            { fromEntity: 'A', toEntity: 'B', relation: 'r1', confidence: 0.4 },
+            { fromEntity: 'A', toEntity: 'B', relation: 'r2', confidence: 0.5 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const offDiag = m.entries.find((e) => e.row !== e.col);
+    expect(offDiag?.value).toBeCloseTo(0.9, 5);
+  });
+
+  it('caps combined confidence at 1.0', async () => {
+    const adapter = new KnowledgeGraphAdapter({
+      source: {
+        async listEdges() {
+          return [
+            { fromEntity: 'A', toEntity: 'B', relation: 'r1', confidence: 0.7 },
+            { fromEntity: 'A', toEntity: 'B', relation: 'r2', confidence: 0.8 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const offDiag = m.entries.find((e) => e.row !== e.col);
+    expect(offDiag?.value).toBe(1.0);
+  });
+
+  it('registers under canonical graphId', () => {
+    const registry = getRegistry();
+    registerKnowledgeGraphAdapter({
+      source: { async listEdges() { return []; } },
+      registry,
+    });
+    expect(registry.get(KNOWLEDGE_GRAPH_ID)).toBeDefined();
+  });
+
+  it('end-to-end via sublinear/page-rank-entry', async () => {
+    const registry = getRegistry();
+    registerKnowledgeGraphAdapter({
+      source: {
+        async listEdges() {
+          return [
+            { fromEntity: 'A', toEntity: 'B', relation: 'r', confidence: 0.5 },
+            { fromEntity: 'B', toEntity: 'C', relation: 'r', confidence: 0.5 },
+            { fromEntity: 'C', toEntity: 'A', relation: 'r', confidence: 0.5 },
+          ];
+        },
+      },
+      registry,
+    });
+    const tool = graphIntelligenceTools.find((t) => t.name === 'sublinear/page-rank-entry');
+    const r = (await tool!.handler({
+      graphId: KNOWLEDGE_GRAPH_ID,
+      nodeId: 'B',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { score: number } };
+    expect(r.success).toBe(true);
+    expect(r.result?.score).toBeGreaterThan(0);
+  });
+});
+
+describe('RagMemoryAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('exports a DD matrix from chunk edges, filtering below similarity floor', async () => {
+    const adapter = new RagMemoryAdapter({
+      similarityFloor: 0.5,
+      source: {
+        async listChunkEdges() {
+          return [
+            { fromChunkId: 'c1', toChunkId: 'c2', similarity: 0.8 },
+            { fromChunkId: 'c1', toChunkId: 'c3', similarity: 0.3 }, // filtered
+            { fromChunkId: 'c2', toChunkId: 'c3', similarity: 0.7 },
+          ];
+        },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    // c3 still appears via c2 → c3 (above floor); c1 → c3 is the filtered one.
+    expect(m.size).toBe(3);
+    expect(coherenceScore(m)).toBeGreaterThan(0);
+  });
+
+  it('namespace scopes the graph id', () => {
+    expect(ragMemoryGraphId('docs')).toBe('ruflo-rag-memory:chunks:docs');
+    expect(ragMemoryGraphId()).toBe('ruflo-rag-memory:chunks:default');
+  });
+
+  it('end-to-end personalized PR via seedNodes', async () => {
+    const registry = getRegistry();
+    registerRagMemoryAdapter({
+      namespace: 'test',
+      source: {
+        async listChunkEdges() {
+          return [
+            { fromChunkId: 'c1', toChunkId: 'c2', similarity: 0.9 },
+            { fromChunkId: 'c2', toChunkId: 'c3', similarity: 0.7 },
+            { fromChunkId: 'c3', toChunkId: 'c1', similarity: 0.6 },
+          ];
+        },
+      },
+      registry,
+    });
+    const tool = graphIntelligenceTools.find((t) => t.name === 'sublinear/page-rank-entry');
+    const r = (await tool!.handler({
+      graphId: ragMemoryGraphId('test'),
+      nodeId: 'c3',
+      seedNodes: ['c1'],
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { score: number } };
+    expect(r.success).toBe(true);
+    expect(r.result?.score).toBeGreaterThan(0);
+  });
+});

package/tests/phase5-portfolio.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Phase 5 Tests — Portfolio Covariance Adapter (Wedge 8)
+ *
+ * Acceptance:
+ *  - Covariance matrix is symmetric after symmetrisation
+ *  - Σx = μ solved via CG to small residual
+ *  - Ridge keeps Σ SPD even when the empirical covariance is rank-1
+ *  - End-to-end via sublinear/solve
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  PortfolioCovarianceAdapter,
+  portfolioGraphId,
+  registerPortfolioCovarianceAdapter,
+} from '../src/adapters/portfolio-cg-adapter.js';
+import { resetRegistry, getRegistry } from '../src/domain/adapter.js';
+import { conjugateGradient } from '../src/infrastructure/solver-bridge.js';
+import { graphIntelligenceTools } from '../src/mcp-tools/index.js';
+
+describe('PortfolioCovarianceAdapter', () => {
+  beforeEach(() => resetRegistry());
+
+  it('symmetrises one-sided covariance entries', async () => {
+    const adapter = new PortfolioCovarianceAdapter({
+      portfolioId: 'p1',
+      source: {
+        async listCovarianceEntries() {
+          return [
+            { assetA: 'AAPL', assetB: 'AAPL', covariance: 0.04 },
+            { assetA: 'GOOG', assetB: 'GOOG', covariance: 0.05 },
+            { assetA: 'AAPL', assetB: 'GOOG', covariance: 0.01 }, // only one side
+          ];
+        },
+        async listExpectedReturns() { return { AAPL: 0.08, GOOG: 0.09 }; },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const aIdx = m.nodeIndex['AAPL'];
+    const gIdx = m.nodeIndex['GOOG'];
+    const ag = m.entries.find((e) => e.row === aIdx && e.col === gIdx);
+    const ga = m.entries.find((e) => e.row === gIdx && e.col === aIdx);
+    expect(ag?.value).toBeCloseTo(0.01, 6);
+    expect(ga?.value).toBeCloseTo(0.01, 6);
+  });
+
+  it('CG solves Σx = μ to small residual', async () => {
+    const adapter = new PortfolioCovarianceAdapter({
+      portfolioId: 'p1',
+      ridge: 1e-3,
+      source: {
+        async listCovarianceEntries() {
+          return [
+            { assetA: 'AAPL', assetB: 'AAPL', covariance: 0.04 },
+            { assetA: 'GOOG', assetB: 'GOOG', covariance: 0.05 },
+            { assetA: 'MSFT', assetB: 'MSFT', covariance: 0.03 },
+            { assetA: 'AAPL', assetB: 'GOOG', covariance: 0.015 },
+            { assetA: 'AAPL', assetB: 'MSFT', covariance: 0.018 },
+            { assetA: 'GOOG', assetB: 'MSFT', covariance: 0.020 },
+          ];
+        },
+        async listExpectedReturns() { return { AAPL: 0.08, GOOG: 0.09, MSFT: 0.07 }; },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const mu = await adapter.expectedReturnsVector(m);
+    const { x, residualNorm, iterations } = conjugateGradient(m, mu, { epsilon: 1e-8, maxIter: 50 });
+    expect(x).toHaveLength(3);
+    expect(residualNorm).toBeLessThan(1e-6);
+    expect(iterations).toBeLessThan(20);
+  });
+
+  it('ridge keeps a rank-deficient matrix solvable', async () => {
+    // Two perfectly-correlated assets — empirical Σ is rank 1
+    const adapter = new PortfolioCovarianceAdapter({
+      portfolioId: 'p-corr',
+      ridge: 1e-3,
+      source: {
+        async listCovarianceEntries() {
+          return [
+            { assetA: 'X', assetB: 'X', covariance: 0.01 },
+            { assetA: 'Y', assetB: 'Y', covariance: 0.01 },
+            { assetA: 'X', assetB: 'Y', covariance: 0.01 },
+          ];
+        },
+        async listExpectedReturns() { return { X: 0.1, Y: 0.1 }; },
+      },
+    });
+    const m = await adapter.exportAsSparseMatrix();
+    const mu = await adapter.expectedReturnsVector(m);
+    const { residualNorm } = conjugateGradient(m, mu, { epsilon: 1e-6, maxIter: 100 });
+    expect(residualNorm).toBeLessThan(1e-4);
+  });
+
+  it('end-to-end via sublinear/solve', async () => {
+    const registry = getRegistry();
+    registerPortfolioCovarianceAdapter({
+      portfolioId: 'p2',
+      source: {
+        async listCovarianceEntries() {
+          return [
+            { assetA: 'A', assetB: 'A', covariance: 0.04 },
+            { assetA: 'B', assetB: 'B', covariance: 0.05 },
+            { assetA: 'A', assetB: 'B', covariance: 0.01 },
+          ];
+        },
+        async listExpectedReturns() { return { A: 0.1, B: 0.12 }; },
+      },
+      registry,
+    });
+    const tool = graphIntelligenceTools.find((t) => t.name === 'sublinear/solve');
+    const r = (await tool!.handler({
+      graphId: portfolioGraphId('p2'),
+      rhs: [0.1, 0.12],
+      algorithm: 'cg',
+      maxComplexityClass: 'polynomial',
+    })) as { success: boolean; result?: { x: number[]; residualNorm: number } };
+    expect(r.success).toBe(true);
+    expect(r.result?.x).toHaveLength(2);
+    expect(r.result?.residualNorm).toBeLessThan(1e-4);
+  });
+});