ruflo-graph-intelligence 0.1.0-alpha.1

package/src/adapters/aidefence-suspicion-adapter.ts

@@ -0,0 +1,102 @@
+/**
+ * AIDefence Suspicion Adapter (Wedge 10, ADR-123 Phase 6)
+ *
+ * `ruflo-aidefence` flags syscalls / agent actions as suspicious. This
+ * adapter exports the call-graph so suspicion propagates from the flagged
+ * leaf node back through callers via single-entry PR. `α=0.95` (high
+ * decay — suspicion travels far) by convention.
+ */
+
+import { createHash } from 'node:crypto';
+import type { SparseEntry, SparseMatrix } from '../domain/types.js';
+import type { SublinearAdapter, AdapterRegistry } from '../domain/adapter.js';
+import { getRegistry } from '../domain/adapter.js';
+
+export interface CallEdge {
+  callerId: string;
+  calleeId: string;
+  /** Optional weight — calls per session. Default 1. */
+  weight?: number;
+}
+
+export interface AIDefenceSource {
+  listCallEdges(): Promise<readonly CallEdge[]>;
+}
+
+export interface AIDefenceAdapterOptions {
+  source: AIDefenceSource;
+  /** DD safety margin. Default 0.25. */
+  ddSafetyMargin?: number;
+}
+
+export const AIDEFENCE_CALL_GRAPH_ID = 'ruflo-aidefence:call-graph';
+
+export class AIDefenceSuspicionAdapter implements SublinearAdapter {
+  readonly graphId = AIDEFENCE_CALL_GRAPH_ID;
+  readonly ownerPlugin = 'ruflo-aidefence';
+  readonly requiresPreprocessing = false;
+
+  private readonly source: AIDefenceSource;
+  private readonly ddSafetyMargin: number;
+
+  constructor(options: AIDefenceAdapterOptions) {
+    this.source = options.source;
+    this.ddSafetyMargin = options.ddSafetyMargin ?? 0.25;
+  }
+
+  async exportAsSparseMatrix(options?: { nodeFilter?: ReadonlySet<string> }): Promise<SparseMatrix> {
+    const edges = await this.source.listCallEdges();
+    const idSet = new Set<string>();
+    for (const e of edges) {
+      idSet.add(e.callerId);
+      idSet.add(e.calleeId);
+    }
+    if (options?.nodeFilter) {
+      for (const n of [...idSet]) if (!options.nodeFilter.has(n)) idSet.delete(n);
+    }
+    const nodes = [...idSet].sort();
+    const nodeIndex: Record<string, number> = {};
+    nodes.forEach((n, i) => (nodeIndex[n] = i));
+
+    // Suspicion flows from callee BACK to caller, so edges are reversed:
+    // a callee that's flagged should bump suspicion on its caller.
+    const entries: SparseEntry[] = [];
+    const rowSums = new Array<number>(nodes.length).fill(0);
+    for (const e of edges) {
+      // Reverse direction: from callee → caller
+      const r = nodeIndex[e.calleeId];
+      const c = nodeIndex[e.callerId];
+      if (r === undefined || c === undefined || r === c) continue;
+      const w = Math.max(0, e.weight ?? 1);
+      entries.push({ row: r, col: c, value: w });
+      rowSums[r] += w;
+    }
+    for (let i = 0; i < nodes.length; i++) {
+      entries.push({ row: i, col: i, value: rowSums[i]! + this.ddSafetyMargin });
+    }
+    return {
+      graphId: this.graphId,
+      size: nodes.length,
+      entries,
+      nodeIndex,
+      indexNode: nodes,
+      capturedAt: new Date().toISOString(),
+      contentHash: hashContent(this.graphId, entries),
+    };
+  }
+}
+
+export function registerAIDefenceSuspicionAdapter(
+  options: AIDefenceAdapterOptions & { registry?: AdapterRegistry },
+): AIDefenceSuspicionAdapter {
+  const adapter = new AIDefenceSuspicionAdapter(options);
+  (options.registry ?? getRegistry()).register(adapter);
+  return adapter;
+}
+
+function hashContent(graphId: string, entries: readonly SparseEntry[]): string {
+  const h = createHash('sha256');
+  h.update(graphId);
+  for (const e of entries) h.update(`|${e.row},${e.col},${e.value.toFixed(8)}`);
+  return h.digest('hex');
+}

package/src/adapters/browser-causal-adapter.ts

