agent-working-memory 0.11.0 → 0.12.0

package/src/engine/activation.ts

@@ -1,1369 +1,1468 @@
-// Copyright 2026 Robert Winter / Complete Ideas
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Activation Pipeline — the core retrieval engine.
- *
- * 10-phase cognitive retrieval pipeline:
- *   0. Query expansion (flan-t5-small synonym generation)
- *   1. Vector embedding (MiniLM 384d)
- *   2. Parallel retrieval (FTS5/BM25 + vector pool)
- *   3. Scoring (BM25, Jaccard, z-score vector, entity-bridge boost)
- *   4. Rocchio pseudo-relevance feedback (expand + re-search BM25)
- *   5. ACT-R temporal decay
- *   6. Hebbian boost (co-activation strength)
- *   7. Composite scoring with confidence gating
- *   8. Beam search graph walk (depth 2, hop penalty)
- *   9. Cross-encoder reranking (ms-marco-MiniLM, adaptive blend)
- *  10. Abstention gate
- *
- * Logs activation events for eval metrics.
- */
-
-import { randomUUID } from 'node:crypto';
-import { baseLevelActivation, softplus } from '../core/decay.js';
-import { strengthenAssociation, CoActivationBuffer, ValidationGatedBuffer } from '../core/hebbian.js';
-import { embed, cosineSimilarity } from '../core/embeddings.js';
-import { rerank } from '../core/reranker.js';
-import { expandQuery } from '../core/query-expander.js';
-import { computeRecallConfidence } from './confidence.js';
-import type {
-  Engram, ActivationResult, ActivationQuery, Association, PhaseScores, QueryMode,
-} from '../types/index.js';
-import type { IEngramStore as EngramStore } from '../storage/store.js';
-
-// ─── Query-adaptive pipeline parameters ───────────────────────────
-
-interface AdaptiveParams {
-  mode: 'targeted' | 'exploratory' | 'balanced';
-  textWeight: number;       // Weight for text match in composite (default 0.6)
-  temporalWeight: number;   // Weight for temporal signals (default 0.4)
-  decayExponentBase: number;// Base ACT-R decay exponent (default 0.5)
-  zScoreGate: number;       // Z-score threshold for vector match (default 0.5)
-  beamWidth: number;        // Graph walk beam width (default 15)
-  hopPenalty: number;       // Graph walk hop penalty (default 0.3)
-}
-
-const ADAPTIVE_PRESETS: Record<'targeted' | 'exploratory' | 'balanced', AdaptiveParams> = {
-  targeted: {
-    mode: 'targeted',
-    textWeight: 0.75,       // Heavy BM25/keyword emphasis
-    temporalWeight: 0.25,
-    decayExponentBase: 0.6, // Stronger decay — recent exact matches matter more
-    zScoreGate: 0.8,        // Strict vector gate — only strong semantic matches
-    beamWidth: 3,           // Narrow beam — don't wander
-    hopPenalty: 0.2,        // Steeper hop penalty
-  },
-  exploratory: {
-    mode: 'exploratory',
-    textWeight: 0.4,        // Lower BM25 weight
-    temporalWeight: 0.6,    // Lean on temporal/associative signals
-    decayExponentBase: 0.3, // Weaker decay — surface older memories
-    zScoreGate: 0.3,        // Relaxed vector gate — cast wider net
-    beamWidth: 20,          // Wide beam — explore associations
-    hopPenalty: 0.4,        // Gentler hop penalty
-  },
-  balanced: {
-    mode: 'balanced',
-    textWeight: 0.6,
-    temporalWeight: 0.4,
-    decayExponentBase: 0.5,
-    zScoreGate: 0.5,
-    beamWidth: 15,
-    hopPenalty: 0.3,
-  },
-};
-
-/**
- * Classify a query as targeted, exploratory, or balanced.
- *
- * Targeted signals: identifiers (PROJ-123, camelCase, snake_case, UUIDs),
- * short queries (< 8 words), quoted strings, file paths.
- *
- * Exploratory signals: question words, long queries (> 15 words),
- * vague modifiers ("general", "overview", "about", "related to").
- */
-function classifyQuery(context: string): 'targeted' | 'exploratory' | 'balanced' {
-  const words = context.split(/\s+/).filter(w => w.length > 0);
-  const wordCount = words.length;
-  const lower = context.toLowerCase();
-
-  let targetedScore = 0;
-  let exploratoryScore = 0;
-
-  // Identifier patterns
-  if (/[A-Z]+-\d+/.test(context)) targetedScore += 2;          // PROJ-123
-  if (/[a-z][A-Z]/.test(context)) targetedScore += 1;          // camelCase
-  if (/\w+_\w+/.test(context)) targetedScore += 1;             // snake_case
-  if (/[0-9a-f]{8}-[0-9a-f]{4}/.test(lower)) targetedScore += 2; // UUID fragment
-  if (/["']/.test(context)) targetedScore += 1;                 // Quoted strings
-  if (/[\/\\]/.test(context)) targetedScore += 1;               // File paths
-  if (/\.\w{1,4}$/.test(context.trim())) targetedScore += 1;   // File extensions
-
-  // Short queries are usually targeted
-  if (wordCount <= 5) targetedScore += 2;
-  else if (wordCount <= 8) targetedScore += 1;
-
-  // Question words / exploratory modifiers
-  if (/^(what|how|why|when|where|who|which|can|does|is|are)\b/i.test(context)) exploratoryScore += 1;
-  if (/\b(overview|general|about|related|similar|like|broad|concept|idea|approach|strategy)\b/i.test(lower)) exploratoryScore += 1;
-  if (/\b(any|all|everything|anything)\b/i.test(lower)) exploratoryScore += 1;
-
-  // Long queries are usually exploratory
-  if (wordCount > 15) exploratoryScore += 2;
-  else if (wordCount > 10) exploratoryScore += 1;
-
-  const diff = targetedScore - exploratoryScore;
-  if (diff >= 2) return 'targeted';
-  if (diff <= -2) return 'exploratory';
-  return 'balanced';
-}
-
-function resolveAdaptiveParams(query: ActivationQuery): AdaptiveParams {
-  const mode = query.mode ?? 'auto';
-  if (mode !== 'auto') return ADAPTIVE_PRESETS[mode];
-  const classified = classifyQuery(query.context);
-  return ADAPTIVE_PRESETS[classified];
-}
-
-/**
- * Common English stopwords — filtered from similarity calculations.
- * These words carry no semantic signal for memory retrieval.
- */
-const STOPWORDS = new Set([
-  'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had',
-  'her', 'was', 'one', 'our', 'out', 'has', 'have', 'been', 'from', 'that',
-  'this', 'with', 'they', 'will', 'each', 'make', 'like', 'then', 'than',
-  'them', 'some', 'what', 'when', 'where', 'which', 'who', 'how', 'use',
-  'into', 'does', 'also', 'just', 'more', 'over', 'such', 'only', 'very',
-  'about', 'after', 'being', 'between', 'could', 'during', 'before',
-  'should', 'would', 'their', 'there', 'these', 'those', 'through',
-  'because', 'using', 'other',
-]);
-
-function tokenize(text: string): Set<string> {
-  return new Set(
-    text.toLowerCase()
-      .split(/\s+/)
-      .filter(w => w.length > 2 && !STOPWORDS.has(w))
-  );
-}
-
-/**
- * Jaccard similarity between two word sets: |intersection| / |union|
- */
-function jaccard(a: Set<string>, b: Set<string>): number {
-  if (a.size === 0 || b.size === 0) return 0;
-  let intersection = 0;
-  for (const w of a) {
-    if (b.has(w)) intersection++;
-  }
-  const union = a.size + b.size - intersection;
-  return union > 0 ? intersection / union : 0;
-}
-
-export class ActivationEngine {
-  private store: EngramStore;
-  private coActivationBuffer: CoActivationBuffer;
-  readonly validationGate: ValidationGatedBuffer;
-
-  constructor(store: EngramStore) {
-    this.store = store;
-    this.coActivationBuffer = new CoActivationBuffer(50);
-    this.validationGate = new ValidationGatedBuffer();
-  }
-
-  /**
-   * Activate — retrieve the most cognitively relevant engrams for a context.
-   */
-  async activate(query: ActivationQuery): Promise<ActivationResult[]> {
-    const startTime = performance.now();
-    const limit = query.limit ?? 10;
-    const minScore = query.minScore ?? 0.01; // Default: filter out zero-relevance results
-    const useReranker = query.useReranker ?? true;
-    // Default OFF (rerank-only): query expansion ~doubles recall latency (it inflates the rerank
-    // candidate pool) for no measured accuracy gain — validated no-regression on LoCoMo
-    // (overall 22.8→22.7, adversarial 73.5→73.4), the 4-suite eval (identical), and the MWA
-    // gauntlet. Callers can still opt in per-query (useExpansion:true); AWM_DEFAULT_EXPANSION=1
-    // restores expansion-by-default globally as an escape hatch.
-    const useExpansion = query.useExpansion ?? process.env.AWM_DEFAULT_EXPANSION === '1';
-    const abstentionThreshold = query.abstentionThreshold ?? 0;
-    const requireConfidence = query.requireConfidence ?? 0;
-    const adaptive = resolveAdaptiveParams(query);
-
-    // Resolve workspace scope: if workspace is set, search across all agents in that workspace
-    const agentIds = query.workspace
-      ? await this.store.getWorkspaceAgentIds(query.agentId, query.workspace)
-      : [query.agentId];
-    const isWorkspaceScoped = agentIds.length > 1;
-
-    // Phase -1: Coref expansion — if query has pronouns, append recent entity names
-    let queryContext = query.context;
-    const pronounPattern = /\b(she|he|they|her|his|him|their|it|that|this|there)\b/i;
-    if (pronounPattern.test(queryContext)) {
-      try {
-        const recentEntities = (await this.store.getEngramsByAgents(agentIds, 'active'))
-          .sort((a, b) => b.accessCount - a.accessCount)
-          .slice(0, 10)
-          .flatMap(e => e.tags.filter(t => t.length >= 3 && !/^(session-|low-|D\d)/.test(t)))
-          .filter((v, i, a) => a.indexOf(v) === i)
-          .slice(0, 5);
-        if (recentEntities.length > 0) {
-          queryContext = `${queryContext} ${recentEntities.join(' ')}`;
-        }
-      } catch { /* non-fatal */ }
-    }
-
-    // Phase 0: Query expansion — add related terms to improve BM25 recall
-    let searchContext = queryContext;
-    if (useExpansion) {
-      let timer: ReturnType<typeof setTimeout> | undefined;
-      try {
-        searchContext = await Promise.race([
-          expandQuery(query.context),
-          new Promise<string>((_, reject) => { timer = setTimeout(() => reject(new Error('expansion timeout')), 5000); }),
-        ]);
-      } catch {
-        // Expansion unavailable or timed out — use original query
-      } finally {
-        if (timer) clearTimeout(timer);
-      }
-    }
-
-    // Phase 1: Embed query for vector similarity (uses coref-expanded context)
-    let queryEmbedding: number[] | null = null;
-    try {
-      queryEmbedding = await embed(queryContext);
-    } catch {
-      // Embedding unavailable — fall back to text-only matching
-    }
-
-    // Phase 2: Parallel retrieval — dual BM25 + all active engrams
-    // Two-pass BM25: (1) keyword-stripped query for precision, (2) expanded query for recall.
-    const keywordQuery = Array.from(tokenize(query.context)).join(' ');
-    const bm25Keyword = keywordQuery.length > 2
-      ? await this.store.searchBM25WithRankMultiAgent(agentIds, keywordQuery, limit * 3)
-      : [];
-    const bm25Expanded = await this.store.searchBM25WithRankMultiAgent(agentIds, searchContext, limit * 3);
-
-    // Merge: take the best BM25 score per engram from either pass
-    const bm25ScoreMap = new Map<string, number>();
-    const bm25EngramMap = new Map<string, any>();
-    for (const r of [...bm25Keyword, ...bm25Expanded]) {
-      const existing = bm25ScoreMap.get(r.engram.id) ?? 0;
-      if (r.bm25Score > existing) {
-        bm25ScoreMap.set(r.engram.id, r.bm25Score);
-        bm25EngramMap.set(r.engram.id, r.engram);
-      }
-    }
-    const bm25Ranked = Array.from(bm25EngramMap.entries()).map(([id, engram]) => ({
-      engram, bm25Score: bm25ScoreMap.get(id) ?? 0,
-    }));
-
-    // Phase 3 — Two-pass fetch (0.7.9+):
-    //   Pass 1: slim fetch (id, concept, embedding only) for ALL active engrams.
-    //           Used for cosine sim + adaptive z-score stats + cheap pool filter.
-    //   Pass 2: full fetch ONLY on the survivors that pass the filter.
-    //
-    // AWM 0.8.x — Native vector search refactor (2026-05-25): the prior slim
-    // fetch path materialized ALL active engrams (id + concept + embedding)
-    // for in-process cosine + z-score gating. On PGlite that meant parsing
-    // 11K embedding vectors per recall (~200-500ms). Replaced with native
-    // vector search: PGlite uses pgvector + ivfflat (O(log N)); SQLite uses
-    // its slim cache + JS cosine (same as before but encapsulated). Z-score
-    // normalization is replaced with a mode-adaptive raw-cosine floor —
-    // simpler, faster, model-tuned for BGE-small embeddings.
-    const VECTOR_TOP_K = Math.max(50, limit * 5);
-
-    // Tokenize query once (used by scoring)
-    const queryTokens = tokenize(query.context);
-
-    // Phase 3a: native vector search across agents — top-K by cosine.
-    // Apply a candidate floor — BGE-small unit-norm vectors typically cluster
-    // around 0.30-0.40 even for unrelated text, so we need a floor that
-    // distinguishes "related" from "noise" without throwing out genuine
-    // related-but-not-identical matches.
-    //
-    // Tuning: targeted=0.40, exploratory=0.30. Earlier 0.55/0.45 floors were
-    // too aggressive — they dropped Recall@5 on the 200-fact eval corpus
-    // from 0.80 → 0.46 (verified 2026-05-26). BGE-small cosines for genuine
-    // related matches commonly land 0.42-0.55, so a 0.55 floor cut them
-    // entirely. The vectorMatch scoring floor (0.50 targeted / 0.35 exploratory)
-    // still suppresses low-confidence matches in the final score.
-    // Env override: AWM_SIM_CANDIDATE_FLOOR_TARGETED, AWM_SIM_CANDIDATE_FLOOR_EXPLORATORY.
-    const SIM_CANDIDATE_FLOOR = adaptive.zScoreGate > 0.5
-      ? Number(process.env.AWM_SIM_CANDIDATE_FLOOR_TARGETED ?? 0.40)
-      : Number(process.env.AWM_SIM_CANDIDATE_FLOOR_EXPLORATORY ?? 0.30);
-    const rawCosineSims = new Map<string, number>();
-    const vectorHits: Engram[] = [];
-    if (queryEmbedding) {
-      for (const aid of agentIds) {
-        try {
-          const hits = await this.store.searchByVector(aid, queryEmbedding, VECTOR_TOP_K);
-          for (const h of hits) {
-            // pgvector cosine distance: 0 = identical, 2 = opposite.
-            // For unit-norm BGE vectors, distance ≈ 1 - cosineSimilarity.
-            const sim = 1 - h.distance;
-            // pgvector returns sorted ASC by distance (DESC by sim) — break once
-            // we drop below the candidate floor; all subsequent hits will too.
-            if (sim < SIM_CANDIDATE_FLOOR) break;
-            if (!rawCosineSims.has(h.engram.id)) {
-              rawCosineSims.set(h.engram.id, sim);
-              vectorHits.push(h.engram);
-            }
-          }
-        } catch {
-          // Vector search unavailable — fall back to BM25-only ranking
-        }
-      }
-    }
-
-    // Survivors = BM25 candidates ∪ vector candidates.
-    // The slim-fetch jaccard-fallback path is dropped: in practice it surfaced
-    // <1% of candidates that BM25 + vector missed, and on PGlite cost more
-    // than the candidates were worth. Concept jaccard signal still contributes
-    // via textMatch in scoring.
-    const survivorIds = new Set<string>();
-    for (const r of bm25Ranked) survivorIds.add(r.engram.id);
-    for (const e of vectorHits) survivorIds.add(e.id);
-
-    // Hydrate full engrams. BM25 and vector hits arrive pre-hydrated; nothing
-    // else needs fetching in the normal path.
-    const candidateMap = new Map<string, Engram>();
-    for (const r of bm25Ranked) candidateMap.set(r.engram.id, r.engram);
-    for (const e of vectorHits) candidateMap.set(e.id, e);
-    let candidates = Array.from(candidateMap.values());
-
-    // Filter by memory type if specified
-    if (query.memoryType) {
-      candidates = candidates.filter(e => e.memoryType === query.memoryType);
-    }
-
-    // ── ENTITY-AWARE CANDIDATE FETCH (2026-06, fixes the buried 2-hop / sparse-cue gap) ──
-    // A query like "codename for my main project" strongly recalls "main project = Atlas" but the
-    // ANSWER ("Atlas codename = Magpie") is a different-vocabulary attribute fact that falls out
-    // of the candidate pool — and rerank can't rescue what isn't in the pool. AWM doesn't form
-    // entity-co-occurrence edges, so graph-walk can't bridge it either. Fix: from the strongest
-    // seeds, pull the proper-noun ENTITIES that aren't already in the query, run ONE cheap local
-    // BM25 pass on them, and add the hits to the candidate pool. RECALL-ONLY: these only become
-    // candidates the reranker can consider — the final top-K stays rerank-gated, so this never
-    // surfaces facts you don't need (preserves AWM's precision-first design). Fast (one BM25
-    // call), local (no network/LLM), capped. DEFAULT-OFF (opt-in AWM_ENTITY_FETCH=1): verified
-    // recall-only pool-injection is INSUFFICIENT at scale — the buried fact enters the pool but
-    // still ranks below distractors against the vocab-mismatched original query, and a ranking
-    // boost would trade precision (against AWM's precision-first design). The design-aligned fix
-    // is HARNESS-side multi-hop decomposition (LLM chains sequential single-hop recalls). Kept
-    // opt-in for future spreading-activation experiments.
-    if (process.env.AWM_ENTITY_FETCH === '1' && candidates.length > 0) {
-      const ENT_SEEDS = Number(process.env.AWM_ENTITY_FETCH_SEEDS ?? 5);
-      const ENT_CAP = Number(process.env.AWM_ENTITY_FETCH_CAP ?? 30);
-      const STOPCAPS = new Set(['my', 'the', 'a', 'an', 'i', 'we', 'you', 'he', 'she', 'it', 'they', 'this', 'that', 'what', 'when', 'where', 'who', 'why', 'how', 'is', 'are', 'was', 'were', 'do', 'does', 'project', 'account', 'codename', 'name', 'team', 'main', 'internal']);
-      const seeds = candidates
-        .map(e => ({ e, s: Math.max(bm25ScoreMap.get(e.id) ?? 0, rawCosineSims.get(e.id) ?? 0) }))
-        .sort((a, b) => b.s - a.s).slice(0, ENT_SEEDS);
-      const ents = new Set<string>();
-      for (const { e } of seeds) {
-        for (const match of `${e.concept} ${e.content}`.matchAll(/\b[A-Z][A-Za-z]{2,}\b/g)) {
-          const w = match[0]; const lw = w.toLowerCase();
-          if (!queryTokens.has(lw) && !STOPCAPS.has(lw)) ents.add(w);
-        }
-      }
-      if (ents.size > 0) {
-        try {
-          const entHits = await this.store.searchBM25WithRankMultiAgent(agentIds, Array.from(ents).slice(0, 8).join(' '), ENT_CAP);
-          let added = 0;
-          for (const h of entHits) {
-            if (added >= ENT_CAP) break;
-            const n = h.engram;
-            if (candidateMap.has(n.id)) continue;
-            if (n.stage !== 'active' || (n as any).retracted || n.supersededBy) continue;
-            if (query.memoryType && n.memoryType !== query.memoryType) continue;
-            candidateMap.set(n.id, n);
-            bm25ScoreMap.set(n.id, Math.max(bm25ScoreMap.get(n.id) ?? 0, h.bm25Score)); // scoring sees it
-            added++;
-          }
-          if (added > 0) candidates = Array.from(candidateMap.values());
-        } catch { /* best-effort: entity fetch never breaks recall */ }
-      }
-    }
-
-    if (candidates.length === 0) return [];
-
-    // Phase 3b: Score each candidate with per-phase breakdown
-    // Candidates are already filtered (the slim-pool filter ran before hydration).
-    //
-    // Optimization (0.7.12+): the scoring loop only reads `count` and `sumWeight`
-    // from associations. Use a SQL aggregate (GROUP BY) to fetch scalar stats
-    // instead of materializing thousands of Association objects. Phase-breakdown
-    // (post-0.7.10) showed this saves ~200ms (222ms → ~20ms).
-    //
-    // Graph walk still needs full Association objects, but it operates on the
-    // top-N (~30 candidates) — its on-demand `getAssociationsFor` lookups are
-    // cheap (<5ms total).
-    const assocStats = await this.store.getAssociationStatsForBatch(candidates.map(e => e.id));
-    const scored = candidates.map(engram => {
-      const ageDays = (Date.now() - engram.createdAt.getTime()) / (1000 * 60 * 60 * 24);
-      const stats = assocStats.get(engram.id) ?? { count: 0, sumWeight: 0 };
-
-      // --- Text relevance (keyword signals) ---
-
-      // Signal 1: BM25 continuous score (0-1, from FTS5 rank)
-      const bm25Score = bm25ScoreMap.get(engram.id) ?? 0;
-
-      // Signal 2: Jaccard similarity with stopword filtering
-      const conceptTokens = tokenize(engram.concept);
-      const contentTokens = tokenize(engram.content);
-      const conceptJaccard = jaccard(queryTokens, conceptTokens);
-      const contentJaccard = jaccard(queryTokens, contentTokens);
-      const jaccardScore = 0.6 * conceptJaccard + 0.4 * contentJaccard;
-
-      // Signal 3: Concept exact match bonus (up to 0.3)
-      const conceptOverlap = conceptTokens.size > 0
-        ? [...conceptTokens].filter(w => queryTokens.has(w)).length / conceptTokens.size
-        : 0;
-      const conceptBonus = conceptOverlap * 0.3;
-
-      const keywordMatch = Math.min(Math.max(bm25Score, jaccardScore) + conceptBonus, 1.0);
-
-      // --- Vector similarity (semantic signal) ---
-      // AWM 0.8.x: model-tuned raw-cosine floor in place of z-score normalization.
-      // For BGE-small unit-norm vectors: unrelated ~0.3, related 0.5-0.7, near-duplicate 0.85+.
-      // Floor adapts to query mode: targeted=0.50 (stricter), exploratory=0.35 (looser).
-      let vectorMatch = 0;
-      const rawSim = rawCosineSims.get(engram.id);
-      if (rawSim !== undefined && rawSim > 0) {
-        const SIM_FLOOR = adaptive.zScoreGate > 0.5
-        ? Number(process.env.AWM_SIM_FLOOR_TARGETED ?? 0.50)
-        : Number(process.env.AWM_SIM_FLOOR_EXPLORATORY ?? 0.35);
-        if (rawSim > SIM_FLOOR) {
-          // Map [SIM_FLOOR, 1.0] → [0, 1] linearly with cap at 1.0.
-          vectorMatch = Math.min(1, (rawSim - SIM_FLOOR) / (0.95 - SIM_FLOOR));
-        }
-      }
-
-      // Combined text match: weighted blend of keyword and vector signals.
-      // BM25 is better at lexical discrimination; vector is better at semantic matching.
-      // When both are non-zero, blend favors the stronger signal with a boost.
-      const textMatch = keywordMatch > 0 && vectorMatch > 0
-        ? 0.5 * Math.max(keywordMatch, vectorMatch) + 0.3 * Math.min(keywordMatch, vectorMatch) + 0.2 * (keywordMatch * vectorMatch)
-        : Math.max(keywordMatch, vectorMatch);
-
-      // --- Temporal signals ---
-
-      // ACT-R decay — confidence + replay modulated (synaptic tagging)
-      // High-confidence memories decay slower. Heavily-accessed memories also resist decay.
-      // Base exponent adapts to query mode: targeted (0.6) decays harder, exploratory (0.3) preserves older memories.
-      const confMod = 0.2 * Math.max(0, (engram.confidence - 0.5) / 0.5);
-      const replayMod = Math.min(0.1, 0.05 * Math.log1p(engram.accessCount));
-      const decayExponent = Math.max(0.2, adaptive.decayExponentBase - confMod - replayMod);
-      const decayScore = baseLevelActivation(engram.accessCount, ageDays, decayExponent);
-
-      // Hebbian boost from associations — capped to prevent popular memories
-      // from dominating regardless of query relevance
-      const rawHebbian = stats.count > 0 ? stats.sumWeight / stats.count : 0;
-      const hebbianBoost = Math.min(rawHebbian, 0.5);
-
-      // Centrality signal — well-connected memories (high weighted degree)
-      // get a small boost. This makes consolidation edges matter for retrieval.
-      // Log-scaled to prevent hub domination: 10 edges ≈ 0.05 boost, 50 ≈ 0.08
-      const centralityBoost = stats.count > 0
-        ? Math.min(0.1, 0.03 * Math.log1p(stats.sumWeight))
-        : 0;
-
-      // Confidence gate — multiplicative quality signal
-      const confidenceGate = engram.confidence;
-
-      // Feedback bonus — memories confirmed useful via explicit feedback get a
-      // direct additive boost. Models how a senior dev "just knows" certain things
-      // are important. Confidence > 0.6 means at least 2+ positive feedbacks.
-      // Scales: conf 0.6→0.03, 0.7→0.06, 0.8→0.09, 1.0→0.15
-      const feedbackBonus = engram.confidence > 0.55
-        ? Math.min(0.15, 0.3 * Math.max(0, engram.confidence - 0.5))
-        : 0;
-
-      // --- Composite score: relevance-gated additive ---
-      // Text/temporal weights adapt to query mode: targeted (0.75/0.25), exploratory (0.4/0.6).
-      const temporalNorm = Math.min(softplus(decayScore + hebbianBoost), 3.0) / 3.0;
-      const relevanceGate = textMatch > 0.1 ? textMatch : 0.0; // Proportional gate
-      const composite = (adaptive.textWeight * textMatch + adaptive.temporalWeight * temporalNorm * relevanceGate + centralityBoost * relevanceGate + feedbackBonus * relevanceGate) * confidenceGate;
-
-      const phaseScores: PhaseScores = {
-        textMatch,
-        vectorMatch,
-        decayScore,
-        hebbianBoost,
-        graphBoost: 0, // Filled in phase 5
-        confidenceGate,
-        composite,
-        rerankerScore: 0, // Filled in phase 7
-      };
-
-      // associations: empty in 0.7.12+ — graph walk lazy-fetches per engram on demand
-      return { engram, score: composite, phaseScores, associations: [] as Association[] };
-    });
-
-    // Phase 3.5: Rocchio pseudo-relevance feedback — expand query with top result terms
-    // then re-search BM25 to find candidates that keyword search missed
-    const preSorted = scored.sort((a, b) => b.score - a.score);
-    const topForFeedback = preSorted.slice(0, 3).filter(r => r.phaseScores.textMatch > 0.1);
-    if (topForFeedback.length > 0) {
-      const feedbackTerms = new Set<string>();
-      for (const item of topForFeedback) {
-        const tokens = tokenize(item.engram.content);
-        for (const t of tokens) {
-          if (!queryTokens.has(t) && t.length >= 4) feedbackTerms.add(t);
-        }
-      }
-      // Take top 5 feedback terms and re-search
-      const extraTerms = Array.from(feedbackTerms).slice(0, 5).join(' ');
-      if (extraTerms) {
-        const feedbackBM25 = await this.store.searchBM25WithRankMultiAgent(agentIds, `${searchContext} ${extraTerms}`, limit * 2);
-        for (const r of feedbackBM25) {
-          if (!candidateMap.has(r.engram.id)) {
-            candidateMap.set(r.engram.id, r.engram);
-            // Score the new candidate
-            const engram = r.engram;
-            const ageDays = (Date.now() - engram.createdAt.getTime()) / (1000 * 60 * 60 * 24);
-            const associations = await this.store.getAssociationsFor(engram.id);
-            const cTokens = tokenize(engram.concept);
-            const ctTokens = tokenize(engram.content);
-            const cJac = jaccard(queryTokens, cTokens);
-            const ctJac = jaccard(queryTokens, ctTokens);
-            const jSc = 0.6 * cJac + 0.4 * ctJac;
-            const cOvlp = cTokens.size > 0 ? [...cTokens].filter(w => queryTokens.has(w)).length / cTokens.size : 0;
-            const km = Math.min(Math.max(r.bm25Score, jSc) + cOvlp * 0.3, 1.0);
-            let vm = 0;
-            const rs = rawCosineSims.get(engram.id) ?? (queryEmbedding && engram.embedding ? cosineSimilarity(queryEmbedding, engram.embedding) : 0);
-            if (rs > 0) {
-              const SIM_FLOOR = adaptive.zScoreGate > 0.5
-        ? Number(process.env.AWM_SIM_FLOOR_TARGETED ?? 0.50)
-        : Number(process.env.AWM_SIM_FLOOR_EXPLORATORY ?? 0.35);
-              if (rs > SIM_FLOOR) vm = Math.min(1, (rs - SIM_FLOOR) / (0.95 - SIM_FLOOR));
-            }
-            const tm = km > 0 && vm > 0
-              ? 0.5 * Math.max(km, vm) + 0.3 * Math.min(km, vm) + 0.2 * (km * vm)
-              : Math.max(km, vm);
-            const ds = baseLevelActivation(engram.accessCount, ageDays);
-            const rh = associations.length > 0 ? Math.min(associations.reduce((s, a) => s + a.weight, 0) / associations.length, 0.5) : 0;
-            const tn = Math.min(softplus(ds + rh), 3.0) / 3.0;
-            const rg = tm > 0.1 ? tm : 0.0;
-            const comp = (adaptive.textWeight * tm + adaptive.temporalWeight * tn * rg) * engram.confidence;
-            scored.push({ engram, score: comp, phaseScores: { textMatch: tm, vectorMatch: vm, decayScore: ds, hebbianBoost: rh, graphBoost: 0, confidenceGate: engram.confidence, composite: comp, rerankerScore: 0 }, associations });
-          }
-        }
-      }
-    }
-
-    // Phase 3.7: Entity-Bridge boost — boost scored candidates that share entity tags
-    // with the most query-relevant result. The original intent: surface candidates
-    // that DON'T match the query text directly but share entities with the top
-    // text-match anchor ("she said something" → bridge to entities of the recent
-    // speaker named "she"). This is LATERAL relevance, not direct relevance.
-    //
-    // 2026-05-26: Added textMatch gate. Without it, when many engrams share entity
-    // tags AND have similar text matches (e.g., 10 near-clones of the same concept),
-    // the bridge boost would push the 8 non-anchor clones above the 2 anchors —
-    // an inversion of the genuine top match. The eval Retrieval suite caught this
-    // (Recall@5 0.80 → 0.46). Gate: only boost candidates whose textMatch is
-    // meaningfully below the anchor's. They actually need the lateral boost.
-    // Env override: AWM_DISABLE_ENTITY_BRIDGE=1 to skip this phase entirely.
-    if (!process.env.AWM_DISABLE_ENTITY_BRIDGE)
-    {
-      // Find the result with the highest textMatch (most query-relevant, not just highest score)
-      // Gate: only bridge when anchor has meaningful text relevance (> 0.15)
-      // Adaptive: scale bridge boost inversely with candidate pool size to prevent
-      // over-boosting in large memory pools where many items share entity tags
-      const sortedByTextMatch = scored
-        .filter(r => r.phaseScores.textMatch > 0.15)
-        .sort((a, b) => b.phaseScores.textMatch - a.phaseScores.textMatch);
-
-      // Bridge from top 2 text-matched results (IDF handles weighting)
-      const bridgeAnchors = sortedByTextMatch.slice(0, 2);
-
-      if (bridgeAnchors.length > 0) {
-        const entityTags = new Set<string>();
-        const anchorIds = new Set(bridgeAnchors.map(r => r.engram.id));
-
-        for (const item of bridgeAnchors) {
-          for (const tag of item.engram.tags) {
-            const t = tag.toLowerCase();
-            // Skip non-entity tags: turn IDs, session tags, dialogue IDs, generic speaker labels
-            if (/^t\d+$/.test(t) || t.startsWith('session-') || t.startsWith('dia_') || t.length < 3) continue;
-            if (/^speaker\d*$/.test(t)) continue; // Generic speaker labels are too broad
-            // Auto-tagger `cat:` category tags are too broad to bridge on (they'd link
-            // every "cat:work" memory laterally); they stay for BM25 recall only. The
-            // precise `entity:` proper-noun tags are kept as bridges.
-            if (t.startsWith('cat:')) continue;
-            entityTags.add(t);
-          }
-        }
-
-        // Document frequency filter: remove tags appearing in >30% of items (too common)
-        // This prevents speaker names in 2-person conversations from being used as bridges
-        if (entityTags.size > 0 && scored.length > 10) {
-          const tagFreqs = new Map<string, number>();
-          for (const item of scored) {
-            const seen = new Set<string>();
-            for (const tag of item.engram.tags) {
-              const t = tag.toLowerCase();
-              if (entityTags.has(t) && !seen.has(t)) {
-                seen.add(t);
-                tagFreqs.set(t, (tagFreqs.get(t) ?? 0) + 1);
-              }
-            }
-          }
-          const maxFreq = scored.length * 0.30;
-          for (const [tag, freq] of tagFreqs) {
-            if (freq > maxFreq) entityTags.delete(tag);
-          }
-        }
-
-        if (entityTags.size > 0) {
-          // Anchor's textMatch sets the scale. Bridge boost magnitude is
-          // proportional to the gap between anchor and candidate textMatch:
-          //   - candidate near anchor (a near-clone of the anchor) → small gap → near-zero boost
-          //   - candidate far below anchor (genuine lateral relevance) → large gap → full boost
-          // Without this scaling, dense same-concept corpora flip the genuine
-          // top-1 below its 8-9 near-clones (eval Recall@5 0.80 → 0.46 verified
-          // 2026-05-26). The scaling keeps the lateral-relevance behavior
-          // (which is what helps the AB test) without inverting the genuine
-          // text-match winner.
-          const anchorTextMax = bridgeAnchors[0].phaseScores.textMatch;
-
-          for (const item of scored) {
-            if (anchorIds.has(item.engram.id)) continue;
-
-            const engramTags = new Set(item.engram.tags.map((t: string) => t.toLowerCase()));
-            let sharedEntities = 0;
-            for (const et of entityTags) {
-              if (engramTags.has(et)) sharedEntities++;
-            }
-
-            if (sharedEntities > 0) {
-              // Gap scaling: 1.0 when candidateText << anchorText, 0 when equal.
-              // Clamped to [0, 1]. Anchors with textMatch ≤ 0 fall back to flat boost.
-              const gapScale = anchorTextMax > 0
-                ? Math.max(0, Math.min(1, (anchorTextMax - item.phaseScores.textMatch) / anchorTextMax))
-                : 1;
-              const bridgeBoost = Math.min(sharedEntities * 0.15, 0.4) * gapScale;
-              if (bridgeBoost > 0) {
-                item.score += bridgeBoost;
-                item.phaseScores.composite += bridgeBoost;
-                item.phaseScores.graphBoost += bridgeBoost;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // Phase 3.75: Query-conditioned entity bridge (default-OFF, AWM_QUERY_BRIDGE=1).
-    //
-    // The anchor-based bridge above (Phase 3.7) is query-BLIND: it bridges from the
-    // top text-match result's tags and a document-frequency filter DELETES common
-    // tags (e.g. a speaker present in >30% of turns). That is exactly backwards for
-    // attribution / entity-named queries: if the user asks "what does Caroline think
-    // about the trip" or "who said the trip moved to Saturday", the speaker/entity the
-    // query NAMES is the single most valuable bridge — its corpus frequency is
-    // irrelevant. This phase extracts proper-noun entities from the QUERY and boosts
-    // candidates whose tags match them, regardless of frequency, gated by topical
-    // relevance (textMatch floor) so it surfaces "Caroline's turns ABOUT the trip"
-    // rather than every Caroline turn. Boost folds into composite → survives rerank.
-    // Recall-only re-ranking of in-pool candidates (no injection) → low precision risk.
-    if (process.env.AWM_QUERY_BRIDGE === '1') {
-      const QSTOP = new Set(['what', 'who', 'when', 'where', 'why', 'how', 'which', 'whose', 'whom',
-        'the', 'this', 'that', 'these', 'those', 'and', 'but', 'for', 'did', 'does', 'is', 'are',
-        'was', 'were', 'how', 'tell', 'about', 'they', 'them']);
-      const qEnts = new Set<string>();
-      for (const m of query.context.matchAll(/\b[A-Z][a-zA-Z]{2,}\b/g)) {
-        const w = m[0].toLowerCase();
-        if (!QSTOP.has(w)) qEnts.add(w);
-      }
-      if (qEnts.size > 0) {
-        const QC_WEIGHT = Number(process.env.AWM_QUERY_BRIDGE_WEIGHT ?? 0.4);
-        const QC_CAP = Number(process.env.AWM_QUERY_BRIDGE_CAP ?? 0.4);
-        const QC_FLOOR = Number(process.env.AWM_QUERY_BRIDGE_FLOOR ?? 0.1);
-        for (const item of scored) {
-          if (item.phaseScores.textMatch < QC_FLOOR) continue; // only re-rank topically-relevant candidates
-          let matches = 0;
-          for (const tag of item.engram.tags) {
-            const t = tag.toLowerCase();
-            const val = t.startsWith('entity:') ? t.slice(7) : t;
-            // match whole-tag or any word of a multi-word entity ("marcus lee" ← "Marcus")
-            if (qEnts.has(val) || val.split(/\s+/).some(w => qEnts.has(w))) { matches++; }
-          }
-          if (matches > 0) {
-            // Relevance-modulated: scale by the candidate's topical relevance so
-            // "named-entity AND on-topic" wins big while "named-entity but off-topic
-            // chatter" (a common speaker tag on an irrelevant turn) gets almost
-            // nothing. Without this, a broad speaker tag floods the top with the
-            // person's unrelated turns (verified 2026-06-16 _query-bridge-verify).
-            const boost = Math.min(matches * QC_WEIGHT * item.phaseScores.textMatch, QC_CAP);
-            item.score += boost;
-            item.phaseScores.composite += boost;
-            item.phaseScores.graphBoost += boost;
-          }
-        }
-      }
-    }
-
-    // Phase 4+5: Graph walk — boost engrams connected to high-scoring ones
-    // Only walk from engrams that had text relevance (composite > 0 pre-walk)
-    const sorted = scored.sort((a, b) => b.score - a.score);
-    // Candidate breadth carried into graph-walk + rerank. Default 8×limit (was 3×).
-    // WHY 8× (2026-06-16): the pipeline-attribution trace showed ~50% of answerable LoCoMo
-    // queries had gold that CLEARED the floor (89%) but was squeezed out HERE by the
-    // decay-compressed composite before the (high-lift, +3.29) reranker saw it — the
-    // dominant loss. Widening this + the rerank pool (below) lifted official LoCoMo
-    // 22.7→25.1 (every recall category up), 4-suite unchanged, recall 35→77ms; small
-    // adversarial cost 73.4→71.0 (a fixed step, recoverable on the abstention gate).
-    // Tunable via AWM_TOPN_MULT.
-    const topNMult = Number(process.env.AWM_TOPN_MULT ?? 8);
-    const topN = sorted.slice(0, limit * topNMult);
-    if (process.env.AWM_SPREAD === '1' && query.spread !== false) {
-      await this.spreadActivation(topN);
-    } else {
-      await this.graphWalk(topN, 2, adaptive.hopPenalty, adaptive.beamWidth);
-    }
-
-    // Phase 6: Initial filter and sort for re-ranking pool
-    const pool = topN
-      .filter(r => r.score >= minScore)
-      .sort((a, b) => b.score - a.score);
-
-    // Phase 7: Cross-encoder re-ranking — scores (query, passage) pairs directly
-    // Widens the pool to find relevant results that keyword matching missed.
-    // How many candidates reach the cross-encoder. Default max(limit*4, 40) — widened
-    // from max(limit*2, 15) on 2026-06-16. WHY: the reranker rarely loses gold (0.5%) and
-    // lifts it +3.29, but the weak composite was only passing it ~35% of retrievable gold;
-    // feeding it more recovered the dominant lost@pool/scoring bucket. Validated knee on
-    // recall × precision × latency (pool 40 ≈ 25.1% LoCoMo / 71.0% adv / 77ms; pool 60 adds
-    // only +0.6pp for +33ms). The composite is now a CHEAP WIDE PRE-FILTER, not the ranker —
-    // the reranker does discrimination on a wide pool. Tunable via AWM_RERANK_POOL.
-    const rerankPoolSize = Number(process.env.AWM_RERANK_POOL ?? Math.max(limit * 4, 40));
-    const rerankPool = pool.slice(0, rerankPoolSize);
-
-    // Reranker skip heuristic (0.7.10+): if BM25 already has a clear winner with
-    // strong absolute score AND a meaningful gap to the runner-up, the cross-encoder
-    // is unlikely to change the top result. Skipping saves ~300ms of wall-clock per
-    // recall on simple queries (40% of post-0.7.9 floor was reranker).
-    //
-    // Conservative gate (only skip when very confident):
-    //   - top-1 textMatch >= 0.8 (high BM25 + jaccard agreement)
-    //   - top-1 score is at least 1.5× top-2 score (clear separation)
-    //   - rerankPool size <= limit*2 (small pool — reranker has less to do)
-    //
-    // Ambiguous queries (close BM25 scores, weak top-1, large pool) still go through
-    // the reranker. Disable this heuristic via AWM_DISABLE_RERANK_SKIP=1.
-    let rerankSkipped = false;
-    if (useReranker && rerankPool.length >= 2 && process.env.AWM_DISABLE_RERANK_SKIP !== '1') {
-      const top1 = rerankPool[0];
-      const top2 = rerankPool[1];
-      const t1Text = top1.phaseScores.textMatch;
-      const t1Score = top1.score;
-      const t2Score = top2.score;
-      const cleanWinner = t1Text >= 0.8 && t1Score >= 1.5 * Math.max(t2Score, 0.01);
-      const smallPool = rerankPool.length <= Math.max(limit * 2, 20);
-      if (cleanWinner && smallPool) {
-        rerankSkipped = true;
-      }
-    }
-
-    if (useReranker && !rerankSkipped && rerankPool.length > 0) {
-      try {
-        // Truncate content to ~400 chars before rerank (0.7.14+). Cross-encoders
-        // have a 512-token max anyway and pad to the longest passage in the batch;
-        // sending full content (some 5000+ chars) means everything pads to ~512
-        // tokens. Truncation drops tokenization + inference cost ~3-4× on long
-        // memory pools without losing rerank signal — the concept + first 400
-        // chars carry the core meaning.
-        const passages = rerankPool.map(r => {
-          const concept = r.engram.concept;
-          const content = r.engram.content.length > 400
-            ? r.engram.content.slice(0, 400)
-            : r.engram.content;
-          return `${concept}: ${content}`;
-        });
-        let rerankTimer: ReturnType<typeof setTimeout> | undefined;
-        const rerankResults = await Promise.race([
-          rerank(query.context, passages),
-          new Promise<never>((_, reject) => { rerankTimer = setTimeout(() => reject(new Error('reranker timeout')), 10000); }),
-        ]).finally(() => { if (rerankTimer) clearTimeout(rerankTimer); });
-
-        // Adaptive reranker blend (Codex recommendation):
-        // When BM25/text signals are strong, trust them more; when weak, lean on reranker.
-        const bm25Max = Math.max(...rerankPool.map(r => r.phaseScores.textMatch));
-        const rerankWeight = Math.min(0.7, Math.max(0.3, 0.3 + 0.4 * (1 - bm25Max)));
-        const compositeWeight = 1 - rerankWeight;
-
-        for (const rr of rerankResults) {
-          const item = rerankPool[rr.index];
-          item.phaseScores.rerankerScore = rr.score;
-          item.score = compositeWeight * item.phaseScores.composite + rerankWeight * rr.score;
-        }
-      } catch {
-        // Re-ranker unavailable — keep original scores
-      }
-    }
-
-    // Phase 8: Multi-channel OOD detection + agreement gate
-    // Requires at least 2 of 3 retrieval channels to agree the query is in-domain.
-    if (rerankPool.length >= 3) {
-      // Abstention gate scope (2026-06-16): the in-domain channel maxes used to be taken
-      // over the ENTIRE rerankPool. Once that pool was widened for recall (pool 40), a lone
-      // high-scoring distractor inflated the maxes and defeated abstention on adversarial
-      // queries (adversarial 73.4→71.0). Fix: judge in-domain on the post-rerank TOP-K —
-      // the items we'd actually return — so pool width (recall) is decoupled from the
-      // abstention decision (precision). AWM_ABSTAIN_GATE_K controls K (0 = legacy
-      // whole-pool behavior). Answerable queries are unaffected: the gold is in the top-K
-      // and supplies the in-domain signal; only borderline distractors deep in a wide pool
-      // stop counting.
-      // Default 5 (2026-06-16): judge in-domain on the post-rerank top-5. With the widened
-      // rerank pool, basing it on the whole pool (legacy AWM_ABSTAIN_GATE_K=0) let a lone
-      // deep distractor defeat abstention; top-5 restored adversarial 71.0→74.9 (ABOVE the
-      // pre-widening 73.4) at ZERO recall cost (answerable categories unchanged) — the
-      // precision half of the two-dial pool-widening win.
-      const gateK = Number(process.env.AWM_ABSTAIN_GATE_K ?? 5);
-      const gatePool = gateK > 0
-        ? [...rerankPool].sort((a, b) => b.score - a.score).slice(0, gateK)
-        : rerankPool;
-
-      const topBM25 = Math.max(...gatePool.map(r => bm25ScoreMap.get(r.engram.id) ?? 0));
-      const topVector = queryEmbedding
-        ? Math.max(...gatePool.map(r => r.phaseScores.vectorMatch))
-        : 0;
-      const topReranker = Math.max(...gatePool.map(r => r.phaseScores.rerankerScore));
-
-      const bm25Ok = topBM25 > 0.3;
-      const vectorOk = topVector > 0.05;
-      const rerankerOk = topReranker > 0.25;
-      const channelsAgreeing = (bm25Ok ? 1 : 0) + (vectorOk ? 1 : 0) + (rerankerOk ? 1 : 0);
-
-      const rerankerScores = gatePool
-        .map(r => r.phaseScores.rerankerScore)
-        .sort((a, b) => b - a);
-      const margin = rerankerScores.length >= 2
-        ? rerankerScores[0] - rerankerScores[1]
-        : rerankerScores[0];
-
-      const cosineSimValues = Array.from(rawCosineSims.values());
-      const maxRawCosine = queryEmbedding && cosineSimValues.length > 0
-        ? Math.max(...cosineSimValues)
-        : 1.0;
-
-      // Required-channels for hard abstention:
-      //   abstention-explicit (caller passed abstentionThreshold > 0): 3 of 3
-      //   default: 2 of 3 — precision-first
-      const requiredChannels = abstentionThreshold > 0 ? 3 : 2;
-
-      // Hard abstention: fewer than required channels agree AND semantic match weak.
-      // After the 2.0.x vector refactor we no longer compute z-score; threshold
-      // on raw cosine against the mode floor (targeted=0.50, exploratory=0.35).
-      const semanticFloor = adaptive.zScoreGate > 0.5 ? 0.50 : 0.35;
-      if (channelsAgreeing < requiredChannels && maxRawCosine < semanticFloor) {
-        return [];
-      }
-
-      // Soft penalty: only 1 channel agrees or margin is thin
-      if (channelsAgreeing < 2 || margin < 0.05) {
-        if (abstentionThreshold > 0) {
-          return [];
-        }
-        for (const item of rerankPool) {
-          item.score *= 0.4;
-        }
-      }
-    }
-
-    // Legacy abstention gate (when explicitly requested)
-    if (abstentionThreshold > 0 && rerankPool.length >= 3) {
-      const topRerankerScores = rerankPool
-        .map(r => r.phaseScores.rerankerScore)
-        .sort((a, b) => b - a)
-        .slice(0, 5);
-      const maxScore = topRerankerScores[0];
-      const meanScore = topRerankerScores.reduce((s, v) => s + v, 0) / topRerankerScores.length;
-      const variance = topRerankerScores.reduce((s, v) => s + (v - meanScore) ** 2, 0) / topRerankerScores.length;
-
-      if (maxScore < abstentionThreshold || (maxScore < 0.5 && variance < 0.01)) {
-        return [];
-      }
-    }
-
-    // Phase 8c: Supersession penalty — superseded memories are deprioritized.
-    // They aren't wrong (that's retraction), just outdated.
-    for (const item of rerankPool) {
-      if (item.engram.supersededBy) {
-        item.score *= 0.15; // Severe down-rank — successor should dominate
-      }
-    }
-
-    // Phase 9: Final sort, limit, explain, attach confidence
-    const finalRanked = rerankPool.sort((a, b) => b.score - a.score);
-    const topScoresForConfidence = finalRanked.slice(0, 10).map(r => r.score);
-    const { confidence } = computeRecallConfidence(topScoresForConfidence);
-
-    // Opt-in confidence-based abstention. When the caller sets
-    // `requireConfidence`, we return [] if the score-distribution shape
-    // indicates a low-quality recall (noisy or best-of-bad-bunch).
-    // Independent of the channel-agreement abstention earlier — that path
-    // requires the reranker; this one uses just the final composite scores.
-    if (requireConfidence > 0 && confidence < requireConfidence) {
-      return [];
-    }
-
-    // Confidence-adaptive output granularity (Paper 3: cognitive teaming).
-    // 'full'    → no summary (default, current behavior).
-    // 'compact' → every result gets a short summary (COMPACT_LEN chars).
-    // 'auto'    → if confidence ≥ AUTO_THRESHOLD: top result gets a full-length
-    //             summary, lower-ranked results get compact summaries. If
-    //             confidence is lower, all results get compact summaries.
-    const granularity = query.granularity ?? 'full';
-    const COMPACT_LEN = Number(process.env.AWM_GRANULARITY_COMPACT_LEN ?? 200);
-    const FULL_LEN = Number(process.env.AWM_GRANULARITY_FULL_LEN ?? 1000);
-    const AUTO_THRESHOLD = Number(process.env.AWM_GRANULARITY_AUTO_THRESHOLD ?? 0.4);
-
-    // Snippet token list — reuse the activation queryTokens (Set<string>),
-    // filtered to ≥2 chars to drop noise. queryTokens was tokenized at line
-    // 273 via tokenize() with stopword stripping already applied.
-    const snippetTokens = Array.from(queryTokens).filter(t => t.length >= 2);
-
-    // Find the densest window of `len` chars in `content` that contains the
-    // most query-token matches. Falls back to head if no tokens match.
-    const summaryFor = (content: string, len: number): string => {
-      if (content.length <= len) return content;
-      if (snippetTokens.length === 0) return content.slice(0, len).trimEnd() + '…';
-
-      const lower = content.toLowerCase();
-      const hits: number[] = [];
-      for (const tok of snippetTokens) {
-        let from = 0;
-        while (true) {
-          const idx = lower.indexOf(tok, from);
-          if (idx < 0) break;
-          hits.push(idx);
-          from = idx + tok.length;
-        }
-      }
-      if (hits.length === 0) return content.slice(0, len).trimEnd() + '…';
-      hits.sort((a, b) => a - b);
-
-      // Find the window of size `len` that contains the most hits, by
-      // sliding a window anchored on each hit.
-      let bestStart = hits[0];
-      let bestCount = 0;
-      for (let i = 0; i < hits.length; i++) {
-        const start = Math.max(0, hits[i] - Math.floor(len / 4));
-        let count = 0;
-        for (let j = i; j < hits.length; j++) {
-          if (hits[j] - start < len) count++;
-          else break;
-        }
-        if (count > bestCount) {
-          bestCount = count;
-          bestStart = start;
-        }
-      }
-
-      // Reserve characters for the ellipses we're about to add so the final
-      // string stays within `len`. Without this, both '…' prefix + suffix
-      // would push the snippet to len+2 chars.
-      const hasPrefix = bestStart > 0;
-      const tentativeEnd = Math.min(content.length, bestStart + len);
-      const hasSuffix = tentativeEnd < content.length;
-      const reserveForEllipses = (hasPrefix ? 1 : 0) + (hasSuffix ? 1 : 0);
-      const bodyLen = Math.max(0, len - reserveForEllipses);
-      const end = Math.min(content.length, bestStart + bodyLen);
-      const startAdj = Math.max(0, end - bodyLen);
-      let snippet = content.slice(startAdj, end);
-      if (startAdj > 0) snippet = '…' + snippet.trimStart();
-      if (end < content.length) snippet = snippet.trimEnd() + '…';
-      return snippet;
-    };
-
-    const results: ActivationResult[] = finalRanked
-      .slice(0, limit)
-      .map((r, idx) => {
-        let summary: string | undefined;
-        if (granularity === 'compact') {
-          summary = summaryFor(r.engram.content, COMPACT_LEN);
-        } else if (granularity === 'auto') {
-          if (confidence >= AUTO_THRESHOLD && idx === 0) {
-            summary = summaryFor(r.engram.content, FULL_LEN);
-          } else {
-            summary = summaryFor(r.engram.content, COMPACT_LEN);
-          }
-        }
-        return {
-          engram: r.engram,
-          score: r.score,
-          phaseScores: r.phaseScores,
-          why: this.explain(r.phaseScores, r.engram, r.associations),
-          associations: r.associations,
-          confidence,
-          ...(summary !== undefined && { summary }),
-        };
-      });
-
-    const activatedIds = results.map(r => r.engram.id);
-
-    // Side effects: touch, co-activate, defer Hebbian to validation gate (skip for internal/system calls)
-    if (!query.internal) {
-      for (const id of activatedIds) {
-        await this.store.touchEngram(id);
-      }
-      this.coActivationBuffer.pushBatch(activatedIds);
-      // Validation-gated Hebbian: defer strengthening until feedback arrives
-      const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
-      const seen = new Set<string>();
-      const uniquePairs: [string, string][] = [];
-      for (const [a, b] of pairs) {
-        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
-        if (!seen.has(key)) { seen.add(key); uniquePairs.push([a, b]); }
-      }
-      this.validationGate.addPending(activatedIds, uniquePairs);
-
-      // Log activation event for eval
-      const latencyMs = performance.now() - startTime;
-      await this.store.logActivationEvent({
-        id: randomUUID(),
-        agentId: query.agentId,
-        timestamp: new Date(),
-        context: query.context,
-        resultsReturned: results.length,
-        topScore: results.length > 0 ? results[0].score : 0,
-        latencyMs,
-        engramIds: activatedIds,
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Multi-graph traversal (MAGMA-inspired).
-   *
-   * Instead of one beam search over all edge types, runs independent traversals
-   * per graph type with specialized scoring, then fuses the boosts.
-   *
-   * Four sub-graphs:
-   * - Semantic (connection + hebbian edges) → standard weight-based walk
-   * - Temporal (temporal edges) → recency-weighted (favor recent connections)
-   * - Causal (causal edges) → full weight walk (causal links are high-value)
-   * - Entity (bridge edges) → entity-tag-weighted walk
-   *
-   * Each sub-graph contributes independently to the final graph boost,
-   * weighted by configurable per-graph weights.
-   */
-  private static readonly GRAPH_WEIGHTS = {
-    semantic: 0.40,   // connection + hebbian
-    temporal: 0.20,   // temporal edges
-    causal: 0.25,     // causal edges (high-value signal)
-    entity: 0.15,     // bridge edges
-  };
-
-  private async graphWalk(
-    scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
-    maxDepth: number,
-    hopPenalty: number,
-    beamWidth: number = 15
-  ): Promise<void> {
-    const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
-    const MAX_TOTAL_BOOST = 0.25;
-
-    // Define which edge types belong to each sub-graph
-    const graphTypes: Record<string, string[]> = {
-      semantic: ['connection', 'hebbian'],
-      temporal: ['temporal'],
-      causal: ['causal'],
-      entity: ['bridge'],
-    };
-
-    // Run independent traversals per sub-graph, accumulate boosts
-    const boostAccum = new Map<string, number>(); // engramId → total boost
-
-    for (const [graphName, edgeTypes] of Object.entries(graphTypes)) {
-      const graphWeight = ActivationEngine.GRAPH_WEIGHTS[graphName as keyof typeof ActivationEngine.GRAPH_WEIGHTS];
-      const subBeamWidth = Math.max(3, Math.ceil(beamWidth * graphWeight));
-
-      // Seed beam
-      const beam = scored
-        .filter(item => item.phaseScores.textMatch >= 0.15)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, subBeamWidth);
-
-      const explored = new Set<string>();
-
-      for (let depth = 0; depth < maxDepth; depth++) {
-        const nextBeam: typeof beam = [];
-
-        for (const item of beam) {
-          if (explored.has(item.engram.id)) continue;
-          explored.add(item.engram.id);
-
-          const associations = item.associations.length > 0
-            ? item.associations
-            : await this.store.getAssociationsFor(item.engram.id);
-
-          // Filter to only edges of this sub-graph type
-          const relevantEdges = associations.filter(a => edgeTypes.includes(a.type));
-
-          for (const assoc of relevantEdges) {
-            const neighborId = assoc.fromEngramId === item.engram.id
-              ? assoc.toEngramId
-              : assoc.fromEngramId;
-
-            if (explored.has(neighborId)) continue;
-            const neighbor = scoreMap.get(neighborId);
-            if (!neighbor) continue;
-
-            const relevanceFloor = depth === 0 ? 0.1 : 0.05;
-            if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
-
-            // Path score with graph-type-specific weighting
-            const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
-            let pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
-
-            // Causal edges get a 2x boost — they represent verified reasoning chains
-            if (graphName === 'causal') pathScore *= 2.0;
-
-            // Weight by sub-graph importance
-            const boost = Math.min(pathScore * graphWeight, 0.15);
-            if (boost > 0.001) {
-              boostAccum.set(neighborId, (boostAccum.get(neighborId) ?? 0) + boost);
-              nextBeam.push(neighbor);
-            }
-          }
-        }
-
-        if (nextBeam.length === 0) break;
-        beam.length = 0;
-        beam.push(...nextBeam
-          .sort((a, b) => b.score - a.score)
-          .slice(0, subBeamWidth)
-        );
-      }
-    }
-
-    // Apply fused boosts to scored items
-    for (const [engramId, totalBoost] of boostAccum) {
-      const item = scoreMap.get(engramId);
-      if (!item) continue;
-      const capped = Math.min(totalBoost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
-      if (capped > 0.001) {
-        item.score += capped;
-        item.phaseScores.graphBoost += capped;
-      }
-    }
-  }
-
-  /**
-   * R2 — bounded iterative spreading activation (PPR / SYNAPSE-style).
-   *
-   * Default-OFF (`AWM_SPREAD=1`). The principled, in-AWM successor to the
-   * fixed depth-2 beam `graphWalk` and the MWA harness bridge: it runs T
-   * iterations of **fan-normalized** spreading with **lateral inhibition** and
-   * a **restart** term (Personalized PageRank) over the association graph —
-   * richest when R1's `AWM_BROAD_EDGES` entity edges are present.
-   *
-   * Two effects, both precision-guarded:
-   *  - **Boost** existing pool candidates by the *graph evidence* they receive
-   *    (convergent multi-path activation, not a single spurious hop).
-   *  - **Inject** (`AWM_SPREAD_INJECT=1`) strongly-reached *out-of-pool*
-   *    engrams as recall-only candidates so the reranker can see true
-   *    multi-hop bridges that BM25/vector missed. Their composite carries the
-   *    graph-activation signal (blended with rerank), which is what lets a
-   *    vocab-mismatched bridge surface where the prior `AWM_ENTITY_FETCH`
-   *    recall-only injection (rerank-only) could not.
-   *
-   * Precision is preserved because spreading is **seeded by the initial
-   * retrieval**: adversarial "is this even in memory?" queries have weak/empty
-   * seeds, so nothing meaningful propagates and abstention is unaffected.
-   * Fan-normalization stops hubs from flooding; lateral inhibition keeps only
-   * the top-M activated nodes per step; a node budget bounds cost; injected
-   * candidates stay rerank-gated and the pool-level OOD agreement gate is
-   * unaffected (seeds still supply the BM25/vector channels).
-   */
-  private async spreadActivation(
-    topN: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
-  ): Promise<void> {
-    const T = Number(process.env.AWM_SPREAD_ITERS ?? 3);
-    const delta = Number(process.env.AWM_SPREAD_DAMPING ?? 0.5);
-    const NODE_BUDGET = Number(process.env.AWM_SPREAD_BUDGET ?? 64);
-    const BOOST_SCALE = Number(process.env.AWM_SPREAD_BOOST ?? 0.4);
-    const PER_NODE_CAP = 0.15;
-    const MAX_TOTAL_BOOST = 0.25;
-    const inject = process.env.AWM_SPREAD_INJECT === '1';
-    const INJECT_THRESHOLD = Number(process.env.AWM_SPREAD_INJECT_MIN ?? 0.08);
-    const INJECT_BUDGET = Number(process.env.AWM_SPREAD_INJECT_CAP ?? 8);
-    const INJECT_SCALE = Number(process.env.AWM_SPREAD_INJECT_SCALE ?? 1.0);
-    const EPS = 0.01;
-    // 'invalidation' edges link superseded→replacement; excluded so spreading
-    // never pulls stale facts back in.
-    const allowed = new Set(['connection', 'hebbian', 'temporal', 'causal', 'bridge']);
-
-    const scoreMap = new Map(topN.map(s => [s.engram.id, s]));
-
-    // Seed activation from query-relevant candidates (textMatch gate), normalized to [0,1].
-    const seed = new Map<string, number>();
-    let maxSeed = 0;
-    for (const item of topN) {
-      if (item.phaseScores.textMatch >= 0.15) {
-        const v = Math.max(0, item.score);
-        seed.set(item.engram.id, v);
-        if (v > maxSeed) maxSeed = v;
-      }
-    }
-    if (seed.size === 0 || maxSeed <= 0) return;
-    for (const [k, v] of seed) seed.set(k, v / maxSeed);
-
-    const edgeCache = new Map<string, Association[]>();
-    const getEdges = async (id: string): Promise<Association[]> => {
-      let e = edgeCache.get(id);
-      if (!e) {
-        e = (await this.store.getAssociationsFor(id)).filter(a => allowed.has(a.type));
-        edgeCache.set(id, e);
-      }
-      return e;
-    };
-
-    let act = new Map(seed);
-    // Cumulative inflow received from the graph (excludes a node's own seed) —
-    // this is the multi-hop "evidence" signal used for boost + injection.
-    const graphActivation = new Map<string, number>();
-
-    for (let t = 0; t < T; t++) {
-      const inflow = new Map<string, number>();
-      for (const [u, au] of act) {
-        if (au <= EPS) continue;
-        const edges = await getEdges(u);
-        if (edges.length === 0) continue;
-        let fan = 0;
-        for (const e of edges) fan += Math.max(0, e.weight);
-        if (fan <= 0) continue;
-        for (const e of edges) {
-          const v = e.fromEngramId === u ? e.toEngramId : e.fromEngramId;
-          const share = Math.max(0, e.weight) / fan; // fan-effect normalization
-          inflow.set(v, (inflow.get(v) ?? 0) + au * share);
-        }
-      }
-      for (const [v, f] of inflow) graphActivation.set(v, (graphActivation.get(v) ?? 0) + f);
-
-      // Restart (PPR): blend propagated inflow with the original seed vector.
-      const newAct = new Map<string, number>();
-      const keys = new Set<string>([...act.keys(), ...inflow.keys()]);
-      for (const v of keys) {
-        const val = (1 - delta) * (seed.get(v) ?? 0) + delta * (inflow.get(v) ?? 0);
-        if (val > EPS) newAct.set(v, val);
-      }
-      // Lateral inhibition: keep only the top-M activated nodes (competition + cost bound).
-      if (newAct.size > NODE_BUDGET) {
-        act = new Map([...newAct.entries()].sort((a, b) => b[1] - a[1]).slice(0, NODE_BUDGET));
-      } else {
-        act = newAct;
-      }
-    }
-
-    // Normalize graph evidence to [0,1] so the boost magnitude is scale-stable
-    // (raw `ga` accumulates across iterations + bidirectional edges, so its
-    // absolute scale varies with graph density). The top-reached node maps to 1.0.
-    let maxGa = 0;
-    for (const ga of graphActivation.values()) if (ga > maxGa) maxGa = ga;
-    const normGa = (id: string): number => (maxGa > 0 ? (graphActivation.get(id) ?? 0) / maxGa : 0);
-
-    if (process.env.AWM_SPREAD_DEBUG === '1') {
-      const top = [...graphActivation.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
-      process.stderr.write(`[spread] seeds=${seed.size} reached=${graphActivation.size} inPool=${[...graphActivation.keys()].filter(id => scoreMap.has(id)).length} maxGa=${maxGa.toFixed(3)}\n`);
-      for (const [id, ga] of top) {
-        const e = scoreMap.get(id)?.engram;
-        process.stderr.write(`[spread]   ga=${ga.toFixed(3)} norm=${normGa(id).toFixed(2)} pool=${scoreMap.has(id)} ${e ? e.concept.slice(0, 40) : '(out-of-pool ' + id.slice(0, 8) + ')'}\n`);
-      }
-    }
-
-    // Boost existing candidates by the (normalized) graph evidence they received.
-    // Folded into `composite` (NOT just `score`) so it survives the rerank blend
-    // — the reranker recomputes score from composite, so a score-only boost would
-    // be discarded. This makes spreading a first-class multi-hop ranking signal.
-    for (const [id] of graphActivation) {
-      const item = scoreMap.get(id);
-      if (!item) continue;
-      const boost = Math.min(normGa(id) * BOOST_SCALE, PER_NODE_CAP);
-      const capped = Math.min(boost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
-      if (capped > 0.001) {
-        item.phaseScores.composite += capped;
-        item.score += capped;
-        item.phaseScores.graphBoost += capped;
-      }
-    }
-
-    // Inject strongly-reached out-of-pool engrams as recall-only candidates.
-    if (inject) {
-      const reached = [...graphActivation.entries()]
-        .filter(([id]) => !scoreMap.has(id) && normGa(id) >= INJECT_THRESHOLD)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, INJECT_BUDGET);
-      for (const [id] of reached) {
-        const engram = await this.store.getEngram(id);
-        if (!engram || engram.stage !== 'active') continue;
-        if ((engram as unknown as { retracted?: boolean }).retracted || engram.supersededBy) continue;
-        const composite = Math.min(0.6, normGa(id) * INJECT_SCALE);
-        const phaseScores: PhaseScores = {
-          textMatch: 0,
-          vectorMatch: 0,
-          decayScore: 0,
-          hebbianBoost: 0,
-          graphBoost: composite,
-          confidenceGate: engram.confidence,
-          composite,
-          rerankerScore: 0,
-        };
-        const injected = { engram, score: composite, phaseScores, associations: [] as Association[] };
-        topN.push(injected);
-        scoreMap.set(id, injected);
-      }
-    }
-  }
-
-  /**
-   * Resolve validation-gated Hebbian update for a specific engram.
-   * Called by memory_feedback — only strengthens when retrieval was useful.
-   * This prevents hub toxicity from noisy co-retrieval (Kairos-inspired).
-   */
-  async resolveHebbianFeedback(engramId: string, useful: boolean): Promise<number> {
-    const { pairs, signal } = this.validationGate.resolveFeedback(engramId, useful);
-    let updated = 0;
-
-    for (const [a, b] of pairs) {
-      const existing = (await this.store.getAssociation(a, b)) ?? (await this.store.getAssociation(b, a));
-      const currentWeight = existing?.weight ?? 0.1;
-
-      if (signal > 0) {
-        // Positive feedback → strengthen
-        const newWeight = strengthenAssociation(currentWeight, signal);
-        await this.store.upsertAssociation(a, b, newWeight, 'hebbian');
-        await this.store.upsertAssociation(b, a, newWeight, 'hebbian');
-      } else {
-        // Negative feedback → slight weakening (decay by signal magnitude)
-        const newWeight = Math.max(0.001, currentWeight * (1 + signal)); // signal is -0.3
-        await this.store.upsertAssociation(a, b, newWeight, 'hebbian');
-        await this.store.upsertAssociation(b, a, newWeight, 'hebbian');
-      }
-      updated++;
-    }
-    return updated;
-  }
-
-  private explain(phases: PhaseScores, engram: Engram, associations: Association[]): string {
-    const parts: string[] = [];
-    parts.push(`composite=${phases.composite.toFixed(3)}`);
-    if (phases.textMatch > 0) parts.push(`text=${phases.textMatch.toFixed(2)}`);
-    if (phases.vectorMatch > 0) parts.push(`vector=${phases.vectorMatch.toFixed(2)}`);
-    parts.push(`decay=${phases.decayScore.toFixed(2)}`);
-    if (phases.hebbianBoost > 0) parts.push(`hebbian=${phases.hebbianBoost.toFixed(2)}`);
-    if (phases.graphBoost > 0) parts.push(`graph=${phases.graphBoost.toFixed(2)}`);
-    if (phases.rerankerScore > 0) parts.push(`reranker=${phases.rerankerScore.toFixed(2)}`);
-    parts.push(`conf=${phases.confidenceGate.toFixed(2)}`);
-    parts.push(`access=${engram.accessCount}`);
-    if (associations.length > 0) parts.push(`edges=${associations.length}`);
-    return parts.join(' | ');
-  }
-}
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Activation Pipeline — the core retrieval engine.
+ *
+ * Cognitive retrieval pipeline — phases as shipped (D4 honesty pass 2026-07-30;
+ * default-OFF phases are marked, since operators tune from this header):
+ *   -1. Coreference expansion (conditional: query contains pronouns)
+ *   0. Query expansion (flan-t5-small; caller-gated, MCP default ON)
+ *   1. Vector embedding (bge-small 384d)
+ *   2. Parallel retrieval (dual FTS5/BM25 + native vector top-K)
+ *   3. Per-candidate scoring (BM25, Jaccard, cosine floor, ACT-R decay,
+ *      Hebbian boost, confidence gate — computed together in phase 3b)
+ *   3.5 Rocchio pseudo-relevance feedback (conditional on BM25 signal)
+ *   3.7 Entity-bridge boost (default ON; AWM_DISABLE_ENTITY_BRIDGE=1)
+ *   3.5  Entity-index candidate injection (DEFAULT OFF; AWM_ENTITY_INDEX_FETCH=1 —
+ *        D11 2026-07-30: D9 inverted-index lookup of query-named entities; injected
+ *        candidates get no boost but a guaranteed rerank audition)
+ *   3.75 Query-conditioned entity bridge (DEFAULT OFF; AWM_QUERY_BRIDGE=1)
+ *   4/5 Spreading-activation graph walk (DEFAULT OFF; AWM_SPREAD=1 — parked
+ *       after displacing-gold regressions; see design-proposals D11)
+ *   6. Filter + sort into rerank pool (wide pool since 0.9.0)
+ *   7. Cross-encoder rerank (ms-marco; clear-winner skip unless
+ *      AWM_DISABLE_RERANK_SKIP=1)
+ *   8. Multi-channel OOD detection + agreement gate; supersession penalty;
+ *      abstention enforced only when caller passes require_confidence
+ *   9. Final sort, granularity, confidence attach
+ *
+ * Logs activation events for eval metrics.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { baseLevelActivation, softplus } from '../core/decay.js';
+import { strengthenAssociation, CoActivationBuffer, ValidationGatedBuffer } from '../core/hebbian.js';
+import { embed, cosineSimilarity } from '../core/embeddings.js';
+import { rerank } from '../core/reranker.js';
+import { expandQuery } from '../core/query-expander.js';
+import { computeRecallConfidence } from './confidence.js';
+import type {
+  Engram, ActivationResult, ActivationQuery, Association, PhaseScores, QueryMode,
+} from '../types/index.js';
+import type { IEngramStore as EngramStore } from '../storage/store.js';
+
+// ─── Query-adaptive pipeline parameters ───────────────────────────
+
+interface AdaptiveParams {
+  mode: 'targeted' | 'exploratory' | 'balanced';
+  textWeight: number;       // Weight for text match in composite (default 0.6)
+  temporalWeight: number;   // Weight for temporal signals (default 0.4)
+  decayExponentBase: number;// Base ACT-R decay exponent (default 0.5)
+  zScoreGate: number;       // Z-score threshold for vector match (default 0.5)
+  beamWidth: number;        // Graph walk beam width (default 15)
+  hopPenalty: number;       // Graph walk hop penalty (default 0.3)
+}
+
+const ADAPTIVE_PRESETS: Record<'targeted' | 'exploratory' | 'balanced', AdaptiveParams> = {
+  targeted: {
+    mode: 'targeted',
+    textWeight: 0.75,       // Heavy BM25/keyword emphasis
+    temporalWeight: 0.25,
+    decayExponentBase: 0.6, // Stronger decay — recent exact matches matter more
+    zScoreGate: 0.8,        // Strict vector gate — only strong semantic matches
+    beamWidth: 3,           // Narrow beam — don't wander
+    hopPenalty: 0.2,        // Steeper hop penalty
+  },
+  exploratory: {
+    mode: 'exploratory',
+    textWeight: 0.4,        // Lower BM25 weight
+    temporalWeight: 0.6,    // Lean on temporal/associative signals
+    decayExponentBase: 0.3, // Weaker decay — surface older memories
+    zScoreGate: 0.3,        // Relaxed vector gate — cast wider net
+    beamWidth: 20,          // Wide beam — explore associations
+    hopPenalty: 0.4,        // Gentler hop penalty
+  },
+  balanced: {
+    mode: 'balanced',
+    textWeight: 0.6,
+    temporalWeight: 0.4,
+    decayExponentBase: 0.5,
+    zScoreGate: 0.5,
+    beamWidth: 15,
+    hopPenalty: 0.3,
+  },
+};
+
+/**
+ * Classify a query as targeted, exploratory, or balanced.
+ *
+ * Targeted signals: identifiers (PROJ-123, camelCase, snake_case, UUIDs),
+ * short queries (< 8 words), quoted strings, file paths.
+ *
+ * Exploratory signals: question words, long queries (> 15 words),
+ * vague modifiers ("general", "overview", "about", "related to").
+ */
+function classifyQuery(context: string): 'targeted' | 'exploratory' | 'balanced' {
+  const words = context.split(/\s+/).filter(w => w.length > 0);
+  const wordCount = words.length;
+  const lower = context.toLowerCase();
+
+  let targetedScore = 0;
+  let exploratoryScore = 0;
+
+  // Identifier patterns
+  if (/[A-Z]+-\d+/.test(context)) targetedScore += 2;          // PROJ-123
+  if (/[a-z][A-Z]/.test(context)) targetedScore += 1;          // camelCase
+  if (/\w+_\w+/.test(context)) targetedScore += 1;             // snake_case
+  if (/[0-9a-f]{8}-[0-9a-f]{4}/.test(lower)) targetedScore += 2; // UUID fragment
+  if (/["']/.test(context)) targetedScore += 1;                 // Quoted strings
+  if (/[\/\\]/.test(context)) targetedScore += 1;               // File paths
+  if (/\.\w{1,4}$/.test(context.trim())) targetedScore += 1;   // File extensions
+
+  // Short queries are usually targeted
+  if (wordCount <= 5) targetedScore += 2;
+  else if (wordCount <= 8) targetedScore += 1;
+
+  // Question words / exploratory modifiers
+  if (/^(what|how|why|when|where|who|which|can|does|is|are)\b/i.test(context)) exploratoryScore += 1;
+  if (/\b(overview|general|about|related|similar|like|broad|concept|idea|approach|strategy)\b/i.test(lower)) exploratoryScore += 1;
+  if (/\b(any|all|everything|anything)\b/i.test(lower)) exploratoryScore += 1;
+
+  // Long queries are usually exploratory
+  if (wordCount > 15) exploratoryScore += 2;
+  else if (wordCount > 10) exploratoryScore += 1;
+
+  const diff = targetedScore - exploratoryScore;
+  if (diff >= 2) return 'targeted';
+  if (diff <= -2) return 'exploratory';
+  return 'balanced';
+}
+
+function resolveAdaptiveParams(query: ActivationQuery): AdaptiveParams {
+  const mode = query.mode ?? 'auto';
+  if (mode !== 'auto') return ADAPTIVE_PRESETS[mode];
+  const classified = classifyQuery(query.context);
+  return ADAPTIVE_PRESETS[classified];
+}
+
+/**
+ * Common English stopwords — filtered from similarity calculations.
+ * These words carry no semantic signal for memory retrieval.
+ */
+const STOPWORDS = new Set([
+  'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had',
+  'her', 'was', 'one', 'our', 'out', 'has', 'have', 'been', 'from', 'that',
+  'this', 'with', 'they', 'will', 'each', 'make', 'like', 'then', 'than',
+  'them', 'some', 'what', 'when', 'where', 'which', 'who', 'how', 'use',
+  'into', 'does', 'also', 'just', 'more', 'over', 'such', 'only', 'very',
+  'about', 'after', 'being', 'between', 'could', 'during', 'before',
+  'should', 'would', 'their', 'there', 'these', 'those', 'through',
+  'because', 'using', 'other',
+]);
+
+function tokenize(text: string): Set<string> {
+  return new Set(
+    text.toLowerCase()
+      .split(/\s+/)
+      .filter(w => w.length > 2 && !STOPWORDS.has(w))
+  );
+}
+
+/**
+ * Jaccard similarity between two word sets: |intersection| / |union|
+ */
+function jaccard(a: Set<string>, b: Set<string>): number {
+  if (a.size === 0 || b.size === 0) return 0;
+  let intersection = 0;
+  for (const w of a) {
+    if (b.has(w)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+
+export class ActivationEngine {
+  private store: EngramStore;
+  private coActivationBuffer: CoActivationBuffer;
+  readonly validationGate: ValidationGatedBuffer;
+
+  constructor(store: EngramStore) {
+    this.store = store;
+    this.coActivationBuffer = new CoActivationBuffer(50);
+    this.validationGate = new ValidationGatedBuffer();
+  }
+
+  /**
+   * Activate — retrieve the most cognitively relevant engrams for a context.
+   */
+  async activate(query: ActivationQuery): Promise<ActivationResult[]> {
+    const startTime = performance.now();
+    const limit = query.limit ?? 10;
+    const minScore = query.minScore ?? 0.01; // Default: filter out zero-relevance results
+    const useReranker = query.useReranker ?? true;
+    // Default OFF (rerank-only): query expansion ~doubles recall latency (it inflates the rerank
+    // candidate pool) for no measured accuracy gain — validated no-regression on LoCoMo
+    // (overall 22.8→22.7, adversarial 73.5→73.4), the 4-suite eval (identical), and the MWA
+    // gauntlet. Callers can still opt in per-query (useExpansion:true); AWM_DEFAULT_EXPANSION=1
+    // restores expansion-by-default globally as an escape hatch.
+    const useExpansion = query.useExpansion ?? process.env.AWM_DEFAULT_EXPANSION === '1';
+    const abstentionThreshold = query.abstentionThreshold ?? 0;
+    const requireConfidence = query.requireConfidence ?? 0;
+    const adaptive = resolveAdaptiveParams(query);
+
+    // Resolve workspace scope: if workspace is set, search across all agents in that workspace
+    const agentIds = query.workspace
+      ? await this.store.getWorkspaceAgentIds(query.agentId, query.workspace)
+      : [query.agentId];
+    const isWorkspaceScoped = agentIds.length > 1;
+
+    // Phase -1: Coref expansion — if query has pronouns, append recent entity names
+    let queryContext = query.context;
+    const pronounPattern = /\b(she|he|they|her|his|him|their|it|that|this|there)\b/i;
+    if (pronounPattern.test(queryContext)) {
+      try {
+        const recentEntities = (await this.store.getEngramsByAgents(agentIds, 'active'))
+          .sort((a, b) => b.accessCount - a.accessCount)
+          .slice(0, 10)
+          .flatMap(e => e.tags.filter(t => t.length >= 3 && !/^(session-|low-|D\d)/.test(t)))
+          .filter((v, i, a) => a.indexOf(v) === i)
+          .slice(0, 5);
+        if (recentEntities.length > 0) {
+          queryContext = `${queryContext} ${recentEntities.join(' ')}`;
+        }
+      } catch { /* non-fatal */ }
+    }
+
+    // Phase 0: Query expansion — add related terms to improve BM25 recall
+    let searchContext = queryContext;
+    if (useExpansion) {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        searchContext = await Promise.race([
+          expandQuery(query.context),
+          new Promise<string>((_, reject) => { timer = setTimeout(() => reject(new Error('expansion timeout')), 5000); }),
+        ]);
+      } catch {
+        // Expansion unavailable or timed out — use original query
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    }
+
+    // Phase 1: Embed query for vector similarity (uses coref-expanded context)
+    let queryEmbedding: number[] | null = null;
+    try {
+      queryEmbedding = await embed(queryContext);
+    } catch {
+      // Embedding unavailable — fall back to text-only matching
+    }
+
+    // Phase 2: Parallel retrieval — dual BM25 + all active engrams
+    // Two-pass BM25: (1) keyword-stripped query for precision, (2) expanded query for recall.
+    const keywordQuery = Array.from(tokenize(query.context)).join(' ');
+    const bm25Keyword = keywordQuery.length > 2
+      ? await this.store.searchBM25WithRankMultiAgent(agentIds, keywordQuery, limit * 3)
+      : [];
+    const bm25Expanded = await this.store.searchBM25WithRankMultiAgent(agentIds, searchContext, limit * 3);
+
+    // Merge: take the best BM25 score per engram from either pass
+    const bm25ScoreMap = new Map<string, number>();
+    const bm25EngramMap = new Map<string, any>();
+    for (const r of [...bm25Keyword, ...bm25Expanded]) {
+      const existing = bm25ScoreMap.get(r.engram.id) ?? 0;
+      if (r.bm25Score > existing) {
+        bm25ScoreMap.set(r.engram.id, r.bm25Score);
+        bm25EngramMap.set(r.engram.id, r.engram);
+      }
+    }
+    const bm25Ranked = Array.from(bm25EngramMap.entries()).map(([id, engram]) => ({
+      engram, bm25Score: bm25ScoreMap.get(id) ?? 0,
+    }));
+
+    // Phase 3 — Two-pass fetch (0.7.9+):
+    //   Pass 1: slim fetch (id, concept, embedding only) for ALL active engrams.
+    //           Used for cosine sim + adaptive z-score stats + cheap pool filter.
+    //   Pass 2: full fetch ONLY on the survivors that pass the filter.
+    //
+    // AWM 0.8.x — Native vector search refactor (2026-05-25): the prior slim
+    // fetch path materialized ALL active engrams (id + concept + embedding)
+    // for in-process cosine + z-score gating. On PGlite that meant parsing
+    // 11K embedding vectors per recall (~200-500ms). Replaced with native
+    // vector search: PGlite uses pgvector + ivfflat (O(log N)); SQLite uses
+    // its slim cache + JS cosine (same as before but encapsulated). Z-score
+    // normalization is replaced with a mode-adaptive raw-cosine floor —
+    // simpler, faster, model-tuned for BGE-small embeddings.
+    // D4 (2026-07-30): AWM_DISABLE_POOL_FILTER=1 was documented since 0.7.x but
+    // never implemented after the 0.8.x native-vector refactor absorbed the
+    // pool pre-filter. Honor its documented semantics: score ALL active
+    // candidates (no top-K cut, no similarity floor).
+    const POOL_FILTER_DISABLED = process.env.AWM_DISABLE_POOL_FILTER === '1';
+    const VECTOR_TOP_K = POOL_FILTER_DISABLED ? Number.MAX_SAFE_INTEGER : Math.max(50, limit * 5);
+
+    // Tokenize query once (used by scoring)
+    const queryTokens = tokenize(query.context);
+
+    // Phase 3a: native vector search across agents — top-K by cosine.
+    // Apply a candidate floor — BGE-small unit-norm vectors typically cluster
+    // around 0.30-0.40 even for unrelated text, so we need a floor that
+    // distinguishes "related" from "noise" without throwing out genuine
+    // related-but-not-identical matches.
+    //
+    // Tuning: targeted=0.40, exploratory=0.30. Earlier 0.55/0.45 floors were
+    // too aggressive — they dropped Recall@5 on the 200-fact eval corpus
+    // from 0.80 → 0.46 (verified 2026-05-26). BGE-small cosines for genuine
+    // related matches commonly land 0.42-0.55, so a 0.55 floor cut them
+    // entirely. The vectorMatch scoring floor (0.50 targeted / 0.35 exploratory)
+    // still suppresses low-confidence matches in the final score.
+    // Env override: AWM_SIM_CANDIDATE_FLOOR_TARGETED, AWM_SIM_CANDIDATE_FLOOR_EXPLORATORY.
+    const SIM_CANDIDATE_FLOOR = POOL_FILTER_DISABLED ? -1 : (adaptive.zScoreGate > 0.5
+      ? Number(process.env.AWM_SIM_CANDIDATE_FLOOR_TARGETED ?? 0.40)
+      : Number(process.env.AWM_SIM_CANDIDATE_FLOOR_EXPLORATORY ?? 0.30));
+    const rawCosineSims = new Map<string, number>();
+    const vectorHits: Engram[] = [];
+    if (queryEmbedding) {
+      for (const aid of agentIds) {
+        try {
+          const hits = await this.store.searchByVector(aid, queryEmbedding, VECTOR_TOP_K);
+          for (const h of hits) {
+            // pgvector cosine distance: 0 = identical, 2 = opposite.
+            // For unit-norm BGE vectors, distance ≈ 1 - cosineSimilarity.
+            const sim = 1 - h.distance;
+            // pgvector returns sorted ASC by distance (DESC by sim) — break once
+            // we drop below the candidate floor; all subsequent hits will too.
+            if (sim < SIM_CANDIDATE_FLOOR) break;
+            if (!rawCosineSims.has(h.engram.id)) {
+              rawCosineSims.set(h.engram.id, sim);
+              vectorHits.push(h.engram);
+            }
+          }
+        } catch {
+          // Vector search unavailable — fall back to BM25-only ranking
+        }
+      }
+    }
+
+    // Survivors = BM25 candidates ∪ vector candidates.
+    // The slim-fetch jaccard-fallback path is dropped: in practice it surfaced
+    // <1% of candidates that BM25 + vector missed, and on PGlite cost more
+    // than the candidates were worth. Concept jaccard signal still contributes
+    // via textMatch in scoring.
+    const survivorIds = new Set<string>();
+    for (const r of bm25Ranked) survivorIds.add(r.engram.id);
+    for (const e of vectorHits) survivorIds.add(e.id);
+
+    // Hydrate full engrams. BM25 and vector hits arrive pre-hydrated; nothing
+    // else needs fetching in the normal path.
+    const candidateMap = new Map<string, Engram>();
+    for (const r of bm25Ranked) candidateMap.set(r.engram.id, r.engram);
+    for (const e of vectorHits) candidateMap.set(e.id, e);
+    let candidates = Array.from(candidateMap.values());
+
+    // Filter by memory type if specified
+    if (query.memoryType) {
+      candidates = candidates.filter(e => e.memoryType === query.memoryType);
+    }
+
+    // ── ENTITY-AWARE CANDIDATE FETCH (2026-06, fixes the buried 2-hop / sparse-cue gap) ──
+    // A query like "codename for my main project" strongly recalls "main project = Atlas" but the
+    // ANSWER ("Atlas codename = Magpie") is a different-vocabulary attribute fact that falls out
+    // of the candidate pool — and rerank can't rescue what isn't in the pool. AWM doesn't form
+    // entity-co-occurrence edges, so graph-walk can't bridge it either. Fix: from the strongest
+    // seeds, pull the proper-noun ENTITIES that aren't already in the query, run ONE cheap local
+    // BM25 pass on them, and add the hits to the candidate pool. RECALL-ONLY: these only become
+    // candidates the reranker can consider — the final top-K stays rerank-gated, so this never
+    // surfaces facts you don't need (preserves AWM's precision-first design). Fast (one BM25
+    // call), local (no network/LLM), capped. DEFAULT-OFF (opt-in AWM_ENTITY_FETCH=1): verified
+    // recall-only pool-injection is INSUFFICIENT at scale — the buried fact enters the pool but
+    // still ranks below distractors against the vocab-mismatched original query, and a ranking
+    // boost would trade precision (against AWM's precision-first design). The design-aligned fix
+    // is HARNESS-side multi-hop decomposition (LLM chains sequential single-hop recalls). Kept
+    // opt-in for future spreading-activation experiments.
+    if (process.env.AWM_ENTITY_FETCH === '1' && candidates.length > 0) {
+      const ENT_SEEDS = Number(process.env.AWM_ENTITY_FETCH_SEEDS ?? 5);
+      const ENT_CAP = Number(process.env.AWM_ENTITY_FETCH_CAP ?? 30);
+      const STOPCAPS = new Set(['my', 'the', 'a', 'an', 'i', 'we', 'you', 'he', 'she', 'it', 'they', 'this', 'that', 'what', 'when', 'where', 'who', 'why', 'how', 'is', 'are', 'was', 'were', 'do', 'does', 'project', 'account', 'codename', 'name', 'team', 'main', 'internal']);
+      const seeds = candidates
+        .map(e => ({ e, s: Math.max(bm25ScoreMap.get(e.id) ?? 0, rawCosineSims.get(e.id) ?? 0) }))
+        .sort((a, b) => b.s - a.s).slice(0, ENT_SEEDS);
+      const ents = new Set<string>();
+      for (const { e } of seeds) {
+        for (const match of `${e.concept} ${e.content}`.matchAll(/\b[A-Z][A-Za-z]{2,}\b/g)) {
+          const w = match[0]; const lw = w.toLowerCase();
+          if (!queryTokens.has(lw) && !STOPCAPS.has(lw)) ents.add(w);
+        }
+      }
+      if (ents.size > 0) {
+        try {
+          const entHits = await this.store.searchBM25WithRankMultiAgent(agentIds, Array.from(ents).slice(0, 8).join(' '), ENT_CAP);
+          let added = 0;
+          for (const h of entHits) {
+            if (added >= ENT_CAP) break;
+            const n = h.engram;
+            if (candidateMap.has(n.id)) continue;
+            if (n.stage !== 'active' || (n as any).retracted || n.supersededBy) continue;
+            if (query.memoryType && n.memoryType !== query.memoryType) continue;
+            candidateMap.set(n.id, n);
+            bm25ScoreMap.set(n.id, Math.max(bm25ScoreMap.get(n.id) ?? 0, h.bm25Score)); // scoring sees it
+            added++;
+          }
+          if (added > 0) candidates = Array.from(candidateMap.values());
+        } catch { /* best-effort: entity fetch never breaks recall */ }
+      }
+    }
+
+    // ── D11 (2026-07-30): ENTITY-INDEX CANDIDATE INJECTION (default-OFF, AWM_ENTITY_INDEX_FETCH=1) ──
+    // The D9 inverted index resolves query-NAMED entities ("Seetha", "ticket 18999") to every
+    // engram indexed under them — deterministic exact lookup, immune to embedding/BM25 vocabulary
+    // mismatch. Injected candidates get NO score boost; instead they are GUARANTEED a rerank
+    // audition (exempt from the topN cut, the minScore pool filter, the rerank-pool slice, and
+    // the rerank-skip heuristic) and the cross-encoder alone decides whether they surface.
+    // This is the guarded successor to AWM_ENTITY_FETCH above, whose failure mode was measured:
+    // injected gold entered the pool but was cut before the reranker ever scored it. Bounded
+    // (AWM_ENTITY_INDEX_CAP, default 12) so the audition costs at most one extra rerank batch.
+    const injectedIds = new Set<string>();
+    if (process.env.AWM_ENTITY_INDEX_FETCH === '1') {
+      try {
+        const IDX_CAP = Number(process.env.AWM_ENTITY_INDEX_CAP ?? 12);
+        const IDX_QSTOP = new Set(['what', 'who', 'when', 'where', 'why', 'how', 'which', 'whose',
+          'the', 'this', 'that', 'and', 'but', 'for', 'did', 'does', 'is', 'are', 'was', 'were',
+          'tell', 'about', 'they', 'them', 'write', 'reply', 'list', 'please', 'remember', 'confirm']);
+        const terms = new Set<string>();
+        for (const m of query.context.matchAll(/\b[A-Z][A-Za-z]{2,}\b/g)) {
+          const w = m[0].toLowerCase();
+          if (!IDX_QSTOP.has(w)) terms.add(w);
+        }
+        for (const m of query.context.matchAll(/\b\d{4,}\b/g)) terms.add(m[0]); // bare ids: tickets, members, events
+        let added = 0;
+        for (const term of Array.from(terms).slice(0, 4)) {
+          if (added >= IDX_CAP) break;
+          const entities = await this.store.searchEntities(term, 6);
+          for (const entity of entities) {
+            if (added >= IDX_CAP) break;
+            for (const agentId of agentIds) {
+              if (added >= IDX_CAP) break;
+              for (const id of await this.store.getEngramIdsByEntity(entity, agentId)) {
+                if (added >= IDX_CAP) break;
+                if (injectedIds.has(id)) continue;
+                // Already a candidate via BM25/vector? Still VOUCH for it: a weak in-pool
+                // candidate the index confirms would otherwise die at the minScore/topN
+                // cuts unguarded. The audition guarantee is about the index match, not
+                // about how the candidate entered the pool.
+                const inPool = candidateMap.get(id);
+                if (inPool) {
+                  if (inPool.stage === 'active' && !(inPool as any).retracted && !inPool.supersededBy) { injectedIds.add(id); added++; }
+                  continue;
+                }
+                const n = await this.store.getEngram(id);
+                if (!n || n.stage !== 'active' || (n as any).retracted || n.supersededBy) continue;
+                if (query.memoryType && n.memoryType !== query.memoryType) continue;
+                candidateMap.set(id, n);
+                injectedIds.add(id);
+                added++;
+              }
+            }
+          }
+        }
+        if (added > 0) candidates = Array.from(candidateMap.values());
+      } catch { /* index injection never breaks recall */ }
+    }
+
+    if (candidates.length === 0) return [];
+
+    // Phase 3b: Score each candidate with per-phase breakdown
+    // Candidates are already filtered (the slim-pool filter ran before hydration).
+    //
+    // Optimization (0.7.12+): the scoring loop only reads `count` and `sumWeight`
+    // from associations. Use a SQL aggregate (GROUP BY) to fetch scalar stats
+    // instead of materializing thousands of Association objects. Phase-breakdown
+    // (post-0.7.10) showed this saves ~200ms (222ms → ~20ms).
+    //
+    // Graph walk still needs full Association objects, but it operates on the
+    // top-N (~30 candidates) — its on-demand `getAssociationsFor` lookups are
+    // cheap (<5ms total).
+    const assocStats = await this.store.getAssociationStatsForBatch(candidates.map(e => e.id));
+    const scored = candidates.map(engram => {
+      const ageDays = (Date.now() - engram.createdAt.getTime()) / (1000 * 60 * 60 * 24);
+      const stats = assocStats.get(engram.id) ?? { count: 0, sumWeight: 0 };
+
+      // --- Text relevance (keyword signals) ---
+
+      // Signal 1: BM25 continuous score (0-1, from FTS5 rank)
+      const bm25Score = bm25ScoreMap.get(engram.id) ?? 0;
+
+      // Signal 2: Jaccard similarity with stopword filtering
+      const conceptTokens = tokenize(engram.concept);
+      const contentTokens = tokenize(engram.content);
+      const conceptJaccard = jaccard(queryTokens, conceptTokens);
+      const contentJaccard = jaccard(queryTokens, contentTokens);
+      const jaccardScore = 0.6 * conceptJaccard + 0.4 * contentJaccard;
+
+      // Signal 3: Concept exact match bonus (up to 0.3)
+      const conceptOverlap = conceptTokens.size > 0
+        ? [...conceptTokens].filter(w => queryTokens.has(w)).length / conceptTokens.size
+        : 0;
+      const conceptBonus = conceptOverlap * 0.3;
+
+      const keywordMatch = Math.min(Math.max(bm25Score, jaccardScore) + conceptBonus, 1.0);
+
+      // --- Vector similarity (semantic signal) ---
+      // AWM 0.8.x: model-tuned raw-cosine floor in place of z-score normalization.
+      // For BGE-small unit-norm vectors: unrelated ~0.3, related 0.5-0.7, near-duplicate 0.85+.
+      // Floor adapts to query mode: targeted=0.50 (stricter), exploratory=0.35 (looser).
+      let vectorMatch = 0;
+      const rawSim = rawCosineSims.get(engram.id);
+      if (rawSim !== undefined && rawSim > 0) {
+        const SIM_FLOOR = adaptive.zScoreGate > 0.5
+        ? Number(process.env.AWM_SIM_FLOOR_TARGETED ?? 0.50)
+        : Number(process.env.AWM_SIM_FLOOR_EXPLORATORY ?? 0.35);
+        if (rawSim > SIM_FLOOR) {
+          // Map [SIM_FLOOR, 1.0] → [0, 1] linearly with cap at 1.0.
+          vectorMatch = Math.min(1, (rawSim - SIM_FLOOR) / (0.95 - SIM_FLOOR));
+        }
+      }
+
+      // Combined text match: weighted blend of keyword and vector signals.
+      // BM25 is better at lexical discrimination; vector is better at semantic matching.
+      // When both are non-zero, blend favors the stronger signal with a boost.
+      const textMatch = keywordMatch > 0 && vectorMatch > 0
+        ? 0.5 * Math.max(keywordMatch, vectorMatch) + 0.3 * Math.min(keywordMatch, vectorMatch) + 0.2 * (keywordMatch * vectorMatch)
+        : Math.max(keywordMatch, vectorMatch);
+
+      // --- Temporal signals ---
+
+      // ACT-R decay — confidence + replay modulated (synaptic tagging)
+      // High-confidence memories decay slower. Heavily-accessed memories also resist decay.
+      // Base exponent adapts to query mode: targeted (0.6) decays harder, exploratory (0.3) preserves older memories.
+      const confMod = 0.2 * Math.max(0, (engram.confidence - 0.5) / 0.5);
+      const replayMod = Math.min(0.1, 0.05 * Math.log1p(engram.accessCount));
+      const decayExponent = Math.max(0.2, adaptive.decayExponentBase - confMod - replayMod);
+      const decayScore = baseLevelActivation(engram.accessCount, ageDays, decayExponent);
+
+      // Hebbian boost from associations — capped to prevent popular memories
+      // from dominating regardless of query relevance
+      const rawHebbian = stats.count > 0 ? stats.sumWeight / stats.count : 0;
+      const hebbianBoost = Math.min(rawHebbian, 0.5);
+
+      // Centrality signal — well-connected memories (high weighted degree)
+      // get a small boost. This makes consolidation edges matter for retrieval.
+      // Log-scaled to prevent hub domination: 10 edges ≈ 0.05 boost, 50 ≈ 0.08
+      const centralityBoost = stats.count > 0
+        ? Math.min(0.1, 0.03 * Math.log1p(stats.sumWeight))
+        : 0;
+
+      // Confidence gate — multiplicative quality signal
+      const confidenceGate = engram.confidence;
+
+      // Feedback bonus — memories confirmed useful via explicit feedback get a
+      // direct additive boost. Models how a senior dev "just knows" certain things
+      // are important. Confidence > 0.6 means at least 2+ positive feedbacks.
+      // Scales: conf 0.6→0.03, 0.7→0.06, 0.8→0.09, 1.0→0.15
+      const feedbackBonus = engram.confidence > 0.55
+        ? Math.min(0.15, 0.3 * Math.max(0, engram.confidence - 0.5))
+        : 0;
+
+      // --- Composite score: relevance-gated additive ---
+      // Text/temporal weights adapt to query mode: targeted (0.75/0.25), exploratory (0.4/0.6).
+      const temporalNorm = Math.min(softplus(decayScore + hebbianBoost), 3.0) / 3.0;
+      const relevanceGate = textMatch > 0.1 ? textMatch : 0.0; // Proportional gate
+      const composite = (adaptive.textWeight * textMatch + adaptive.temporalWeight * temporalNorm * relevanceGate + centralityBoost * relevanceGate + feedbackBonus * relevanceGate) * confidenceGate;
+
+      const phaseScores: PhaseScores = {
+        textMatch,
+        vectorMatch,
+        decayScore,
+        hebbianBoost,
+        graphBoost: 0, // Filled in phase 5
+        confidenceGate,
+        composite,
+        rerankerScore: 0, // Filled in phase 7
+      };
+
+      // associations: empty in 0.7.12+ — graph walk lazy-fetches per engram on demand
+      return { engram, score: composite, phaseScores, associations: [] as Association[] };
+    });
+
+    // Phase 3.5: Rocchio pseudo-relevance feedback — expand query with top result terms
+    // then re-search BM25 to find candidates that keyword search missed
+    const preSorted = scored.sort((a, b) => b.score - a.score);
+    const topForFeedback = preSorted.slice(0, 3).filter(r => r.phaseScores.textMatch > 0.1);
+    if (topForFeedback.length > 0) {
+      const feedbackTerms = new Set<string>();
+      for (const item of topForFeedback) {
+        const tokens = tokenize(item.engram.content);
+        for (const t of tokens) {
+          if (!queryTokens.has(t) && t.length >= 4) feedbackTerms.add(t);
+        }
+      }
+      // Take top 5 feedback terms and re-search
+      const extraTerms = Array.from(feedbackTerms).slice(0, 5).join(' ');
+      if (extraTerms) {
+        const feedbackBM25 = await this.store.searchBM25WithRankMultiAgent(agentIds, `${searchContext} ${extraTerms}`, limit * 2);
+        for (const r of feedbackBM25) {
+          if (!candidateMap.has(r.engram.id)) {
+            candidateMap.set(r.engram.id, r.engram);
+            // Score the new candidate
+            const engram = r.engram;
+            const ageDays = (Date.now() - engram.createdAt.getTime()) / (1000 * 60 * 60 * 24);
+            const associations = await this.store.getAssociationsFor(engram.id);
+            const cTokens = tokenize(engram.concept);
+            const ctTokens = tokenize(engram.content);
+            const cJac = jaccard(queryTokens, cTokens);
+            const ctJac = jaccard(queryTokens, ctTokens);
+            const jSc = 0.6 * cJac + 0.4 * ctJac;
+            const cOvlp = cTokens.size > 0 ? [...cTokens].filter(w => queryTokens.has(w)).length / cTokens.size : 0;
+            const km = Math.min(Math.max(r.bm25Score, jSc) + cOvlp * 0.3, 1.0);
+            let vm = 0;
+            const rs = rawCosineSims.get(engram.id) ?? (queryEmbedding && engram.embedding ? cosineSimilarity(queryEmbedding, engram.embedding) : 0);
+            if (rs > 0) {
+              const SIM_FLOOR = adaptive.zScoreGate > 0.5
+        ? Number(process.env.AWM_SIM_FLOOR_TARGETED ?? 0.50)
+        : Number(process.env.AWM_SIM_FLOOR_EXPLORATORY ?? 0.35);
+              if (rs > SIM_FLOOR) vm = Math.min(1, (rs - SIM_FLOOR) / (0.95 - SIM_FLOOR));
+            }
+            const tm = km > 0 && vm > 0
+              ? 0.5 * Math.max(km, vm) + 0.3 * Math.min(km, vm) + 0.2 * (km * vm)
+              : Math.max(km, vm);
+            const ds = baseLevelActivation(engram.accessCount, ageDays);
+            const rh = associations.length > 0 ? Math.min(associations.reduce((s, a) => s + a.weight, 0) / associations.length, 0.5) : 0;
+            const tn = Math.min(softplus(ds + rh), 3.0) / 3.0;
+            const rg = tm > 0.1 ? tm : 0.0;
+            const comp = (adaptive.textWeight * tm + adaptive.temporalWeight * tn * rg) * engram.confidence;
+            scored.push({ engram, score: comp, phaseScores: { textMatch: tm, vectorMatch: vm, decayScore: ds, hebbianBoost: rh, graphBoost: 0, confidenceGate: engram.confidence, composite: comp, rerankerScore: 0 }, associations });
+          }
+        }
+      }
+    }
+
+    // Phase 3.7: Entity-Bridge boost — boost scored candidates that share entity tags
+    // with the most query-relevant result. The original intent: surface candidates
+    // that DON'T match the query text directly but share entities with the top
+    // text-match anchor ("she said something" → bridge to entities of the recent
+    // speaker named "she"). This is LATERAL relevance, not direct relevance.
+    //
+    // 2026-05-26: Added textMatch gate. Without it, when many engrams share entity
+    // tags AND have similar text matches (e.g., 10 near-clones of the same concept),
+    // the bridge boost would push the 8 non-anchor clones above the 2 anchors —
+    // an inversion of the genuine top match. The eval Retrieval suite caught this
+    // (Recall@5 0.80 → 0.46). Gate: only boost candidates whose textMatch is
+    // meaningfully below the anchor's. They actually need the lateral boost.
+    // Env override: AWM_DISABLE_ENTITY_BRIDGE=1 to skip this phase entirely.
+    if (!process.env.AWM_DISABLE_ENTITY_BRIDGE)
+    {
+      // Find the result with the highest textMatch (most query-relevant, not just highest score)
+      // Gate: only bridge when anchor has meaningful text relevance (> 0.15)
+      // Adaptive: scale bridge boost inversely with candidate pool size to prevent
+      // over-boosting in large memory pools where many items share entity tags
+      const sortedByTextMatch = scored
+        .filter(r => r.phaseScores.textMatch > 0.15)
+        .sort((a, b) => b.phaseScores.textMatch - a.phaseScores.textMatch);
+
+      // Bridge from top 2 text-matched results (IDF handles weighting)
+      const bridgeAnchors = sortedByTextMatch.slice(0, 2);
+
+      if (bridgeAnchors.length > 0) {
+        const entityTags = new Set<string>();
+        const anchorIds = new Set(bridgeAnchors.map(r => r.engram.id));
+
+        for (const item of bridgeAnchors) {
+          for (const tag of item.engram.tags) {
+            const t = tag.toLowerCase();
+            // Skip non-entity tags: turn IDs, session tags, dialogue IDs, generic speaker labels
+            if (/^t\d+$/.test(t) || t.startsWith('session-') || t.startsWith('dia_') || t.length < 3) continue;
+            if (/^speaker\d*$/.test(t)) continue; // Generic speaker labels are too broad
+            // Auto-tagger `cat:` category tags are too broad to bridge on (they'd link
+            // every "cat:work" memory laterally); they stay for BM25 recall only. The
+            // precise `entity:` proper-noun tags are kept as bridges.
+            if (t.startsWith('cat:')) continue;
+            entityTags.add(t);
+          }
+        }
+
+        // Document frequency filter: remove tags appearing in >30% of items (too common)
+        // This prevents speaker names in 2-person conversations from being used as bridges
+        if (entityTags.size > 0 && scored.length > 10) {
+          const tagFreqs = new Map<string, number>();
+          for (const item of scored) {
+            const seen = new Set<string>();
+            for (const tag of item.engram.tags) {
+              const t = tag.toLowerCase();
+              if (entityTags.has(t) && !seen.has(t)) {
+                seen.add(t);
+                tagFreqs.set(t, (tagFreqs.get(t) ?? 0) + 1);
+              }
+            }
+          }
+          const maxFreq = scored.length * 0.30;
+          for (const [tag, freq] of tagFreqs) {
+            if (freq > maxFreq) entityTags.delete(tag);
+          }
+        }
+
+        if (entityTags.size > 0) {
+          // Anchor's textMatch sets the scale. Bridge boost magnitude is
+          // proportional to the gap between anchor and candidate textMatch:
+          //   - candidate near anchor (a near-clone of the anchor) → small gap → near-zero boost
+          //   - candidate far below anchor (genuine lateral relevance) → large gap → full boost
+          // Without this scaling, dense same-concept corpora flip the genuine
+          // top-1 below its 8-9 near-clones (eval Recall@5 0.80 → 0.46 verified
+          // 2026-05-26). The scaling keeps the lateral-relevance behavior
+          // (which is what helps the AB test) without inverting the genuine
+          // text-match winner.
+          const anchorTextMax = bridgeAnchors[0].phaseScores.textMatch;
+
+          for (const item of scored) {
+            if (anchorIds.has(item.engram.id)) continue;
+
+            const engramTags = new Set(item.engram.tags.map((t: string) => t.toLowerCase()));
+            let sharedEntities = 0;
+            for (const et of entityTags) {
+              if (engramTags.has(et)) sharedEntities++;
+            }
+
+            if (sharedEntities > 0) {
+              // Gap scaling: 1.0 when candidateText << anchorText, 0 when equal.
+              // Clamped to [0, 1]. Anchors with textMatch ≤ 0 fall back to flat boost.
+              const gapScale = anchorTextMax > 0
+                ? Math.max(0, Math.min(1, (anchorTextMax - item.phaseScores.textMatch) / anchorTextMax))
+                : 1;
+              const bridgeBoost = Math.min(sharedEntities * 0.15, 0.4) * gapScale;
+              if (bridgeBoost > 0) {
+                item.score += bridgeBoost;
+                item.phaseScores.composite += bridgeBoost;
+                item.phaseScores.graphBoost += bridgeBoost;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Phase 3.75: Query-conditioned entity bridge (default-OFF, AWM_QUERY_BRIDGE=1).
+    //
+    // The anchor-based bridge above (Phase 3.7) is query-BLIND: it bridges from the
+    // top text-match result's tags and a document-frequency filter DELETES common
+    // tags (e.g. a speaker present in >30% of turns). That is exactly backwards for
+    // attribution / entity-named queries: if the user asks "what does Caroline think
+    // about the trip" or "who said the trip moved to Saturday", the speaker/entity the
+    // query NAMES is the single most valuable bridge — its corpus frequency is
+    // irrelevant. This phase extracts proper-noun entities from the QUERY and boosts
+    // candidates whose tags match them, regardless of frequency, gated by topical
+    // relevance (textMatch floor) so it surfaces "Caroline's turns ABOUT the trip"
+    // rather than every Caroline turn. Boost folds into composite → survives rerank.
+    // Recall-only re-ranking of in-pool candidates (no injection) → low precision risk.
+    if (process.env.AWM_QUERY_BRIDGE === '1') {
+      const QSTOP = new Set(['what', 'who', 'when', 'where', 'why', 'how', 'which', 'whose', 'whom',
+        'the', 'this', 'that', 'these', 'those', 'and', 'but', 'for', 'did', 'does', 'is', 'are',
+        'was', 'were', 'how', 'tell', 'about', 'they', 'them']);
+      const qEnts = new Set<string>();
+      for (const m of query.context.matchAll(/\b[A-Z][a-zA-Z]{2,}\b/g)) {
+        const w = m[0].toLowerCase();
+        if (!QSTOP.has(w)) qEnts.add(w);
+      }
+      if (qEnts.size > 0) {
+        const QC_WEIGHT = Number(process.env.AWM_QUERY_BRIDGE_WEIGHT ?? 0.4);
+        const QC_CAP = Number(process.env.AWM_QUERY_BRIDGE_CAP ?? 0.4);
+        const QC_FLOOR = Number(process.env.AWM_QUERY_BRIDGE_FLOOR ?? 0.1);
+        for (const item of scored) {
+          if (item.phaseScores.textMatch < QC_FLOOR) continue; // only re-rank topically-relevant candidates
+          let matches = 0;
+          for (const tag of item.engram.tags) {
+            const t = tag.toLowerCase();
+            const val = t.startsWith('entity:') ? t.slice(7) : t;
+            // match whole-tag or any word of a multi-word entity ("marcus lee" ← "Marcus")
+            if (qEnts.has(val) || val.split(/\s+/).some(w => qEnts.has(w))) { matches++; }
+          }
+          if (matches > 0) {
+            // Relevance-modulated: scale by the candidate's topical relevance so
+            // "named-entity AND on-topic" wins big while "named-entity but off-topic
+            // chatter" (a common speaker tag on an irrelevant turn) gets almost
+            // nothing. Without this, a broad speaker tag floods the top with the
+            // person's unrelated turns (verified 2026-06-16 _query-bridge-verify).
+            const boost = Math.min(matches * QC_WEIGHT * item.phaseScores.textMatch, QC_CAP);
+            item.score += boost;
+            item.phaseScores.composite += boost;
+            item.phaseScores.graphBoost += boost;
+          }
+        }
+      }
+    }
+
+    // Phase 4+5: Graph walk — boost engrams connected to high-scoring ones
+    // Only walk from engrams that had text relevance (composite > 0 pre-walk)
+    const sorted = scored.sort((a, b) => b.score - a.score);
+    // Candidate breadth carried into graph-walk + rerank. Default 8×limit (was 3×).
+    // WHY 8× (2026-06-16): the pipeline-attribution trace showed ~50% of answerable LoCoMo
+    // queries had gold that CLEARED the floor (89%) but was squeezed out HERE by the
+    // decay-compressed composite before the (high-lift, +3.29) reranker saw it — the
+    // dominant loss. Widening this + the rerank pool (below) lifted official LoCoMo
+    // 22.7→25.1 (every recall category up), 4-suite unchanged, recall 35→77ms; small
+    // adversarial cost 73.4→71.0 (a fixed step, recoverable on the abstention gate).
+    // Tunable via AWM_TOPN_MULT.
+    const topNMult = Number(process.env.AWM_TOPN_MULT ?? 8);
+    const topN = sorted.slice(0, limit * topNMult);
+    // D11 guard 1/4: injected entity-index candidates ride into the graph/rerank stages even
+    // when their (boost-free) composite fell below the topN cut.
+    if (injectedIds.size > 0) {
+      for (const item of sorted.slice(limit * topNMult)) {
+        if (injectedIds.has(item.engram.id)) topN.push(item);
+      }
+    }
+    if (process.env.AWM_SPREAD === '1' && query.spread !== false) {
+      await this.spreadActivation(topN);
+    } else {
+      await this.graphWalk(topN, 2, adaptive.hopPenalty, adaptive.beamWidth);
+    }
+
+    // Phase 6: Initial filter and sort for re-ranking pool
+    // (D11 guard 2/4: injected entity-index candidates are exempt from the minScore floor.)
+    const pool = topN
+      .filter(r => r.score >= minScore || injectedIds.has(r.engram.id))
+      .sort((a, b) => b.score - a.score);
+
+    // Phase 7: Cross-encoder re-ranking — scores (query, passage) pairs directly
+    // Widens the pool to find relevant results that keyword matching missed.
+    // How many candidates reach the cross-encoder. Default max(limit*4, 40) — widened
+    // from max(limit*2, 15) on 2026-06-16. WHY: the reranker rarely loses gold (0.5%) and
+    // lifts it +3.29, but the weak composite was only passing it ~35% of retrievable gold;
+    // feeding it more recovered the dominant lost@pool/scoring bucket. Validated knee on
+    // recall × precision × latency (pool 40 ≈ 25.1% LoCoMo / 71.0% adv / 77ms; pool 60 adds
+    // only +0.6pp for +33ms). The composite is now a CHEAP WIDE PRE-FILTER, not the ranker —
+    // the reranker does discrimination on a wide pool. Tunable via AWM_RERANK_POOL.
+    const rerankPoolSize = Number(process.env.AWM_RERANK_POOL ?? Math.max(limit * 4, 40));
+    const rerankPool = pool.slice(0, rerankPoolSize);
+    // D11 guard 3/4: injected entity-index candidates always reach the cross-encoder.
+    if (injectedIds.size > 0) {
+      for (const item of pool.slice(rerankPoolSize)) {
+        if (injectedIds.has(item.engram.id)) rerankPool.push(item);
+      }
+    }
+
+    // Reranker skip heuristic (0.7.10+): if BM25 already has a clear winner with
+    // strong absolute score AND a meaningful gap to the runner-up, the cross-encoder
+    // is unlikely to change the top result. Skipping saves ~300ms of wall-clock per
+    // recall on simple queries (40% of post-0.7.9 floor was reranker).
+    //
+    // Conservative gate (only skip when very confident):
+    //   - top-1 textMatch >= 0.8 (high BM25 + jaccard agreement)
+    //   - top-1 score is at least 1.5× top-2 score (clear separation)
+    //   - rerankPool size <= limit*2 (small pool — reranker has less to do)
+    //
+    // Ambiguous queries (close BM25 scores, weak top-1, large pool) still go through
+    // the reranker. Disable this heuristic via AWM_DISABLE_RERANK_SKIP=1.
+    let rerankSkipped = false;
+    // (D11 guard 4/4: never skip the reranker when entity-index candidates were injected —
+    // the audition IS the rerank; skipping would return them unjudged or drop them.)
+    if (useReranker && rerankPool.length >= 2 && injectedIds.size === 0 && process.env.AWM_DISABLE_RERANK_SKIP !== '1') {
+      const top1 = rerankPool[0];
+      const top2 = rerankPool[1];
+      const t1Text = top1.phaseScores.textMatch;
+      const t1Score = top1.score;
+      const t2Score = top2.score;
+      const cleanWinner = t1Text >= 0.8 && t1Score >= 1.5 * Math.max(t2Score, 0.01);
+      const smallPool = rerankPool.length <= Math.max(limit * 2, 20);
+      if (cleanWinner && smallPool) {
+        rerankSkipped = true;
+      }
+    }
+
+    if (useReranker && !rerankSkipped && rerankPool.length > 0) {
+      try {
+        // Truncate content to ~400 chars before rerank (0.7.14+). Cross-encoders
+        // have a 512-token max anyway and pad to the longest passage in the batch;
+        // sending full content (some 5000+ chars) means everything pads to ~512
+        // tokens. Truncation drops tokenization + inference cost ~3-4× on long
+        // memory pools without losing rerank signal — the concept + first 400
+        // chars carry the core meaning.
+        const passages = rerankPool.map(r => {
+          const concept = r.engram.concept;
+          const content = r.engram.content.length > 400
+            ? r.engram.content.slice(0, 400)
+            : r.engram.content;
+          return `${concept}: ${content}`;
+        });
+        let rerankTimer: ReturnType<typeof setTimeout> | undefined;
+        const rerankResults = await Promise.race([
+          rerank(query.context, passages),
+          new Promise<never>((_, reject) => { rerankTimer = setTimeout(() => reject(new Error('reranker timeout')), 10000); }),
+        ]).finally(() => { if (rerankTimer) clearTimeout(rerankTimer); });
+
+        // Adaptive reranker blend (Codex recommendation):
+        // When BM25/text signals are strong, trust them more; when weak, lean on reranker.
+        const bm25Max = Math.max(...rerankPool.map(r => r.phaseScores.textMatch));
+        const rerankWeight = Math.min(0.7, Math.max(0.3, 0.3 + 0.4 * (1 - bm25Max)));
+        const compositeWeight = 1 - rerankWeight;
+
+        for (const rr of rerankResults) {
+          const item = rerankPool[rr.index];
+          item.phaseScores.rerankerScore = rr.score;
+          item.score = compositeWeight * item.phaseScores.composite + rerankWeight * rr.score;
+        }
+      } catch {
+        // Re-ranker unavailable — keep original scores
+      }
+    }
+
+    // Phase 8: Multi-channel OOD detection + agreement gate
+    // Requires at least 2 of 3 retrieval channels to agree the query is in-domain.
+    if (rerankPool.length >= 3) {
+      // Abstention gate scope (2026-06-16): the in-domain channel maxes used to be taken
+      // over the ENTIRE rerankPool. Once that pool was widened for recall (pool 40), a lone
+      // high-scoring distractor inflated the maxes and defeated abstention on adversarial
+      // queries (adversarial 73.4→71.0). Fix: judge in-domain on the post-rerank TOP-K —
+      // the items we'd actually return — so pool width (recall) is decoupled from the
+      // abstention decision (precision). AWM_ABSTAIN_GATE_K controls K (0 = legacy
+      // whole-pool behavior). Answerable queries are unaffected: the gold is in the top-K
+      // and supplies the in-domain signal; only borderline distractors deep in a wide pool
+      // stop counting.
+      // Default 5 (2026-06-16): judge in-domain on the post-rerank top-5. With the widened
+      // rerank pool, basing it on the whole pool (legacy AWM_ABSTAIN_GATE_K=0) let a lone
+      // deep distractor defeat abstention; top-5 restored adversarial 71.0→74.9 (ABOVE the
+      // pre-widening 73.4) at ZERO recall cost (answerable categories unchanged) — the
+      // precision half of the two-dial pool-widening win.
+      const gateK = Number(process.env.AWM_ABSTAIN_GATE_K ?? 5);
+      const gatePool = gateK > 0
+        ? [...rerankPool].sort((a, b) => b.score - a.score).slice(0, gateK)
+        : rerankPool;
+
+      const topBM25 = Math.max(...gatePool.map(r => bm25ScoreMap.get(r.engram.id) ?? 0));
+      const topVector = queryEmbedding
+        ? Math.max(...gatePool.map(r => r.phaseScores.vectorMatch))
+        : 0;
+      const topReranker = Math.max(...gatePool.map(r => r.phaseScores.rerankerScore));
+
+      const bm25Ok = topBM25 > 0.3;
+      const vectorOk = topVector > 0.05;
+      const rerankerOk = topReranker > 0.25;
+      const channelsAgreeing = (bm25Ok ? 1 : 0) + (vectorOk ? 1 : 0) + (rerankerOk ? 1 : 0);
+
+      const rerankerScores = gatePool
+        .map(r => r.phaseScores.rerankerScore)
+        .sort((a, b) => b - a);
+      const margin = rerankerScores.length >= 2
+        ? rerankerScores[0] - rerankerScores[1]
+        : rerankerScores[0];
+
+      const cosineSimValues = Array.from(rawCosineSims.values());
+      const maxRawCosine = queryEmbedding && cosineSimValues.length > 0
+        ? Math.max(...cosineSimValues)
+        : 1.0;
+
+      // Required-channels for hard abstention:
+      //   abstention-explicit (caller passed abstentionThreshold > 0): 3 of 3
+      //   default: 2 of 3 — precision-first
+      const requiredChannels = abstentionThreshold > 0 ? 3 : 2;
+
+      // Hard abstention: fewer than required channels agree AND semantic match weak.
+      // After the 2.0.x vector refactor we no longer compute z-score; threshold
+      // on raw cosine against the mode floor (targeted=0.50, exploratory=0.35).
+      const semanticFloor = adaptive.zScoreGate > 0.5 ? 0.50 : 0.35;
+      if (channelsAgreeing < requiredChannels && maxRawCosine < semanticFloor) {
+        return [];
+      }
+
+      // Soft penalty: only 1 channel agrees or margin is thin
+      if (channelsAgreeing < 2 || margin < 0.05) {
+        if (abstentionThreshold > 0) {
+          return [];
+        }
+        for (const item of rerankPool) {
+          item.score *= 0.4;
+        }
+      }
+    }
+
+    // Legacy abstention gate (when explicitly requested)
+    if (abstentionThreshold > 0 && rerankPool.length >= 3) {
+      const topRerankerScores = rerankPool
+        .map(r => r.phaseScores.rerankerScore)
+        .sort((a, b) => b - a)
+        .slice(0, 5);
+      const maxScore = topRerankerScores[0];
+      const meanScore = topRerankerScores.reduce((s, v) => s + v, 0) / topRerankerScores.length;
+      const variance = topRerankerScores.reduce((s, v) => s + (v - meanScore) ** 2, 0) / topRerankerScores.length;
+
+      if (maxScore < abstentionThreshold || (maxScore < 0.5 && variance < 0.01)) {
+        return [];
+      }
+    }
+
+    // Phase 8c: Supersession penalty — superseded memories are deprioritized.
+    // They aren't wrong (that's retraction), just outdated.
+    for (const item of rerankPool) {
+      if (item.engram.supersededBy) {
+        item.score *= 0.15; // Severe down-rank — successor should dominate
+      }
+    }
+
+    // Phase 9: Final sort, limit, explain, attach confidence
+    const finalRanked = rerankPool.sort((a, b) => b.score - a.score);
+    const topScoresForConfidence = finalRanked.slice(0, 10).map(r => r.score);
+    const { confidence } = computeRecallConfidence(topScoresForConfidence);
+
+    // Opt-in confidence-based abstention. When the caller sets
+    // `requireConfidence`, we return [] if the score-distribution shape
+    // indicates a low-quality recall (noisy or best-of-bad-bunch).
+    // Independent of the channel-agreement abstention earlier — that path
+    // requires the reranker; this one uses just the final composite scores.
+    if (requireConfidence > 0 && confidence < requireConfidence) {
+      return [];
+    }
+
+    // Confidence-adaptive output granularity (Paper 3: cognitive teaming).
+    // 'full'    → no summary (default, current behavior).
+    // 'compact' → every result gets a short summary (COMPACT_LEN chars).
+    // 'auto'    → if confidence ≥ AUTO_THRESHOLD: top result gets a full-length
+    //             summary, lower-ranked results get compact summaries. If
+    //             confidence is lower, all results get compact summaries.
+    const granularity = query.granularity ?? 'full';
+    const COMPACT_LEN = Number(process.env.AWM_GRANULARITY_COMPACT_LEN ?? 200);
+    const FULL_LEN = Number(process.env.AWM_GRANULARITY_FULL_LEN ?? 1000);
+    const AUTO_THRESHOLD = Number(process.env.AWM_GRANULARITY_AUTO_THRESHOLD ?? 0.4);
+
+    // Snippet token list — reuse the activation queryTokens (Set<string>),
+    // filtered to ≥2 chars to drop noise. queryTokens was tokenized at line
+    // 273 via tokenize() with stopword stripping already applied.
+    const snippetTokens = Array.from(queryTokens).filter(t => t.length >= 2);
+
+    // Find the densest window of `len` chars in `content` that contains the
+    // most query-token matches. Falls back to head if no tokens match.
+    const summaryFor = (content: string, len: number): string => {
+      if (content.length <= len) return content;
+      if (snippetTokens.length === 0) return content.slice(0, len).trimEnd() + '…';
+
+      const lower = content.toLowerCase();
+      const hits: number[] = [];
+      for (const tok of snippetTokens) {
+        let from = 0;
+        while (true) {
+          const idx = lower.indexOf(tok, from);
+          if (idx < 0) break;
+          hits.push(idx);
+          from = idx + tok.length;
+        }
+      }
+      if (hits.length === 0) return content.slice(0, len).trimEnd() + '…';
+      hits.sort((a, b) => a - b);
+
+      // Find the window of size `len` that contains the most hits, by
+      // sliding a window anchored on each hit.
+      let bestStart = hits[0];
+      let bestCount = 0;
+      for (let i = 0; i < hits.length; i++) {
+        const start = Math.max(0, hits[i] - Math.floor(len / 4));
+        let count = 0;
+        for (let j = i; j < hits.length; j++) {
+          if (hits[j] - start < len) count++;
+          else break;
+        }
+        if (count > bestCount) {
+          bestCount = count;
+          bestStart = start;
+        }
+      }
+
+      // Reserve characters for the ellipses we're about to add so the final
+      // string stays within `len`. Without this, both '…' prefix + suffix
+      // would push the snippet to len+2 chars.
+      const hasPrefix = bestStart > 0;
+      const tentativeEnd = Math.min(content.length, bestStart + len);
+      const hasSuffix = tentativeEnd < content.length;
+      const reserveForEllipses = (hasPrefix ? 1 : 0) + (hasSuffix ? 1 : 0);
+      const bodyLen = Math.max(0, len - reserveForEllipses);
+      const end = Math.min(content.length, bestStart + bodyLen);
+      const startAdj = Math.max(0, end - bodyLen);
+      let snippet = content.slice(startAdj, end);
+      if (startAdj > 0) snippet = '…' + snippet.trimStart();
+      if (end < content.length) snippet = snippet.trimEnd() + '…';
+      return snippet;
+    };
+
+    const results: ActivationResult[] = finalRanked
+      .slice(0, limit)
+      .map((r, idx) => {
+        let summary: string | undefined;
+        if (granularity === 'compact') {
+          summary = summaryFor(r.engram.content, COMPACT_LEN);
+        } else if (granularity === 'auto') {
+          if (confidence >= AUTO_THRESHOLD && idx === 0) {
+            summary = summaryFor(r.engram.content, FULL_LEN);
+          } else {
+            summary = summaryFor(r.engram.content, COMPACT_LEN);
+          }
+        }
+        return {
+          engram: r.engram,
+          score: r.score,
+          phaseScores: r.phaseScores,
+          why: this.explain(r.phaseScores, r.engram, r.associations),
+          associations: r.associations,
+          confidence,
+          ...(summary !== undefined && { summary }),
+        };
+      });
+
+    const activatedIds = results.map(r => r.engram.id);
+
+    // Side effects: touch, co-activate, defer Hebbian to validation gate (skip for internal/system calls)
+    if (!query.internal) {
+      for (const id of activatedIds) {
+        await this.store.touchEngram(id);
+      }
+      this.coActivationBuffer.pushBatch(activatedIds);
+      // Validation-gated Hebbian: defer strengthening until feedback arrives
+      const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
+      const seen = new Set<string>();
+      const uniquePairs: [string, string][] = [];
+      for (const [a, b] of pairs) {
+        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+        if (!seen.has(key)) { seen.add(key); uniquePairs.push([a, b]); }
+      }
+      this.validationGate.addPending(activatedIds, uniquePairs);
+
+      // Log activation event for eval
+      const latencyMs = performance.now() - startTime;
+      await this.store.logActivationEvent({
+        id: randomUUID(),
+        agentId: query.agentId,
+        timestamp: new Date(),
+        context: query.context,
+        resultsReturned: results.length,
+        topScore: results.length > 0 ? results[0].score : 0,
+        latencyMs,
+        engramIds: activatedIds,
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * Multi-graph traversal (MAGMA-inspired).
+   *
+   * Instead of one beam search over all edge types, runs independent traversals
+   * per graph type with specialized scoring, then fuses the boosts.
+   *
+   * Four sub-graphs:
+   * - Semantic (connection + hebbian edges) → standard weight-based walk
+   * - Temporal (temporal edges) → recency-weighted (favor recent connections)
+   * - Causal (causal edges) → full weight walk (causal links are high-value)
+   * - Entity (bridge edges) → entity-tag-weighted walk
+   *
+   * Each sub-graph contributes independently to the final graph boost,
+   * weighted by configurable per-graph weights.
+   */
+  private static readonly GRAPH_WEIGHTS = {
+    semantic: 0.40,   // connection + hebbian
+    temporal: 0.20,   // temporal edges
+    causal: 0.25,     // causal edges (high-value signal)
+    entity: 0.15,     // bridge edges
+  };
+
+  private async graphWalk(
+    scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
+    maxDepth: number,
+    hopPenalty: number,
+    beamWidth: number = 15
+  ): Promise<void> {
+    const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
+    const MAX_TOTAL_BOOST = 0.25;
+
+    // Define which edge types belong to each sub-graph
+    const graphTypes: Record<string, string[]> = {
+      semantic: ['connection', 'hebbian'],
+      temporal: ['temporal'],
+      causal: ['causal'],
+      entity: ['bridge'],
+    };
+
+    // Run independent traversals per sub-graph, accumulate boosts
+    const boostAccum = new Map<string, number>(); // engramId → total boost
+
+    for (const [graphName, edgeTypes] of Object.entries(graphTypes)) {
+      const graphWeight = ActivationEngine.GRAPH_WEIGHTS[graphName as keyof typeof ActivationEngine.GRAPH_WEIGHTS];
+      const subBeamWidth = Math.max(3, Math.ceil(beamWidth * graphWeight));
+
+      // Seed beam
+      const beam = scored
+        .filter(item => item.phaseScores.textMatch >= 0.15)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, subBeamWidth);
+
+      const explored = new Set<string>();
+
+      for (let depth = 0; depth < maxDepth; depth++) {
+        const nextBeam: typeof beam = [];
+
+        for (const item of beam) {
+          if (explored.has(item.engram.id)) continue;
+          explored.add(item.engram.id);
+
+          const associations = item.associations.length > 0
+            ? item.associations
+            : await this.store.getAssociationsFor(item.engram.id);
+
+          // Filter to only edges of this sub-graph type
+          const relevantEdges = associations.filter(a => edgeTypes.includes(a.type));
+
+          for (const assoc of relevantEdges) {
+            const neighborId = assoc.fromEngramId === item.engram.id
+              ? assoc.toEngramId
+              : assoc.fromEngramId;
+
+            if (explored.has(neighborId)) continue;
+            const neighbor = scoreMap.get(neighborId);
+            if (!neighbor) continue;
+
+            const relevanceFloor = depth === 0 ? 0.1 : 0.05;
+            if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
+
+            // Path score with graph-type-specific weighting
+            const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
+            let pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
+
+            // Causal edges get a 2x boost — they represent verified reasoning chains
+            if (graphName === 'causal') pathScore *= 2.0;
+
+            // Weight by sub-graph importance
+            const boost = Math.min(pathScore * graphWeight, 0.15);
+            if (boost > 0.001) {
+              boostAccum.set(neighborId, (boostAccum.get(neighborId) ?? 0) + boost);
+              nextBeam.push(neighbor);
+            }
+          }
+        }
+
+        if (nextBeam.length === 0) break;
+        beam.length = 0;
+        beam.push(...nextBeam
+          .sort((a, b) => b.score - a.score)
+          .slice(0, subBeamWidth)
+        );
+      }
+    }
+
+    // Apply fused boosts to scored items
+    for (const [engramId, totalBoost] of boostAccum) {
+      const item = scoreMap.get(engramId);
+      if (!item) continue;
+      const capped = Math.min(totalBoost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
+      if (capped > 0.001) {
+        item.score += capped;
+        item.phaseScores.graphBoost += capped;
+      }
+    }
+  }
+
+  /**
+   * R2 — bounded iterative spreading activation (PPR / SYNAPSE-style).
+   *
+   * Default-OFF (`AWM_SPREAD=1`). The principled, in-AWM successor to the
+   * fixed depth-2 beam `graphWalk` and the MWA harness bridge: it runs T
+   * iterations of **fan-normalized** spreading with **lateral inhibition** and
+   * a **restart** term (Personalized PageRank) over the association graph —
+   * richest when R1's `AWM_BROAD_EDGES` entity edges are present.
+   *
+   * Two effects, both precision-guarded:
+   *  - **Boost** existing pool candidates by the *graph evidence* they receive
+   *    (convergent multi-path activation, not a single spurious hop).
+   *  - **Inject** (`AWM_SPREAD_INJECT=1`) strongly-reached *out-of-pool*
+   *    engrams as recall-only candidates so the reranker can see true
+   *    multi-hop bridges that BM25/vector missed. Their composite carries the
+   *    graph-activation signal (blended with rerank), which is what lets a
+   *    vocab-mismatched bridge surface where the prior `AWM_ENTITY_FETCH`
+   *    recall-only injection (rerank-only) could not.
+   *
+   * Precision is preserved because spreading is **seeded by the initial
+   * retrieval**: adversarial "is this even in memory?" queries have weak/empty
+   * seeds, so nothing meaningful propagates and abstention is unaffected.
+   * Fan-normalization stops hubs from flooding; lateral inhibition keeps only
+   * the top-M activated nodes per step; a node budget bounds cost; injected
+   * candidates stay rerank-gated and the pool-level OOD agreement gate is
+   * unaffected (seeds still supply the BM25/vector channels).
+   */
+  private async spreadActivation(
+    topN: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
+  ): Promise<void> {
+    const T = Number(process.env.AWM_SPREAD_ITERS ?? 3);
+    const delta = Number(process.env.AWM_SPREAD_DAMPING ?? 0.5);
+    const NODE_BUDGET = Number(process.env.AWM_SPREAD_BUDGET ?? 64);
+    const BOOST_SCALE = Number(process.env.AWM_SPREAD_BOOST ?? 0.4);
+    const PER_NODE_CAP = 0.15;
+    const MAX_TOTAL_BOOST = 0.25;
+    const inject = process.env.AWM_SPREAD_INJECT === '1';
+    const INJECT_THRESHOLD = Number(process.env.AWM_SPREAD_INJECT_MIN ?? 0.08);
+    const INJECT_BUDGET = Number(process.env.AWM_SPREAD_INJECT_CAP ?? 8);
+    const INJECT_SCALE = Number(process.env.AWM_SPREAD_INJECT_SCALE ?? 1.0);
+    const EPS = 0.01;
+    // 'invalidation' edges link superseded→replacement; excluded so spreading
+    // never pulls stale facts back in.
+    const allowed = new Set(['connection', 'hebbian', 'temporal', 'causal', 'bridge']);
+
+    const scoreMap = new Map(topN.map(s => [s.engram.id, s]));
+
+    // Seed activation from query-relevant candidates (textMatch gate), normalized to [0,1].
+    const seed = new Map<string, number>();
+    let maxSeed = 0;
+    for (const item of topN) {
+      if (item.phaseScores.textMatch >= 0.15) {
+        const v = Math.max(0, item.score);
+        seed.set(item.engram.id, v);
+        if (v > maxSeed) maxSeed = v;
+      }
+    }
+    if (seed.size === 0 || maxSeed <= 0) return;
+    for (const [k, v] of seed) seed.set(k, v / maxSeed);
+
+    const edgeCache = new Map<string, Association[]>();
+    const getEdges = async (id: string): Promise<Association[]> => {
+      let e = edgeCache.get(id);
+      if (!e) {
+        e = (await this.store.getAssociationsFor(id)).filter(a => allowed.has(a.type));
+        edgeCache.set(id, e);
+      }
+      return e;
+    };
+
+    let act = new Map(seed);
+    // Cumulative inflow received from the graph (excludes a node's own seed) —
+    // this is the multi-hop "evidence" signal used for boost + injection.
+    const graphActivation = new Map<string, number>();
+
+    for (let t = 0; t < T; t++) {
+      const inflow = new Map<string, number>();
+      for (const [u, au] of act) {
+        if (au <= EPS) continue;
+        const edges = await getEdges(u);
+        if (edges.length === 0) continue;
+        let fan = 0;
+        for (const e of edges) fan += Math.max(0, e.weight);
+        if (fan <= 0) continue;
+        for (const e of edges) {
+          const v = e.fromEngramId === u ? e.toEngramId : e.fromEngramId;
+          const share = Math.max(0, e.weight) / fan; // fan-effect normalization
+          inflow.set(v, (inflow.get(v) ?? 0) + au * share);
+        }
+      }
+      // D11: SYNAPSE-style lateral inhibition (divisive normalization) — competing
+      // receivers suppress each other WITHIN an iteration: a node keeps its inflow in
+      // proportion to how much of the iteration's total it earned, so a few strongly-
+      // reached nodes stay strong while diffuse spread mass is crushed. This is the
+      // published fix for the displacing-gold regression that parked AWM_SPREAD.
+      // λ=0 (default) disables; enable for the re-test with AWM_SPREAD_INHIBIT=0.3.
+      const INHIBIT = Number(process.env.AWM_SPREAD_INHIBIT ?? 0);
+      if (INHIBIT > 0 && inflow.size > 1) {
+        let total = 0;
+        for (const f of inflow.values()) total += f;
+        for (const [v, f] of inflow) inflow.set(v, f * (f / (f + INHIBIT * (total - f))));
+      }
+      for (const [v, f] of inflow) graphActivation.set(v, (graphActivation.get(v) ?? 0) + f);
+
+      // Restart (PPR): blend propagated inflow with the original seed vector.
+      const newAct = new Map<string, number>();
+      const keys = new Set<string>([...act.keys(), ...inflow.keys()]);
+      for (const v of keys) {
+        const val = (1 - delta) * (seed.get(v) ?? 0) + delta * (inflow.get(v) ?? 0);
+        if (val > EPS) newAct.set(v, val);
+      }
+      // Lateral inhibition: keep only the top-M activated nodes (competition + cost bound).
+      if (newAct.size > NODE_BUDGET) {
+        act = new Map([...newAct.entries()].sort((a, b) => b[1] - a[1]).slice(0, NODE_BUDGET));
+      } else {
+        act = newAct;
+      }
+    }
+
+    // Normalize graph evidence to [0,1] so the boost magnitude is scale-stable
+    // (raw `ga` accumulates across iterations + bidirectional edges, so its
+    // absolute scale varies with graph density). The top-reached node maps to 1.0.
+    let maxGa = 0;
+    for (const ga of graphActivation.values()) if (ga > maxGa) maxGa = ga;
+    const normGa = (id: string): number => (maxGa > 0 ? (graphActivation.get(id) ?? 0) / maxGa : 0);
+
+    if (process.env.AWM_SPREAD_DEBUG === '1') {
+      const top = [...graphActivation.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+      process.stderr.write(`[spread] seeds=${seed.size} reached=${graphActivation.size} inPool=${[...graphActivation.keys()].filter(id => scoreMap.has(id)).length} maxGa=${maxGa.toFixed(3)}\n`);
+      for (const [id, ga] of top) {
+        const e = scoreMap.get(id)?.engram;
+        process.stderr.write(`[spread]   ga=${ga.toFixed(3)} norm=${normGa(id).toFixed(2)} pool=${scoreMap.has(id)} ${e ? e.concept.slice(0, 40) : '(out-of-pool ' + id.slice(0, 8) + ')'}\n`);
+      }
+    }
+
+    // Boost existing candidates by the (normalized) graph evidence they received.
+    // Folded into `composite` (NOT just `score`) so it survives the rerank blend
+    // — the reranker recomputes score from composite, so a score-only boost would
+    // be discarded. This makes spreading a first-class multi-hop ranking signal.
+    for (const [id] of graphActivation) {
+      const item = scoreMap.get(id);
+      if (!item) continue;
+      const boost = Math.min(normGa(id) * BOOST_SCALE, PER_NODE_CAP);
+      const capped = Math.min(boost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
+      if (capped > 0.001) {
+        item.phaseScores.composite += capped;
+        item.score += capped;
+        item.phaseScores.graphBoost += capped;
+      }
+    }
+
+    // Inject strongly-reached out-of-pool engrams as recall-only candidates.
+    if (inject) {
+      const reached = [...graphActivation.entries()]
+        .filter(([id]) => !scoreMap.has(id) && normGa(id) >= INJECT_THRESHOLD)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, INJECT_BUDGET);
+      for (const [id] of reached) {
+        const engram = await this.store.getEngram(id);
+        if (!engram || engram.stage !== 'active') continue;
+        if ((engram as unknown as { retracted?: boolean }).retracted || engram.supersededBy) continue;
+        const composite = Math.min(0.6, normGa(id) * INJECT_SCALE);
+        const phaseScores: PhaseScores = {
+          textMatch: 0,
+          vectorMatch: 0,
+          decayScore: 0,
+          hebbianBoost: 0,
+          graphBoost: composite,
+          confidenceGate: engram.confidence,
+          composite,
+          rerankerScore: 0,
+        };
+        const injected = { engram, score: composite, phaseScores, associations: [] as Association[] };
+        topN.push(injected);
+        scoreMap.set(id, injected);
+      }
+    }
+  }
+
+  /**
+   * Resolve validation-gated Hebbian update for a specific engram.
+   * Called by memory_feedback — only strengthens when retrieval was useful.
+   * This prevents hub toxicity from noisy co-retrieval (Kairos-inspired).
+   */
+  async resolveHebbianFeedback(engramId: string, useful: boolean): Promise<number> {
+    const { pairs, signal } = this.validationGate.resolveFeedback(engramId, useful);
+    let updated = 0;
+
+    for (const [a, b] of pairs) {
+      const existing = (await this.store.getAssociation(a, b)) ?? (await this.store.getAssociation(b, a));
+      const currentWeight = existing?.weight ?? 0.1;
+
+      if (signal > 0) {
+        // Positive feedback → strengthen
+        const newWeight = strengthenAssociation(currentWeight, signal);
+        await this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        await this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      } else {
+        // Negative feedback → slight weakening (decay by signal magnitude)
+        const newWeight = Math.max(0.001, currentWeight * (1 + signal)); // signal is -0.3
+        await this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        await this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      }
+      updated++;
+    }
+    return updated;
+  }
+
+  private explain(phases: PhaseScores, engram: Engram, associations: Association[]): string {
+    const parts: string[] = [];
+    parts.push(`composite=${phases.composite.toFixed(3)}`);
+    if (phases.textMatch > 0) parts.push(`text=${phases.textMatch.toFixed(2)}`);
+    if (phases.vectorMatch > 0) parts.push(`vector=${phases.vectorMatch.toFixed(2)}`);
+    parts.push(`decay=${phases.decayScore.toFixed(2)}`);
+    if (phases.hebbianBoost > 0) parts.push(`hebbian=${phases.hebbianBoost.toFixed(2)}`);
+    if (phases.graphBoost > 0) parts.push(`graph=${phases.graphBoost.toFixed(2)}`);
+    if (phases.rerankerScore > 0) parts.push(`reranker=${phases.rerankerScore.toFixed(2)}`);
+    parts.push(`conf=${phases.confidenceGate.toFixed(2)}`);
+    parts.push(`access=${engram.accessCount}`);
+    if (associations.length > 0) parts.push(`edges=${associations.length}`);
+    return parts.join(' | ');
+  }
+}