feat(baselines): add node discovery iteration tracking to baseline algorithms

add nodeDiscoveryIteration tracking to standard-bfs, frontier-balanced,
random-priority, delayed-termination, degree-surprise, cross-seed-affinity,
and ensemble-expansion. enables coverage efficiency comparison.

Author: Mearman

src/experiments/baselines/cross-seed-affinity.ts

@@ -18,6 +18,9 @@ export interface CrossSeedAffinityResult {
 
 	/** Statistics about the expansion */
 	stats: CrossSeedAffinityStats;
+
+	/** Maps node ID to the iteration when it was first discovered */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -90,6 +93,7 @@ export class CrossSeedAffinityExpansion<T> {
 	private readonly sampledEdges = new Set<string>();
 	private readonly frontierVisitCounts = new Map<string, number>();
 	private stats: CrossSeedAffinityStats;
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 
 	/**
 	 * Create a new cross-seed-affinity expansion.
@@ -116,6 +120,8 @@ export class CrossSeedAffinityExpansion<T> {
 			});
 			// Seeds are visited by their own frontier
 			this.frontierVisitCounts.set(seed, 1);
+			// Record seed discovery at iteration 0
+			this.nodeDiscoveryIteration.set(seed, 0);
 		}
 
 		this.stats = {
@@ -184,6 +190,11 @@ export class CrossSeedAffinityExpansion<T> {
 				activeState.visited.add(targetId);
 				activeState.parents.set(targetId, { parent: node, edge: relationshipType });
 
+				// Record discovery iteration if this is the first time seeing this node
+				if (!this.nodeDiscoveryIteration.has(targetId)) {
+					this.nodeDiscoveryIteration.set(targetId, this.stats.iterations);
+				}
+
 				// Update frontier visit count
 				const currentCount = this.frontierVisitCounts.get(targetId) ?? 0;
 				this.frontierVisitCounts.set(targetId, currentCount + 1);
@@ -228,6 +239,7 @@ export class CrossSeedAffinityExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			visitedPerFrontier,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}
 

src/experiments/baselines/degree-surprise.ts

@@ -18,6 +18,9 @@ export interface DegreeSurpriseResult {
 
 	/** Statistics about the expansion */
 	stats: DegreeSurpriseStats;
+
+	/** Map from node ID to the iteration when it was first discovered */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -85,6 +88,7 @@ export class DegreeSurpriseExpansion<T> {
 	private readonly paths: Array<{ fromSeed: number; toSeed: number; nodes: string[] }> = [];
 	private readonly sampledEdges = new Set<string>();
 	private stats: DegreeSurpriseStats;
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 
 	/**
 	 * Create a new degree-surprise expansion.
@@ -109,6 +113,7 @@ export class DegreeSurpriseExpansion<T> {
 				visited: new Set([seed]),
 				parents: new Map(),
 			});
+			this.nodeDiscoveryIteration.set(seed, 0);
 		}
 
 		this.stats = {
@@ -170,6 +175,10 @@ export class DegreeSurpriseExpansion<T> {
 				activeState.visited.add(targetId);
 				activeState.parents.set(targetId, { parent: node, edge: relationshipType });
 
+				if (!this.nodeDiscoveryIteration.has(targetId)) {
+					this.nodeDiscoveryIteration.set(targetId, this.stats.iterations);
+				}
+
 				// Compute degree surprise priority for this node
 				const priority = await this.computeDegreeSurprise(targetId);
 
@@ -210,6 +219,7 @@ export class DegreeSurpriseExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			visitedPerFrontier,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}
 

src/experiments/baselines/delayed-termination.ts

@@ -18,6 +18,9 @@ export interface DelayedTerminationResult {
 
 	/** Statistics about the expansion */
 	stats: DelayedTerminationStats;
+
+	/** Map from node ID to the iteration at which it was first discovered */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -95,6 +98,7 @@ export class DelayedTerminationExpansion<T> {
 	private readonly frontiers: FrontierState[] = [];
 	private readonly paths: Array<{ fromSeed: number; toSeed: number; nodes: string[] }> = [];
 	private readonly sampledEdges = new Set<string>();
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 	private stats: DelayedTerminationStats;
 	private firstOverlapIteration = -1;
 	private remainingDelayIterations: number;
@@ -126,6 +130,7 @@ export class DelayedTerminationExpansion<T> {
 				visited: new Set([seed]),
 				parents: new Map(),
 			});
+			this.nodeDiscoveryIteration.set(seed, 0);
 		}
 
 		this.stats = {
@@ -192,6 +197,10 @@ export class DelayedTerminationExpansion<T> {
 				activeState.visited.add(targetId);
 				activeState.parents.set(targetId, { parent: node, edge: relationshipType });
 
+				if (!this.nodeDiscoveryIteration.has(targetId)) {
+					this.nodeDiscoveryIteration.set(targetId, this.stats.iterations);
+				}
+
 				// Add to queue (FIFO - end of queue)
 				activeState.queue.push(targetId);
 
@@ -235,6 +244,7 @@ export class DelayedTerminationExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			visitedPerFrontier,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}
 

src/experiments/baselines/ensemble-expansion.ts

@@ -18,6 +18,9 @@ export interface EnsembleExpansionResult {
 
 	/** Statistics about the expansion */
 	stats: EnsembleExpansionStats;
+
+	/** Map from node ID to the iteration when it was first discovered (across all strategies) */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -96,6 +99,7 @@ interface DegreePriorityFrontierState {
  */
 export class EnsembleExpansion<T> {
 	private readonly sampledEdges = new Set<string>();
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 	private stats: EnsembleExpansionStats;
 
 	/**
@@ -170,6 +174,7 @@ export class EnsembleExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			sampledNodesPerStrategy,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}
 
@@ -181,6 +186,7 @@ export class EnsembleExpansion<T> {
 	private async runBfs(): Promise<Set<string>> {
 		const frontiers: BfsFrontierState[] = [];
 		const allVisited = new Set<string>();
+		let iteration = 0;
 
 		for (const [index, seed] of this.seeds.entries()) {
 			frontiers.push({
@@ -190,9 +196,13 @@ export class EnsembleExpansion<T> {
 				parents: new Map(),
 			});
 			allVisited.add(seed);
+			if (!this.nodeDiscoveryIteration.has(seed)) {
+				this.nodeDiscoveryIteration.set(seed, 0);
+			}
 		}
 
 		while (frontiers.some((f) => f.queue.length > 0)) {
+			iteration++;
 			for (const frontier of frontiers) {
 				if (frontier.queue.length === 0) continue;
 
@@ -208,6 +218,10 @@ export class EnsembleExpansion<T> {
 					frontier.parents.set(targetId, node);
 					frontier.queue.push(targetId);
 
+					if (!this.nodeDiscoveryIteration.has(targetId)) {
+						this.nodeDiscoveryIteration.set(targetId, iteration);
+					}
+
 					const edgeKey = `${node}->${targetId}`;
 					this.sampledEdges.add(edgeKey);
 					this.expander.addEdge(node, targetId, relationshipType);
@@ -226,6 +240,7 @@ export class EnsembleExpansion<T> {
 	private async runDfs(): Promise<Set<string>> {
 		const frontiers: DfsFrontierState[] = [];
 		const allVisited = new Set<string>();
+		let iteration = 0;
 
 		for (const [index, seed] of this.seeds.entries()) {
 			frontiers.push({
@@ -235,9 +250,13 @@ export class EnsembleExpansion<T> {
 				parents: new Map(),
 			});
 			allVisited.add(seed);
+			if (!this.nodeDiscoveryIteration.has(seed)) {
+				this.nodeDiscoveryIteration.set(seed, 0);
+			}
 		}
 
 		while (frontiers.some((f) => f.stack.length > 0)) {
+			iteration++;
 			for (const frontier of frontiers) {
 				if (frontier.stack.length === 0) continue;
 
@@ -253,6 +272,10 @@ export class EnsembleExpansion<T> {
 					frontier.parents.set(targetId, node);
 					frontier.stack.push(targetId);
 
+					if (!this.nodeDiscoveryIteration.has(targetId)) {
+						this.nodeDiscoveryIteration.set(targetId, iteration);
+					}
+
 					const edgeKey = `${node}->${targetId}`;
 					this.sampledEdges.add(edgeKey);
 					this.expander.addEdge(node, targetId, relationshipType);
@@ -271,6 +294,7 @@ export class EnsembleExpansion<T> {
 	private async runDegreePriority(): Promise<Set<string>> {
 		const frontiers: DegreePriorityFrontierState[] = [];
 		const allVisited = new Set<string>();
+		let iteration = 0;
 
 		for (const [index, seed] of this.seeds.entries()) {
 			frontiers.push({
@@ -280,9 +304,13 @@ export class EnsembleExpansion<T> {
 				parents: new Map(),
 			});
 			allVisited.add(seed);
+			if (!this.nodeDiscoveryIteration.has(seed)) {
+				this.nodeDiscoveryIteration.set(seed, 0);
+			}
 		}
 
 		while (frontiers.some((f) => f.frontier.length > 0)) {
+			iteration++;
 			for (const frontier of frontiers) {
 				if (frontier.frontier.length === 0) continue;
 
@@ -300,6 +328,10 @@ export class EnsembleExpansion<T> {
 					allVisited.add(targetId);
 					frontier.parents.set(targetId, item.nodeId);
 
+					if (!this.nodeDiscoveryIteration.has(targetId)) {
+						this.nodeDiscoveryIteration.set(targetId, iteration);
+					}
+
 					const degree = this.expander.getDegree(targetId);
 					frontier.frontier.push({ nodeId: targetId, degree });
 

src/experiments/baselines/frontier-balanced.ts

@@ -18,6 +18,9 @@ export interface FrontierBalancedResult {
 
 	/** Statistics about the expansion */
 	stats: FrontierBalancedStats;
+
+	/** Maps each node to the iteration when it was first discovered */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -84,6 +87,7 @@ export class FrontierBalancedExpansion<T> {
 	private readonly paths: Array<{ fromSeed: number; toSeed: number; nodes: string[] }> = [];
 	private readonly sampledEdges = new Set<string>();
 	private stats: FrontierBalancedStats;
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 	private lastActiveFrontier = 0;
 
 	/**
@@ -109,6 +113,7 @@ export class FrontierBalancedExpansion<T> {
 				visited: new Set([seed]),
 				parents: new Map(),
 			});
+			this.nodeDiscoveryIteration.set(seed, 0);
 		}
 
 		this.stats = {
@@ -171,6 +176,10 @@ export class FrontierBalancedExpansion<T> {
 				activeState.visited.add(targetId);
 				activeState.parents.set(targetId, { parent: node, edge: relationshipType });
 
+				if (!this.nodeDiscoveryIteration.has(targetId)) {
+					this.nodeDiscoveryIteration.set(targetId, this.stats.iterations);
+				}
+
 				// Add to queue
 				activeState.queue.push(targetId);
 
@@ -209,6 +218,7 @@ export class FrontierBalancedExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			visitedPerFrontier,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}
 

src/experiments/baselines/random-priority.ts

@@ -18,6 +18,9 @@ export interface RandomPriorityResult {
 
 	/** Statistics about the expansion */
 	stats: RandomPriorityStats;
+
+	/** Maps each node to the iteration when it was first discovered */
+	nodeDiscoveryIteration: Map<string, number>;
 }
 
 /**
@@ -109,6 +112,7 @@ export class RandomPriorityExpansion<T> {
 	private readonly sampledEdges = new Set<string>();
 	private readonly rng: SeededRandom;
 	private stats: RandomPriorityStats;
+	private readonly nodeDiscoveryIteration = new Map<string, number>();
 
 	/**
 	 * Create a new random-priority expansion.
@@ -137,6 +141,7 @@ export class RandomPriorityExpansion<T> {
 				visited: new Set([seedNode]),
 				parents: new Map(),
 			});
+			this.nodeDiscoveryIteration.set(seedNode, 0);
 		}
 
 		this.stats = {
@@ -195,6 +200,10 @@ export class RandomPriorityExpansion<T> {
 				activeState.visited.add(targetId);
 				activeState.parents.set(targetId, { parent: node, edge: relationshipType });
 
+				if (!this.nodeDiscoveryIteration.has(targetId)) {
+					this.nodeDiscoveryIteration.set(targetId, this.stats.iterations);
+				}
+
 				// Add to frontier (will be randomly selected later)
 				activeState.frontier.push(targetId);
 
@@ -233,6 +242,7 @@ export class RandomPriorityExpansion<T> {
 			sampledEdges: this.sampledEdges,
 			visitedPerFrontier,
 			stats: this.stats,
+			nodeDiscoveryIteration: this.nodeDiscoveryIteration,
 		};
 	}