@@ -0,0 +1,193 @@
+/**
+ * Browser Causal-Recovery Adapter (Wedge 1, ADR-123 Phase 2)
+ *
+ * Exports the ADR-122 Phase 2 selector-break events as a SparseMatrix so
+ * `sublinear/page-rank-entry` can score a single element-ref's causal
+ * brittleness in O(log N) instead of the current O(N) `breakCount / attempts`
+ * ratio.
+ *
+ * The matrix `M` is built per-origin: rows + columns are union of
+ *   - all element-refs that have ever appeared
+ *   - all selector strings that have ever been retried
+ * Off-diagonal entry M[i,j] = number of times row-event preceded column-event
+ * on the same DOM mutation lineage (weight ≥ 1). Diagonal entry M[i,i] = 1 + Σ
+ * |off-diagonals on row i|, so the matrix is strictly diagonally-dominant.
+ *
+ * The adapter is **dependency-injection-friendly**: callers pass a
+ * `BreakEventSource` (a structural type matching the slice of ADR-122's
+ * CausalRecoveryService surface we actually need) so this plugin does NOT
+ * hard-import @claude-flow/browser. Phase 2 of *this* plugin ships the
+ * adapter; the browser package only needs to call `registerBrowserCausalAdapter()`
+ * at its plugin-init time.
+ */
+
+import { createHash } from 'node:crypto';
+import type { SparseEntry, SparseMatrix } from '../domain/types.js';
+import type { SublinearAdapter } from '../domain/adapter.js';
+
+/**
+ * The slice of @claude-flow/browser's CausalRecoveryService surface we depend on.
+ * Defined structurally so we don't need a hard import.
+ */
+export interface BreakEventSource {
+  /** All recorded break events for an origin, in chronological order. */
+  listBreaks(origin: string): Promise<readonly BreakEventLike[]>;
+}
+
+/** Minimal break-event shape we read. Compatible with ADR-122 Phase 2. */
+export interface BreakEventLike {
+  id: string;
+  origin: string;
+  selector: string;
+  /** Optional last-known role+name fuzzy-match keys (Phase 2 records both). */
+  lastKnownRole?: string;
+  lastKnownName?: string;
+  /** When the break was first observed (ISO). */
+  timestamp: string;
+}
+
+export interface BrowserCausalAdapterOptions {
+  /** Origin (e.g. `https://example.com`) — one adapter instance per origin. */
+  origin: string;
+  /** Event source. */
+  source: BreakEventSource;
+  /** Adjacency-weighting half-life in milliseconds. Default 24h. */
+  halfLifeMs?: number;
+  /** Diagonal-dominance margin to keep DD even under heavy noise. Default 0.5. */
+  ddSafetyMargin?: number;
+}
+
+/**
+ * Identifier convention so consumers can address per-origin graphs:
+ *   `browser:causal:<origin>` — e.g. `browser:causal:https://example.com`
+ */
+export function browserCausalGraphId(origin: string): string {
+  return `browser:causal:${origin}`;
+}
+
+export class BrowserCausalAdapter implements SublinearAdapter {
+  readonly graphId: string;
+  readonly ownerPlugin = '@claude-flow/browser';
+
+  private readonly origin: string;
+  private readonly source: BreakEventSource;
+  private readonly halfLifeMs: number;
+  private readonly ddSafetyMargin: number;
+
+  constructor(options: BrowserCausalAdapterOptions) {
+    this.origin = options.origin;
+    this.source = options.source;
+    this.halfLifeMs = options.halfLifeMs ?? 24 * 60 * 60 * 1000;
+    this.ddSafetyMargin = options.ddSafetyMargin ?? 0.5;
+    this.graphId = browserCausalGraphId(this.origin);
+  }
+
+  async exportAsSparseMatrix(options?: {
+    since?: string;
+    nodeFilter?: ReadonlySet<string>;
+  }): Promise<SparseMatrix> {
+    const events = await this.source.listBreaks(this.origin);
+    const cutoff = options?.since ? Date.parse(options.since) : -Infinity;
+    const filtered = events.filter((e) => Date.parse(e.timestamp) >= cutoff);
+
+    // Node set: union of selectors + (role:name) fuzzy keys
+    const nodeIds = new Set<string>();
+    for (const e of filtered) {
+      nodeIds.add(e.selector);
+      if (e.lastKnownRole && e.lastKnownName) {
+        nodeIds.add(`role:${e.lastKnownRole}:${e.lastKnownName}`);
+      }
+    }
+    if (options?.nodeFilter) {
+      for (const n of [...nodeIds]) if (!options.nodeFilter.has(n)) nodeIds.delete(n);
+    }
+
+    const nodes = [...nodeIds].sort();
+    const nodeIndex: Record<string, number> = {};
+    nodes.forEach((n, i) => (nodeIndex[n] = i));
+
+    // Build adjacency: row = source event's selector, col = "next" event's selector
+    // within the same chronological neighbourhood. Time-decayed weight.
+    const weights = new Map<string, number>(); // key = "row:col"
+    const now = Date.now();
+    for (let i = 0; i < filtered.length - 1; i++) {
+      const a = filtered[i];
+      const b = filtered[i + 1];
+      const decay = Math.exp(-(now - Date.parse(a.timestamp)) / this.halfLifeMs);
+      const keys = pairKeys(a, b);
+      for (const k of keys) weights.set(k, (weights.get(k) ?? 0) + decay);
+    }
+
+    // Emit off-diagonal entries, then add a diagonal that guarantees DD.
+    const entries: SparseEntry[] = [];
+    const rowSums = new Array<number>(nodes.length).fill(0);
+    for (const [key, w] of weights) {
+      const [from, to] = key.split('::');
+      const rIdx = nodeIndex[from!];
+      const cIdx = nodeIndex[to!];
+      if (rIdx === undefined || cIdx === undefined) continue;
+      if (rIdx === cIdx) continue;
+      entries.push({ row: rIdx, col: cIdx, value: w });
+      rowSums[rIdx] += Math.abs(w);
+    }
+    for (let i = 0; i < nodes.length; i++) {
+      const diag = rowSums[i]! + this.ddSafetyMargin;
+      entries.push({ row: i, col: i, value: Math.max(1, diag) });
+    }
+
+    return {
+      graphId: this.graphId,
+      size: nodes.length,
+      entries,
+      nodeIndex,
+      indexNode: nodes,
+      capturedAt: new Date().toISOString(),
+      contentHash: hashContent(this.graphId, entries),
+    };
+  }
+
+  readonly requiresPreprocessing = false;
+}
+
+function pairKeys(a: BreakEventLike, b: BreakEventLike): string[] {
+  const keys: string[] = [`${a.selector}::${b.selector}`];
+  if (a.lastKnownRole && a.lastKnownName) {
+    const key = `role:${a.lastKnownRole}:${a.lastKnownName}`;
+    keys.push(`${key}::${b.selector}`);
+  }
+  if (b.lastKnownRole && b.lastKnownName) {
+    const key = `role:${b.lastKnownRole}:${b.lastKnownName}`;
+    keys.push(`${a.selector}::${key}`);
+  }
+  return keys;
+}
+
+function hashContent(graphId: string, entries: readonly SparseEntry[]): string {
+  const h = createHash('sha256');
+  h.update(graphId);
+  for (const e of entries) {
+    h.update(`|${e.row},${e.col},${e.value.toFixed(8)}`);
+  }
+  return h.digest('hex');
+}
+
+/**
+ * Convenience entry point — instantiate + register in one call.
+ *
+ * Intended to be invoked from @claude-flow/browser's init code:
+ *   import { registerBrowserCausalAdapter } from 'ruflo-graph-intelligence/adapters';
+ *   registerBrowserCausalAdapter({ origin: 'https://example.com', source: causalService });
+ */
+export function registerBrowserCausalAdapter(
+  options: BrowserCausalAdapterOptions & { registry?: import('../domain/adapter.js').AdapterRegistry },
+): BrowserCausalAdapter {
+  const adapter = new BrowserCausalAdapter(options);
+  const registry = options.registry ?? import('../domain/adapter.js').then((m) => m.getRegistry());
+  // Synchronous registration when registry is supplied; lazy fallback otherwise.
+  if (typeof (registry as { register?: unknown }).register === 'function') {
+    (registry as import('../domain/adapter.js').AdapterRegistry).register(adapter);
+  } else {
+    (registry as Promise<import('../domain/adapter.js').AdapterRegistry>).then((r) => r.register(adapter));
+  }
+  return adapter;
+}

