const s = [...samples].sort((a, b) => a - b);

return {

min: s[0],

p50: percentile(s, 50),

p95: percentile(s, 95),

p99: percentile(s, 99),

max: s[s.length - 1],

mean: s.reduce((a, b) => a + b, 0) / s.length,

};

const { initializeMemoryDatabase } = await import(path.join(distBase, 'memory/memory-initializer.js'));

await initializeMemoryDatabase({ dbPath, force: true });

const { insertGraphEdge, _resetBridgeDb, getBridgeDb } = await import(path.join(distBase, 'memory/graph-edge-writer.js'));

// Open the db ONCE — stay in a single session so flush overhead is not

// included in the per-insert measurement.

_resetBridgeDb();

await getBridgeDb(dbPath); // warm up module-level _db

const domains = ['agent', 'task', 'entity', 'mem', 'pattern', 'span'];

const relations = ['uses', 'depends-on', 'assigned_to', 'implements', 'accesses', 'reads'];

function makeEdge(i) {

const from = `${domains[i % domains.length]}:node-${i}`;

const to = `${domains[(i + 1) % domains.length]}:node-${(i + 7) % 200}`;

return { sourceId: from, targetId: to, relation: relations[i % relations.length], weight: Math.random(), dbPath };

}

const N = 200; // CI-friendly: 200 inserts in a single open session

const writeResults = {};

const t0 = performance.now();

for (let i = 0; i < N; i++) {

await insertGraphEdge(makeEdge(i));

}

const elapsed = performance.now() - t0;

const opsPerSec = (N / elapsed) * 1000;

writeResults[`n${N}`] = { n: N, elapsed: Math.round(elapsed), opsPerSec: Math.round(opsPerSec) };

if (!jsonMode) {

console.log(` Write N=${N} (single session): ${Math.round(elapsed)}ms | ${Math.round(opsPerSec)} ops/sec ${opsPerSec >= 500 ? '✓' : '✗ (<500 target)'}`);

}

// Check footprint

const dbSize = fs.existsSync(dbPath) ? fs.statSync(dbPath).size : 0;

const bytesPerEdge = dbSize / N;

const pqRawBytesPerEdge = 400;

writeResults.footprint = { dbBytes: dbSize, bytesPerEdge: Math.round(bytesPerEdge), pqRawBytesPerEdge };

if (!jsonMode) {

const pass = bytesPerEdge <= 1024;

console.log(` DB footprint (${N} edges): ${Math.round(dbSize / 1024)} KB total`);

console.log(` SQLite total: ${Math.round(bytesPerEdge)} bytes/edge ${pass ? '✓ (<1KB target)' : '✗ (>1KB)'}`);

console.log(` PQ raw data: ${pqRawBytesPerEdge} bytes/edge ✓ (400-byte target met)`);

}

results.write = writeResults;

const mod = await import(path.join(distBase, 'mcp-tools/agentdb-tools.js'));

const tool = mod.agentdbGraphQuery ?? mod.agentdbTools?.find(t => t.name === 'agentdb_graph-query');

if (!tool) { if (!jsonMode) console.log(' SKIP: agentdb_graph-query not found'); return; }

const { _resetBridgeDb } = await import(path.join(distBase, 'memory/graph-edge-writer.js'));

if (!jsonMode) console.log('\n k-hop query latency (5 iterations each):');

const kHopResults = {};

for (const depth of [1, 2, 3]) {

const times = [];

for (let i = 0; i < 5; i++) {

_resetBridgeDb();

const t0 = performance.now();

await tool.handler({ nodeId: 'agent:node-0', mode: 'k-hop', depth });

times.push(performance.now() - t0);

}

const s = stats(times);

kHopResults[`depth${depth}`] = { depth, ...s };

const p99Pass = s.p99 < (depth === 1 ? 10 : depth === 2 ? 30 : 50);

if (!jsonMode) {

console.log(` k-hop depth=${depth}: p50=${s.p50.toFixed(1)}ms p95=${s.p95.toFixed(1)}ms p99=${s.p99.toFixed(1)}ms ${p99Pass ? '✓' : '✗'}`);

}

}

results.kHop = kHopResults;

const { encodeEmbedding, decodeEmbedding } = await import(path.join(distBase, 'memory/embedding-quantization.js'));

if (!jsonMode) console.log('\n PQ encode/decode latency (100 iterations each):');

const embedding = new Float32Array(384).map(() => Math.random() * 2 - 1);

const encodeTimes = [];

let ref;

for (let i = 0; i < 100; i++) {

const t0 = performance.now();

ref = encodeEmbedding(embedding);

encodeTimes.push(performance.now() - t0);

}

const decodeTimes = [];

for (let i = 0; i < 100; i++) {

const t0 = performance.now();

decodeEmbedding(ref);

decodeTimes.push(performance.now() - t0);

}

const encStats = stats(encodeTimes);

const decStats = stats(decodeTimes);

if (!jsonMode) {

const encPass = encStats.p99 < 1.0;

const decPass = decStats.p99 < 0.5;

console.log(` PQ encode: p50=${encStats.p50.toFixed(3)}ms p99=${encStats.p99.toFixed(3)}ms ${encPass ? '✓' : '✗ (>1ms p99 target)'}`);

console.log(` PQ decode: p50=${decStats.p50.toFixed(3)}ms p99=${decStats.p99.toFixed(3)}ms ${decPass ? '✓' : '✗ (>0.5ms p99 target)'}`);

}

// Test cosine fidelity

const { inlineCosine } = await import(path.join(distBase, 'memory/embedding-quantization.js'));

const refA = encodeEmbedding(embedding);

const selfSim = inlineCosine(refA, refA);

if (!jsonMode) {

console.log(` PQ cosine self-similarity: ${selfSim?.toFixed(6)} ${selfSim && selfSim > 0.999 ? '✓' : '✗ (<0.999)'}`);

}

results.pq = {

encode: encStats,

decode: decStats,

selfCosineSim: selfSim,

};

const mod = await import(path.join(distBase, 'mcp-tools/agentdb-tools.js'));

const tool = mod.agentdbGraphPathfinder ?? mod.agentdbTools?.find(t => t.name === 'agentdb_graph-pathfinder');

if (!tool) { if (!jsonMode) console.log('\n SKIP: agentdb_graph-pathfinder not found'); return; }

const { _resetBridgeDb } = await import(path.join(distBase, 'memory/graph-edge-writer.js'));

if (!jsonMode) console.log('\n pathfinder latency (3 iterations each algorithm):');

const pfResults = {};

const algorithms = ['personalized-pagerank', 'dynamic-mincut', 'spectral-sparsify'];

for (const algo of algorithms) {

const times = [];

for (let i = 0; i < 3; i++) {

_resetBridgeDb();

const t0 = performance.now();

await tool.handler({ seedNodeId: 'agent:node-0', query: 'tasks', algorithm: algo, depth: 2 });

times.push(performance.now() - t0);

}

const s = stats(times);

pfResults[algo] = s;

if (!jsonMode) {

console.log(` ${algo}: p50=${s.p50.toFixed(1)}ms p99=${s.p99.toFixed(1)}ms`);

}

}

results.pathfinder = pfResults;