agentic-qe 3.6.6 → 3.6.8

package/.claude/skills/skills-manifest.json

@@ -904,7 +904,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.6.6",
+    "fleetVersion": "3.6.7",
     "manifestVersion": "1.3.0",
     "lastUpdated": "2026-02-04T00:00:00.000Z",
     "contributors": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.6.6",
+  "version": "3.6.8",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 59 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "main": "./v3/dist/index.js",
   "types": "./v3/dist/index.d.ts",
@@ -86,6 +86,8 @@
     "cli-progress": "^3.12.0",
     "commander": "^14.0.1",
     "fast-glob": "^3.3.3",
+    "fast-json-patch": "^3.1.1",
+    "jose": "^6.1.3",
     "hnswlib-node": "^3.0.0",
     "lodash": "^4.17.23",
     "ora": "^5.4.1",

package/scripts/benchmark-aqe-baseline.ts

@@ -0,0 +1,614 @@
+#!/usr/bin/env tsx
+/**
+ * AQE Baseline Performance Benchmark
+ *
+ * Measures current AQE performance characteristics for comparison
+ * with an RVF-based implementation. Covers:
+ *
+ * 1. Cold start (DB open + HNSW init)
+ * 2. Pattern insert throughput
+ * 3. Vector search latency + recall
+ * 4. KV read/write throughput
+ * 5. Memory footprint
+ * 6. File size
+ *
+ * Run: npx tsx scripts/benchmark-aqe-baseline.ts
+ */
+
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+// ── Config ──────────────────────────────────────────────────────────
+
+const BENCH_DIR = path.join('/tmp', 'aqe-benchmark-' + Date.now());
+const DB_PATH = path.join(BENCH_DIR, 'bench.db');
+const DIMENSIONS = 384; // AQE default
+const VECTOR_COUNTS = [100, 500, 1000, 5000];
+const QUERY_COUNT = 100;
+const KV_COUNT = 1000;
+const SEARCH_K = 10;
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function randomVector(dim: number): Float32Array {
+  const v = new Float32Array(dim);
+  for (let i = 0; i < dim; i++) v[i] = Math.random() * 2 - 1;
+  return v;
+}
+
+function normalizeVector(v: Float32Array): Float32Array {
+  let norm = 0;
+  for (let i = 0; i < v.length; i++) norm += v[i] * v[i];
+  norm = Math.sqrt(norm);
+  if (norm > 0) for (let i = 0; i < v.length; i++) v[i] /= norm;
+  return v;
+}
+
+function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+function bruteForceKNN(
+  query: Float32Array,
+  vectors: Float32Array[],
+  k: number
+): { id: number; similarity: number }[] {
+  const scored = vectors.map((v, i) => ({ id: i, similarity: cosineSimilarity(query, v) }));
+  scored.sort((a, b) => b.similarity - a.similarity);
+  return scored.slice(0, k);
+}
+
+function percentile(arr: number[], p: number): number {
+  const sorted = [...arr].sort((a, b) => a - b);
+  const idx = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+
+function formatMs(ms: number): string {
+  if (ms < 0.01) return `${(ms * 1000).toFixed(1)}µs`;
+  if (ms < 1) return `${ms.toFixed(2)}ms`;
+  if (ms < 1000) return `${ms.toFixed(1)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// ── SQLite Schema (mirrors AQE unified-memory) ─────────────────────
+
+function createSchema(db: ReturnType<typeof Database>) {
+  db.pragma('journal_mode = WAL');
+  db.pragma('mmap_size = 268435456');
+  db.pragma('cache_size = -64000');
+  db.pragma('busy_timeout = 5000');
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS kv_store (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      namespace TEXT DEFAULT 'default',
+      created_at INTEGER DEFAULT (strftime('%s','now')),
+      updated_at INTEGER DEFAULT (strftime('%s','now')),
+      expires_at INTEGER,
+      tags TEXT DEFAULT '[]'
+    );
+    CREATE INDEX IF NOT EXISTS idx_kv_namespace ON kv_store(namespace);
+
+    CREATE TABLE IF NOT EXISTS qe_patterns (
+      id TEXT PRIMARY KEY,
+      domain TEXT NOT NULL,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      embedding BLOB,
+      confidence REAL DEFAULT 0.5,
+      access_count INTEGER DEFAULT 0,
+      tier TEXT DEFAULT 'short-term',
+      metadata TEXT DEFAULT '{}',
+      created_at INTEGER DEFAULT (strftime('%s','now')),
+      updated_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_patterns_domain ON qe_patterns(domain);
+    CREATE INDEX IF NOT EXISTS idx_patterns_tier ON qe_patterns(tier);
+
+    CREATE TABLE IF NOT EXISTS rl_q_values (
+      state TEXT NOT NULL,
+      action TEXT NOT NULL,
+      q_value REAL NOT NULL DEFAULT 0.0,
+      visit_count INTEGER DEFAULT 0,
+      last_reward REAL DEFAULT 0.0,
+      updated_at INTEGER DEFAULT (strftime('%s','now')),
+      PRIMARY KEY (state, action)
+    );
+  `);
+}
+
+// ── Benchmarks ──────────────────────────────────────────────────────
+
+interface BenchmarkResult {
+  name: string;
+  value: number;
+  unit: string;
+  formatted: string;
+  details?: string;
+}
+
+const results: BenchmarkResult[] = [];
+
+function record(name: string, value: number, unit: string, details?: string) {
+  const formatted = unit === 'ms' ? formatMs(value) :
+                    unit === 'bytes' ? formatBytes(value) :
+                    unit === 'MB' ? `${value.toFixed(1)}MB` :
+                    unit === 'ops/s' ? `${Math.round(value).toLocaleString()} ops/s` :
+                    unit === '%' ? `${value.toFixed(1)}%` :
+                    `${value}`;
+  results.push({ name, value, unit, formatted, details });
+}
+
+async function benchmarkColdStart() {
+  console.log('\n── 1. Cold Start ──────────────────────────────────');
+
+  // Measure DB open + schema creation
+  const t0 = performance.now();
+  const db = new Database(DB_PATH);
+  createSchema(db);
+  const t1 = performance.now();
+  record('cold_start_db_open', t1 - t0, 'ms', 'DB open + schema + WAL + pragma');
+  console.log(`  DB open + schema:    ${formatMs(t1 - t0)}`);
+
+  // Measure HNSW init via @ruvector/gnn
+  let hnswInitMs = 0;
+  try {
+    const { default: gnn } = await import('@ruvector/gnn');
+    const { HNSWIndex: GNNIndex } = gnn as any;
+
+    const t2 = performance.now();
+    const idx = new GNNIndex({ dimension: DIMENSIONS, metric: 'cosine', M: 16 });
+    await idx.initialize?.();
+    const t3 = performance.now();
+    hnswInitMs = t3 - t2;
+    record('cold_start_hnsw_init', hnswInitMs, 'ms', '@ruvector/gnn HNSW init (empty)');
+    console.log(`  HNSW init (empty):   ${formatMs(hnswInitMs)}`);
+  } catch {
+    // Fallback: hnswlib-node
+    try {
+      const hnswlib = await import('hnswlib-node');
+      const { HierarchicalNSW } = hnswlib.default || hnswlib;
+
+      const t2 = performance.now();
+      const idx = new HierarchicalNSW('cosine', DIMENSIONS);
+      idx.initIndex({ maxElements: 10000, m: 16, efConstruction: 200 });
+      const t3 = performance.now();
+      hnswInitMs = t3 - t2;
+      record('cold_start_hnsw_init', hnswInitMs, 'ms', 'hnswlib-node HNSW init (empty)');
+      console.log(`  HNSW init (empty):   ${formatMs(hnswInitMs)}`);
+    } catch {
+      console.log('  HNSW init: SKIPPED (no HNSW library available)');
+    }
+  }
+
+  record('cold_start_total', (t1 - t0) + hnswInitMs, 'ms', 'Total cold start');
+  console.log(`  Total cold start:    ${formatMs((t1 - t0) + hnswInitMs)}`);
+
+  db.close();
+}
+
+async function benchmarkPatternInsert() {
+  console.log('\n── 2. Pattern Insert Throughput ────────────────────');
+
+  for (const count of VECTOR_COUNTS) {
+    const db = new Database(DB_PATH);
+    createSchema(db);
+
+    const insertStmt = db.prepare(`
+      INSERT OR REPLACE INTO qe_patterns (id, domain, type, name, description, embedding, confidence, tier)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    const vectors: Float32Array[] = [];
+    const t0 = performance.now();
+
+    const insertAll = db.transaction(() => {
+      for (let i = 0; i < count; i++) {
+        const vec = normalizeVector(randomVector(DIMENSIONS));
+        vectors.push(vec);
+        const embedding = Buffer.from(vec.buffer);
+        insertStmt.run(
+          `pattern-${i}`,
+          'test-generation',
+          'test-pattern',
+          `Pattern ${i}`,
+          `Test pattern ${i} for benchmarking`,
+          embedding,
+          Math.random(),
+          i % 3 === 0 ? 'long-term' : 'short-term'
+        );
+      }
+    });
+    insertAll();
+
+    const t1 = performance.now();
+    const totalMs = t1 - t0;
+    const opsPerSec = (count / totalMs) * 1000;
+
+    record(`insert_${count}_total`, totalMs, 'ms');
+    record(`insert_${count}_ops`, opsPerSec, 'ops/s');
+    console.log(`  ${count} patterns:     ${formatMs(totalMs)} (${Math.round(opsPerSec).toLocaleString()} ops/s)`);
+
+    // Measure file size
+    const fileSize = fs.statSync(DB_PATH).size;
+    record(`filesize_${count}_patterns`, fileSize, 'bytes');
+    console.log(`  File size:           ${formatBytes(fileSize)}`);
+
+    db.close();
+    fs.unlinkSync(DB_PATH);
+    // Remove WAL/SHM files too
+    try { fs.unlinkSync(DB_PATH + '-wal'); } catch {}
+    try { fs.unlinkSync(DB_PATH + '-shm'); } catch {}
+  }
+}
+
+async function benchmarkVectorSearch() {
+  console.log('\n── 3. Vector Search (Brute Force - SQLite BLOBs) ──');
+
+  for (const count of VECTOR_COUNTS) {
+    const db = new Database(DB_PATH);
+    createSchema(db);
+
+    // Insert vectors
+    const vectors: Float32Array[] = [];
+    const insertStmt = db.prepare(`
+      INSERT OR REPLACE INTO qe_patterns (id, domain, type, name, embedding, confidence)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+
+    const insertAll = db.transaction(() => {
+      for (let i = 0; i < count; i++) {
+        const vec = normalizeVector(randomVector(DIMENSIONS));
+        vectors.push(vec);
+        insertStmt.run(`p-${i}`, 'test-gen', 'pattern', `P${i}`, Buffer.from(vec.buffer), Math.random());
+      }
+    });
+    insertAll();
+
+    // Benchmark: load all vectors from DB and brute-force search
+    const queryVec = normalizeVector(randomVector(DIMENSIONS));
+    const latencies: number[] = [];
+
+    for (let q = 0; q < QUERY_COUNT; q++) {
+      const qv = q === 0 ? queryVec : normalizeVector(randomVector(DIMENSIONS));
+
+      const t0 = performance.now();
+
+      // Load from DB (simulates AQE's in-memory vector scan)
+      const rows = db.prepare('SELECT id, embedding FROM qe_patterns WHERE embedding IS NOT NULL').all() as any[];
+      const scored: { id: string; sim: number }[] = [];
+      for (const row of rows) {
+        const stored = new Float32Array(new Uint8Array(row.embedding).buffer);
+        scored.push({ id: row.id, sim: cosineSimilarity(qv, stored) });
+      }
+      scored.sort((a, b) => b.sim - a.sim);
+      const _topK = scored.slice(0, SEARCH_K);
+
+      const t1 = performance.now();
+      latencies.push(t1 - t0);
+    }
+
+    const p50 = percentile(latencies, 50);
+    const p95 = percentile(latencies, 95);
+    const p99 = percentile(latencies, 99);
+
+    record(`search_${count}_p50`, p50, 'ms', 'Brute force from SQLite BLOBs');
+    record(`search_${count}_p95`, p95, 'ms');
+    record(`search_${count}_p99`, p99, 'ms');
+    console.log(`  ${count} vectors: p50=${formatMs(p50)}  p95=${formatMs(p95)}  p99=${formatMs(p99)}`);
+
+    db.close();
+    fs.unlinkSync(DB_PATH);
+    try { fs.unlinkSync(DB_PATH + '-wal'); } catch {}
+    try { fs.unlinkSync(DB_PATH + '-shm'); } catch {}
+  }
+}
+
+async function benchmarkHNSWSearch() {
+  console.log('\n── 4. Vector Search (HNSW - In-Memory) ────────────');
+
+  let HNSWConstructor: any = null;
+
+  // Try @ruvector/gnn first
+  try {
+    const gnn = await import('@ruvector/gnn');
+    const mod = (gnn as any).default || gnn;
+    if (mod.HNSWIndex) {
+      HNSWConstructor = { type: 'gnn', ctor: mod.HNSWIndex };
+    }
+  } catch {}
+
+  // Fallback to hnswlib-node
+  if (!HNSWConstructor) {
+    try {
+      const hnswlib = await import('hnswlib-node');
+      const mod = (hnswlib as any).default || hnswlib;
+      HNSWConstructor = { type: 'hnswlib', ctor: mod.HierarchicalNSW };
+    } catch {}
+  }
+
+  if (!HNSWConstructor) {
+    console.log('  SKIPPED: No HNSW library available');
+    return;
+  }
+
+  console.log(`  Using: ${HNSWConstructor.type}`);
+
+  for (const count of VECTOR_COUNTS) {
+    const vectors: Float32Array[] = [];
+    for (let i = 0; i < count; i++) {
+      vectors.push(normalizeVector(randomVector(DIMENSIONS)));
+    }
+
+    // Build HNSW index
+    const t0 = performance.now();
+    let index: any;
+
+    if (HNSWConstructor.type === 'gnn') {
+      index = new HNSWConstructor.ctor({ dimension: DIMENSIONS, metric: 'cosine', M: 16 });
+      for (let i = 0; i < count; i++) {
+        index.addPoint(Array.from(vectors[i]), i);
+      }
+    } else {
+      index = new HNSWConstructor.ctor('cosine', DIMENSIONS);
+      index.initIndex({ maxElements: count + 1000, m: 16, efConstruction: 200 });
+      for (let i = 0; i < count; i++) {
+        index.addPoint(Array.from(vectors[i]), i);
+      }
+    }
+
+    const buildMs = performance.now() - t0;
+    record(`hnsw_build_${count}`, buildMs, 'ms', `${HNSWConstructor.type} build time`);
+
+    // Search
+    const latencies: number[] = [];
+    let totalRecall = 0;
+
+    if (HNSWConstructor.type === 'hnswlib') {
+      index.setEfSearch(100);
+    }
+
+    for (let q = 0; q < Math.min(QUERY_COUNT, count); q++) {
+      const queryVec = normalizeVector(randomVector(DIMENSIONS));
+      const queryArr = Array.from(queryVec);
+
+      const t1 = performance.now();
+      let hnswResults: number[];
+
+      if (HNSWConstructor.type === 'gnn') {
+        const res = index.searchKNN(queryArr, SEARCH_K);
+        hnswResults = res.neighbors || res.ids || [];
+      } else {
+        const res = index.searchKnn(queryArr, SEARCH_K);
+        hnswResults = Array.from(res.neighbors);
+      }
+      const t2 = performance.now();
+      latencies.push(t2 - t1);
+
+      // Compute recall vs brute force
+      const bruteForce = bruteForceKNN(queryVec, vectors, SEARCH_K);
+      const bfIds = new Set(bruteForce.map(r => r.id));
+      const hits = hnswResults.filter(id => bfIds.has(id)).length;
+      totalRecall += hits / SEARCH_K;
+    }
+
+    const searchCount = Math.min(QUERY_COUNT, count);
+    const avgRecall = (totalRecall / searchCount) * 100;
+    const p50 = percentile(latencies, 50);
+    const p95 = percentile(latencies, 95);
+
+    record(`hnsw_search_${count}_p50`, p50, 'ms');
+    record(`hnsw_search_${count}_p95`, p95, 'ms');
+    record(`hnsw_search_${count}_recall`, avgRecall, '%');
+
+    console.log(`  ${count} vectors: build=${formatMs(buildMs)}  search p50=${formatMs(p50)}  p95=${formatMs(p95)}  recall@${SEARCH_K}=${avgRecall.toFixed(1)}%`);
+  }
+}
+
+async function benchmarkKVOps() {
+  console.log('\n── 5. KV Store Throughput ──────────────────────────');
+
+  const db = new Database(DB_PATH);
+  createSchema(db);
+
+  const insertStmt = db.prepare(`
+    INSERT OR REPLACE INTO kv_store (key, value, namespace) VALUES (?, ?, ?)
+  `);
+  const getStmt = db.prepare('SELECT value FROM kv_store WHERE key = ? AND namespace = ?');
+
+  // Write throughput
+  const t0 = performance.now();
+  const writeAll = db.transaction(() => {
+    for (let i = 0; i < KV_COUNT; i++) {
+      insertStmt.run(`key-${i}`, JSON.stringify({ data: `value-${i}`, ts: Date.now() }), 'bench');
+    }
+  });
+  writeAll();
+  const writeMs = performance.now() - t0;
+  const writeOps = (KV_COUNT / writeMs) * 1000;
+
+  record('kv_write_total', writeMs, 'ms', `${KV_COUNT} writes`);
+  record('kv_write_ops', writeOps, 'ops/s');
+  console.log(`  Write ${KV_COUNT}:     ${formatMs(writeMs)} (${Math.round(writeOps).toLocaleString()} ops/s)`);
+
+  // Read throughput
+  const t1 = performance.now();
+  for (let i = 0; i < KV_COUNT; i++) {
+    getStmt.get(`key-${i}`, 'bench');
+  }
+  const readMs = performance.now() - t1;
+  const readOps = (KV_COUNT / readMs) * 1000;
+
+  record('kv_read_total', readMs, 'ms', `${KV_COUNT} reads`);
+  record('kv_read_ops', readOps, 'ops/s');
+  console.log(`  Read ${KV_COUNT}:      ${formatMs(readMs)} (${Math.round(readOps).toLocaleString()} ops/s)`);
+
+  // Random read
+  const t2 = performance.now();
+  for (let i = 0; i < KV_COUNT; i++) {
+    const key = `key-${Math.floor(Math.random() * KV_COUNT)}`;
+    getStmt.get(key, 'bench');
+  }
+  const randReadMs = performance.now() - t2;
+  const randReadOps = (KV_COUNT / randReadMs) * 1000;
+
+  record('kv_random_read_total', randReadMs, 'ms', `${KV_COUNT} random reads`);
+  record('kv_random_read_ops', randReadOps, 'ops/s');
+  console.log(`  Random read ${KV_COUNT}: ${formatMs(randReadMs)} (${Math.round(randReadOps).toLocaleString()} ops/s)`);
+
+  db.close();
+  fs.unlinkSync(DB_PATH);
+  try { fs.unlinkSync(DB_PATH + '-wal'); } catch {}
+  try { fs.unlinkSync(DB_PATH + '-shm'); } catch {}
+}
+
+async function benchmarkMemoryFootprint() {
+  console.log('\n── 6. Memory Footprint ────────────────────────────');
+
+  const baseline = process.memoryUsage();
+
+  // Load vectors into memory (simulating HNSW index rebuild)
+  const vectors: Float32Array[] = [];
+  for (let i = 0; i < 5000; i++) {
+    vectors.push(normalizeVector(randomVector(DIMENSIONS)));
+  }
+
+  const afterVectors = process.memoryUsage();
+  const vectorMB = (afterVectors.heapUsed - baseline.heapUsed) / (1024 * 1024);
+  record('memory_5000_vectors', vectorMB, 'MB', `5000 × ${DIMENSIONS}-dim Float32Array in memory`);
+  console.log(`  5000 vectors:        ${vectorMB.toFixed(1)}MB heap`);
+  console.log(`  Per vector:          ${((vectorMB * 1024 * 1024) / 5000).toFixed(0)} bytes`);
+  console.log(`  Theoretical:         ${(5000 * DIMENSIONS * 4 / (1024 * 1024)).toFixed(1)}MB raw`);
+}
+
+async function benchmarkQValueOps() {
+  console.log('\n── 7. Q-Value Operations ──────────────────────────');
+
+  const db = new Database(DB_PATH);
+  createSchema(db);
+
+  const upsertStmt = db.prepare(`
+    INSERT INTO rl_q_values (state, action, q_value, visit_count, last_reward)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(state, action) DO UPDATE SET
+      q_value = excluded.q_value,
+      visit_count = visit_count + 1,
+      last_reward = excluded.last_reward,
+      updated_at = strftime('%s','now')
+  `);
+
+  const lookupStmt = db.prepare(`
+    SELECT action, q_value FROM rl_q_values
+    WHERE state = ?
+    ORDER BY q_value DESC
+    LIMIT 5
+  `);
+
+  // Write Q-values
+  const states = 100;
+  const actionsPerState = 10;
+  const t0 = performance.now();
+  const writeAll = db.transaction(() => {
+    for (let s = 0; s < states; s++) {
+      for (let a = 0; a < actionsPerState; a++) {
+        upsertStmt.run(`state-${s}`, `action-${a}`, Math.random(), 1, Math.random());
+      }
+    }
+  });
+  writeAll();
+  const writeMs = performance.now() - t0;
+  console.log(`  Write ${states * actionsPerState} Q-values: ${formatMs(writeMs)}`);
+  record('qvalue_write_1000', writeMs, 'ms');
+
+  // Lookup best actions
+  const lookupLatencies: number[] = [];
+  for (let q = 0; q < 200; q++) {
+    const state = `state-${Math.floor(Math.random() * states)}`;
+    const t1 = performance.now();
+    lookupStmt.all(state);
+    lookupLatencies.push(performance.now() - t1);
+  }
+
+  const p50 = percentile(lookupLatencies, 50);
+  const p95 = percentile(lookupLatencies, 95);
+  record('qvalue_lookup_p50', p50, 'ms');
+  record('qvalue_lookup_p95', p95, 'ms');
+  console.log(`  Lookup best action: p50=${formatMs(p50)}  p95=${formatMs(p95)}`);
+
+  db.close();
+  fs.unlinkSync(DB_PATH);
+  try { fs.unlinkSync(DB_PATH + '-wal'); } catch {}
+  try { fs.unlinkSync(DB_PATH + '-shm'); } catch {}
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log('╔═══════════════════════════════════════════════════════════╗');
+  console.log('║         AQE Baseline Performance Benchmark               ║');
+  console.log('║         Dimensions: 384  |  Metric: cosine               ║');
+  console.log('╚═══════════════════════════════════════════════════════════╝');
+
+  console.log(`\n  Platform:    ${process.platform} ${process.arch}`);
+  console.log(`  Node:        ${process.version}`);
+  console.log(`  Bench dir:   ${BENCH_DIR}`);
+  console.log(`  Timestamp:   ${new Date().toISOString()}`);
+
+  fs.mkdirSync(BENCH_DIR, { recursive: true });
+
+  await benchmarkColdStart();
+  await benchmarkPatternInsert();
+  await benchmarkVectorSearch();
+  await benchmarkHNSWSearch();
+  await benchmarkKVOps();
+  await benchmarkMemoryFootprint();
+  await benchmarkQValueOps();
+
+  // ── Summary table ──
+  console.log('\n╔═══════════════════════════════════════════════════════════╗');
+  console.log('║                    SUMMARY TABLE                         ║');
+  console.log('╠═══════════════════════════════════════════════════════════╣');
+  console.log('║  Metric                          │  Value                ║');
+  console.log('╟──────────────────────────────────┼───────────────────────╢');
+  for (const r of results) {
+    const name = r.name.padEnd(32).slice(0, 32);
+    const val = r.formatted.padStart(21).slice(-21);
+    console.log(`║  ${name}  │  ${val}  ║`);
+  }
+  console.log('╚══════════════════════════════════╧═══════════════════════╝');
+
+  // Write JSON results
+  const jsonPath = path.join(BENCH_DIR, 'results.json');
+  fs.writeFileSync(jsonPath, JSON.stringify({
+    timestamp: new Date().toISOString(),
+    platform: `${process.platform} ${process.arch}`,
+    node: process.version,
+    dimensions: DIMENSIONS,
+    results,
+  }, null, 2));
+  console.log(`\n  Results saved to: ${jsonPath}`);
+
+  // Cleanup
+  try {
+    fs.rmSync(BENCH_DIR, { recursive: true });
+  } catch {}
+}
+
+main().catch(console.error);

package/v3/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to Agentic QE will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.6.8] - 2026-02-15
+
+### Fixed
+
+- **MCP tools failing with "Fleet not initialized"** — Every MCP tool call required a prior `fleet_init` call, which Claude Code doesn't do automatically. Fleet now auto-initializes on MCP server startup with default configuration (hierarchical topology, hybrid memory).
+- **Experience persistence gap** — Learning system (`ExperienceReplay`) read from a separate `experiences` table while the capture middleware wrote to `captured_experiences`, so new experiences were never visible to the learning system. Unified to use `captured_experiences` as the single source of truth.
+- **Split-brain database from relative dbPath** — `UnifiedMemoryManager` accepted relative paths (e.g. `.agentic-qe/memory.db`) which could create duplicate databases when CWD differed from project root. Now resolves relative paths through `findProjectRoot()`.
+- **Missing runtime dependency `fast-json-patch`** (#262) — Package was marked as external in the MCP esbuild bundle but not listed in root `package.json`, causing `ERR_MODULE_NOT_FOUND` on fresh installs. Added `fast-json-patch` and `jose` to root dependencies.
+
+### Changed
+
+- **Data migrator** — v2-to-v3 migration now writes to `captured_experiences` table instead of the removed `experiences` table.
+
+## [3.6.7] - 2026-02-14
+
+### Fixed
+
+- **Database corruption from concurrent VACUUM** — Automated VACUUM in HybridBackend ran every 10 minutes while 3+ hook processes held concurrent SQLite connections, causing intermittent "database disk image is malformed" errors. Removed automated VACUUM entirely; SQLite WAL mode handles space reclamation safely without it.
+- **Dual-database split-brain** — `findProjectRoot()` found the first `.agentic-qe` directory walking up, which resolved to `v3/.agentic-qe` instead of root. Changed to find the topmost `.agentic-qe`, preventing shadow databases from forming.
+- **Vector table bloat (124MB)** — Every HNSW index insert wrote vectors to SQLite's `vectors` table via `storeVector()`, accumulating 30K+ rows (124MB). Removed persistence since the in-memory HNSW index is the source of truth for search.
+- **Cross-domain transfer re-running every session** — The seed flag (`reasoning-bank:cross-domain-seeded`) was set after `seedCrossDomainPatterns()`, but the 10-second hooks init timeout could fire mid-transfer, preventing the flag from ever being written. Moved the flag write before the transfer so it persists even on timeout.
+- **Stop hook JSON validation error** — Stop hook output included `hookSpecificOutput` with `hookEventName: "Stop"`, but Claude Code's hook schema only accepts this field for PreToolUse, UserPromptSubmit, and PostToolUse events. Simplified to plain JSON output.
+- **Hypergraph database path** — Code-intelligence coordinator used a relative path `.agentic-qe/hypergraph.db`, which created a shadow directory when run from `v3/`. Fixed to use `findProjectRoot()`.
+- **Seed flag namespace collision** — Graph-boundaries kv_store writes used wrong namespace, causing cross-domain seed flag to not persist correctly.
+
+### Added
+
+- **File guardian hook** — Pre-edit hook that protects critical files (database files, WAL files, config) from accidental modification.
+- **Command bouncer hook** — Pre-command hook that blocks dangerous shell commands (rm -rf on databases, VACUUM on live DB) with configurable rules.
+- **Context injection hook** — Injects relevant context (recent patterns, domain knowledge) into prompts via UserPromptSubmit hooks.
+- **Tier 2/3 kv_store persistence** — Learning experiences and routing feedback now persist to kv_store for cross-session retention.
+- **Coverage learner feedback loop** — Tracks test outcomes and coverage trends to improve future test generation.
+- **Token usage tracker** — Records token consumption per operation for cost analysis and optimization.
+- **Q-learning router** — Reinforcement learning-based routing that improves agent selection over time.
+- **RuVector WASM integrations** — AST complexity analyzer, coverage router, diff-risk classifier, and graph boundaries modules for fast local inference.
+
+### Changed
+
+- **Knowledge graph cache-only mode** — Code-intelligence knowledge graph no longer persists to PostgreSQL by default, preventing errors when PG is unavailable. Uses in-memory graph with SQLite-backed concept nodes/edges.
+- **Pattern store simplified** — Removed unused code paths and reduced complexity in pattern persistence layer.
+
 ## [3.6.6] - 2026-02-13
 
 ### Fixed