package/src/adapters/cost-attribution-adapter.ts

@@ -0,0 +1,123 @@
+/**
+ * Cost Attribution Adapter (Wedge 6, ADR-123 Phase 3)
+ *
+ * `ruflo-cost-tracker` records token usage per session in a causation graph:
+ *   user-prompt → spawned-agent → MCP-call → model-invocation → tokens-USD
+ *
+ * This adapter exports that graph so `sublinear/page-rank-entry` answers
+ * "which root prompt caused the most downstream spend" in O(log traces)
+ * rather than O(traces) walks. Costs are one-way edges → asymmetric matrix.
+ */
+
+import { createHash } from 'node:crypto';
+import type { SparseEntry, SparseMatrix } from '../domain/types.js';
+import type { SublinearAdapter, AdapterRegistry } from '../domain/adapter.js';
+import { getRegistry } from '../domain/adapter.js';
+
+export interface CostCausationEdge {
+  /** Parent node — typically a prompt id or upstream agent id. */
+  parentId: string;
+  /** Child node — typically a spawned agent / MCP call / model invocation id. */
+  childId: string;
+  /** USD cost attributed to the child as caused by this parent. */
+  costUsd: number;
+}
+
+export interface CostCausationSource {
+  /** All causation edges for a session (or globally). */
+  listCausationEdges(sessionId?: string): Promise<readonly CostCausationEdge[]>;
+}
+
+export interface CostAttributionAdapterOptions {
+  source: CostCausationSource;
+  /** Restrict to a specific session id. */
+  sessionId?: string;
+  /** DD safety margin. Default 0.25. */
+  ddSafetyMargin?: number;
+}
+
+export function costAttributionGraphId(sessionId?: string): string {
+  return sessionId ? `ruflo-cost-tracker:causation:${sessionId}` : 'ruflo-cost-tracker:causation:global';
+}
+
+export class CostAttributionAdapter implements SublinearAdapter {
+  readonly graphId: string;
+  readonly ownerPlugin = 'ruflo-cost-tracker';
+  readonly requiresPreprocessing = false;
+
+  private readonly source: CostCausationSource;
+  private readonly sessionId?: string;
+  private readonly ddSafetyMargin: number;
+
+  constructor(options: CostAttributionAdapterOptions) {
+    this.source = options.source;
+    this.sessionId = options.sessionId;
+    this.ddSafetyMargin = options.ddSafetyMargin ?? 0.25;
+    this.graphId = costAttributionGraphId(this.sessionId);
+  }
+
+  async exportAsSparseMatrix(options?: { nodeFilter?: ReadonlySet<string> }): Promise<SparseMatrix> {
+    const edges = await this.source.listCausationEdges(this.sessionId);
+    const nodeSet = new Set<string>();
+    for (const e of edges) {
+      nodeSet.add(e.parentId);
+      nodeSet.add(e.childId);
+    }
+    if (options?.nodeFilter) {
+      for (const n of [...nodeSet]) if (!options.nodeFilter.has(n)) nodeSet.delete(n);
+    }
+
+    const nodes = [...nodeSet].sort();
+    const nodeIndex: Record<string, number> = {};
+    nodes.forEach((n, i) => (nodeIndex[n] = i));
+
+    // Normalise costs into [0, 1] per row so PageRank semantics make sense
+    // (we're after the *share of blame*, not the raw dollar amount).
+    const rawRowSums = new Array<number>(nodes.length).fill(0);
+    for (const e of edges) {
+      const r = nodeIndex[e.parentId];
+      if (r === undefined) continue;
+      rawRowSums[r]! += Math.max(0, e.costUsd);
+    }
+    const entries: SparseEntry[] = [];
+    const rowSums = new Array<number>(nodes.length).fill(0);
+    for (const e of edges) {
+      const r = nodeIndex[e.parentId];
+      const c = nodeIndex[e.childId];
+      if (r === undefined || c === undefined || r === c) continue;
+      const denom = rawRowSums[r]!;
+      if (denom === 0) continue;
+      const w = Math.max(0, e.costUsd) / denom;
+      if (w === 0) continue;
+      entries.push({ row: r, col: c, value: w });
+      rowSums[r] += w;
+    }
+    for (let i = 0; i < nodes.length; i++) {
+      entries.push({ row: i, col: i, value: rowSums[i]! + this.ddSafetyMargin });
+    }
+    return {
+      graphId: this.graphId,
+      size: nodes.length,
+      entries,
+      nodeIndex,
+      indexNode: nodes,
+      capturedAt: new Date().toISOString(),
+      contentHash: hashContent(this.graphId, entries),
+    };
+  }
+}
+
+export function registerCostAttributionAdapter(
+  options: CostAttributionAdapterOptions & { registry?: AdapterRegistry },
+): CostAttributionAdapter {
+  const adapter = new CostAttributionAdapter(options);
+  (options.registry ?? getRegistry()).register(adapter);
+  return adapter;
+}
+
+function hashContent(graphId: string, entries: readonly SparseEntry[]): string {
+  const h = createHash('sha256');
+  h.update(graphId);
+  for (const e of entries) h.update(`|${e.row},${e.col},${e.value.toFixed(8)}`);
+  return h.digest('hex');
+}

package/src/adapters/federation-trust-adapter.ts

@@ -0,0 +1,116 @@
+/**
+ * Federation Trust Adapter (Wedge 3, ADR-123 Phase 3)
+ *
+ * `ruflo-federation` ships a peer trust mesh (ADR-097/104/105/111). This
+ * adapter exports the mesh as a SparseMatrix so `sublinear/page-rank-entry`
+ * computes transitive trust `(I − αT)τ = e` in O(log peers) instead of
+ * O(peers²) closure walks. Trust is one-way → the matrix is asymmetric
+ * (per upstream 2025 asymmetric-DD result, this is in-scope for sublinear).
+ */
+
+import { createHash } from 'node:crypto';
+import type { SparseEntry, SparseMatrix } from '../domain/types.js';
+import type { SublinearAdapter, AdapterRegistry } from '../domain/adapter.js';
+import { getRegistry } from '../domain/adapter.js';
+
+export interface PeerTrustEdge {
+  /** Peer the trust comes from. */
+  fromPeer: string;
+  /** Peer the trust is directed at. */
+  toPeer: string;
+  /** Confidence in [0, 1] — typically derived from signed-message hit rate. */
+  confidence: number;
+  /** When the edge was last updated. */
+  updatedAt: string;
+}
+
+export interface PeerTrustSource {
+  /** All trust edges currently in the local view of the mesh. */
+  listTrustEdges(): Promise<readonly PeerTrustEdge[]>;
+}
+
+export interface FederationTrustAdapterOptions {
+  source: PeerTrustSource;
+  /** Edge-staleness cutoff in milliseconds. Default 7 days. */
+  freshnessMs?: number;
+  /** Diagonal-dominance safety margin. Default 0.25. */
+  ddSafetyMargin?: number;
+}
+
+export const FEDERATION_TRUST_GRAPH_ID = 'ruflo-federation:trust-mesh';
+
+export class FederationTrustAdapter implements SublinearAdapter {
+  readonly graphId = FEDERATION_TRUST_GRAPH_ID;
+  readonly ownerPlugin = 'ruflo-federation';
+  readonly requiresPreprocessing = false;
+
+  private readonly source: PeerTrustSource;
+  private readonly freshnessMs: number;
+  private readonly ddSafetyMargin: number;
+
+  constructor(options: FederationTrustAdapterOptions) {
+    this.source = options.source;
+    this.freshnessMs = options.freshnessMs ?? 7 * 24 * 60 * 60 * 1000;
+    this.ddSafetyMargin = options.ddSafetyMargin ?? 0.25;
+  }
+
+  async exportAsSparseMatrix(options?: { nodeFilter?: ReadonlySet<string> }): Promise<SparseMatrix> {
+    const allEdges = await this.source.listTrustEdges();
+    const now = Date.now();
+    const fresh = allEdges.filter((e) => now - Date.parse(e.updatedAt) <= this.freshnessMs);
+
+    const peerSet = new Set<string>();
+    for (const e of fresh) {
+      peerSet.add(e.fromPeer);
+      peerSet.add(e.toPeer);
+    }
+    if (options?.nodeFilter) {
+      for (const p of [...peerSet]) if (!options.nodeFilter.has(p)) peerSet.delete(p);
+    }
+
+    const peers = [...peerSet].sort();
+    const nodeIndex: Record<string, number> = {};
+    peers.forEach((p, i) => (nodeIndex[p] = i));
+
+    const entries: SparseEntry[] = [];
+    const rowSums = new Array<number>(peers.length).fill(0);
+    for (const edge of fresh) {
+      const r = nodeIndex[edge.fromPeer];
+      const c = nodeIndex[edge.toPeer];
+      if (r === undefined || c === undefined || r === c) continue;
+      const w = Math.max(0, Math.min(1, edge.confidence));
+      if (w === 0) continue;
+      entries.push({ row: r, col: c, value: w });
+      rowSums[r] += w;
+    }
+    // DD diagonal: |diag| ≥ Σ|off| + margin
+    for (let i = 0; i < peers.length; i++) {
+      entries.push({ row: i, col: i, value: rowSums[i]! + this.ddSafetyMargin });
+    }
+
+    return {
+      graphId: this.graphId,
+      size: peers.length,
+      entries,
+      nodeIndex,
+      indexNode: peers,
+      capturedAt: new Date().toISOString(),
+      contentHash: hashContent(this.graphId, entries),
+    };
+  }
+}
+
+export function registerFederationTrustAdapter(
+  options: FederationTrustAdapterOptions & { registry?: AdapterRegistry },
+): FederationTrustAdapter {
+  const adapter = new FederationTrustAdapter(options);
+  (options.registry ?? getRegistry()).register(adapter);
+  return adapter;
+}
+
+function hashContent(graphId: string, entries: readonly SparseEntry[]): string {
+  const h = createHash('sha256');
+  h.update(graphId);
+  for (const e of entries) h.update(`|${e.row},${e.col},${e.value.toFixed(8)}`);
+  return h.digest('hex');
+}

package/src/adapters/index.ts

@@ -0,0 +1,87 @@
+/**
+ * ruflo-graph-intelligence — Adapter barrel export
+ *
+ * Each adapter lives in its own file and is opted into by the owning plugin
+ * at init time. Phase-1 ships zero adapters; Phase 2+ adds them one at a time.
+ */
+
+export {
+  BrowserCausalAdapter,
+  browserCausalGraphId,
+  registerBrowserCausalAdapter,
+  type BreakEventSource,
+  type BreakEventLike,
+  type BrowserCausalAdapterOptions,
+} from './browser-causal-adapter.js';
+
+export {
+  FederationTrustAdapter,
+  FEDERATION_TRUST_GRAPH_ID,
+  registerFederationTrustAdapter,
+  type PeerTrustEdge,
+  type PeerTrustSource,
+  type FederationTrustAdapterOptions,
+} from './federation-trust-adapter.js';
+
+export {
+  CostAttributionAdapter,
+  costAttributionGraphId,
+  registerCostAttributionAdapter,
+  type CostCausationEdge,
+  type CostCausationSource,
+  type CostAttributionAdapterOptions,
+} from './cost-attribution-adapter.js';
+
+export {
+  ObservabilitySpanAdapter,
+  observabilityGraphId,
+  registerObservabilitySpanAdapter,
+  type SpanRecord,
+  type ObservabilitySpanSource,
+  type ObservabilitySpanAdapterOptions,
+} from './observability-span-adapter.js';
+
+export {
+  KnowledgeGraphAdapter,
+  KNOWLEDGE_GRAPH_ID,
+  registerKnowledgeGraphAdapter,
+  type KGEdge,
+  type KnowledgeGraphSource,
+  type KnowledgeGraphAdapterOptions,
+} from './knowledge-graph-adapter.js';
+
+export {
+  RagMemoryAdapter,
+  ragMemoryGraphId,
+  registerRagMemoryAdapter,
+  type ChunkEdge,
+  type RagMemorySource,
+  type RagMemoryAdapterOptions,
+} from './rag-memory-adapter.js';
+
+export {
+  PortfolioCovarianceAdapter,
+  portfolioGraphId,
+  registerPortfolioCovarianceAdapter,
+  type CovarianceEntry,
+  type PortfolioSource,
+  type PortfolioAdapterOptions,
+} from './portfolio-cg-adapter.js';
+
+export {
+  AIDefenceSuspicionAdapter,
+  AIDEFENCE_CALL_GRAPH_ID,
+  registerAIDefenceSuspicionAdapter,
+  type CallEdge,
+  type AIDefenceSource,
+  type AIDefenceAdapterOptions,
+} from './aidefence-suspicion-adapter.js';
+
+export {
+  JujutsuBlastRadiusAdapter,
+  JUJUTSU_IMPORT_GRAPH_ID,
+  registerJujutsuBlastRadiusAdapter,
+  type ImportEdge,
+  type JujutsuSource,
+  type JujutsuAdapterOptions,
+} from './jujutsu-blast-radius-adapter.js';