@cleocode/cleo 2026.4.37 → 2026.4.39

package/dist/cli/index.js

@@ -22109,6 +22109,210 @@ var init_quality_scoring = __esm({
   }
 });
 
+// packages/core/src/store/typed-query.ts
+function typedAll(stmt, ...params) {
+  return stmt.all(...params);
+}
+function typedGet(stmt, ...params) {
+  return stmt.get(...params);
+}
+var init_typed_query = __esm({
+  "packages/core/src/store/typed-query.ts"() {
+    "use strict";
+  }
+});
+
+// packages/core/src/memory/temporal-supersession.ts
+function extractKeywords(text3) {
+  const words = text3.toLowerCase().replace(/[^a-z0-9\s\-_]/g, " ").split(/\s+/);
+  const keywords = /* @__PURE__ */ new Set();
+  for (const w2 of words) {
+    if (w2.length >= 4 && !STOP_WORDS.has(w2)) {
+      keywords.add(w2);
+    }
+  }
+  return keywords;
+}
+function keywordSimilarity(textA, textB) {
+  const kwA = extractKeywords(textA);
+  const kwB = extractKeywords(textB);
+  if (kwA.size === 0 || kwB.size === 0) return { similarity: 0, shared: [] };
+  const shared = [];
+  for (const w2 of kwA) {
+    if (kwB.has(w2)) shared.push(w2);
+  }
+  if (shared.length < MIN_SHARED_KEYWORDS) return { similarity: 0, shared: [] };
+  const union3 = kwA.size + kwB.size - shared.length;
+  const similarity = union3 > 0 ? shared.length / union3 : 0;
+  return { similarity, shared };
+}
+function buildNodeId(type, entryId) {
+  return `${type}:${entryId}`;
+}
+async function locateEntry(projectRoot, entryId) {
+  await getBrainDb(projectRoot);
+  const nativeDb = getBrainNativeDb();
+  if (!nativeDb) return null;
+  for (const tc of SUPERSEDABLE_TABLES) {
+    const row = typedGet(
+      nativeDb.prepare(`SELECT id FROM ${tc.table} WHERE id = ? LIMIT 1`),
+      entryId
+    );
+    if (row) {
+      return { tableConfig: tc, nodeId: buildNodeId(tc.type, entryId) };
+    }
+  }
+  return null;
+}
+async function supersedeMemory(projectRoot, oldId, newId, reason) {
+  if (!oldId?.trim()) throw new Error("oldId is required");
+  if (!newId?.trim()) throw new Error("newId is required");
+  if (!reason?.trim()) throw new Error("reason is required");
+  if (oldId === newId) throw new Error("oldId and newId must be different entries");
+  await getBrainDb(projectRoot);
+  const nativeDb = getBrainNativeDb();
+  if (!nativeDb) throw new Error("brain.db is unavailable");
+  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  const oldLocation = await locateEntry(projectRoot, oldId);
+  if (!oldLocation) throw new Error(`Entry not found: ${oldId}`);
+  const newLocation = await locateEntry(projectRoot, newId);
+  if (!newLocation) throw new Error(`Entry not found: ${newId}`);
+  const { tableConfig: oldTc, nodeId: oldNodeId } = oldLocation;
+  const { nodeId: newNodeId } = newLocation;
+  try {
+    nativeDb.prepare(
+      `UPDATE ${oldTc.table} SET invalid_at = ?, updated_at = ? WHERE id = ? AND invalid_at IS NULL`
+    ).run(now2, now2, oldId);
+  } catch {
+  }
+  const provenanceText = reason.substring(0, 500);
+  try {
+    nativeDb.prepare(
+      `INSERT OR IGNORE INTO brain_page_edges
+           (from_id, to_id, edge_type, weight, provenance, created_at)
+         VALUES (?, ?, 'supersedes', 1.0, ?, ?)`
+    ).run(newNodeId, oldNodeId, provenanceText, now2);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to create supersedes edge: ${message}`);
+  }
+  return {
+    success: true,
+    oldId,
+    newId,
+    edgeType: "supersedes"
+  };
+}
+async function detectSupersession(projectRoot, newEntry) {
+  try {
+    await getBrainDb(projectRoot);
+    const nativeDb = getBrainNativeDb();
+    if (!nativeDb) return [];
+    const newLocation = await locateEntry(projectRoot, newEntry.id);
+    if (!newLocation) return [];
+    const { tableConfig } = newLocation;
+    const existing = typedAll(
+      nativeDb.prepare(`
+        SELECT id, COALESCE(${tableConfig.textCol}, '') AS text,
+               created_at, quality_score
+        FROM ${tableConfig.table}
+        WHERE invalid_at IS NULL
+          AND id != ?
+        ORDER BY created_at DESC
+        LIMIT 200
+      `),
+      newEntry.id
+    );
+    if (existing.length === 0) return [];
+    const candidates = [];
+    for (const row of existing) {
+      if (row.created_at >= newEntry.createdAt) continue;
+      const { similarity, shared } = keywordSimilarity(newEntry.text, row.text);
+      if (similarity >= KEYWORD_OVERLAP_THRESHOLD) {
+        candidates.push({
+          existingId: row.id,
+          similarity,
+          table: tableConfig.table,
+          sharedKeywords: shared.slice(0, 10)
+        });
+      }
+    }
+    candidates.sort((a, b2) => b2.similarity - a.similarity);
+    return candidates;
+  } catch (err) {
+    console.warn("[temporal-supersession] detectSupersession failed:", err);
+    return [];
+  }
+}
+var KEYWORD_OVERLAP_THRESHOLD, MIN_SHARED_KEYWORDS, STOP_WORDS, SUPERSEDABLE_TABLES;
+var init_temporal_supersession = __esm({
+  "packages/core/src/memory/temporal-supersession.ts"() {
+    "use strict";
+    init_brain_sqlite();
+    init_typed_query();
+    KEYWORD_OVERLAP_THRESHOLD = 0.8;
+    MIN_SHARED_KEYWORDS = 3;
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "have",
+      "has",
+      "had",
+      "do",
+      "does",
+      "did",
+      "will",
+      "would",
+      "could",
+      "should",
+      "may",
+      "might",
+      "shall",
+      "can",
+      "to",
+      "of",
+      "in",
+      "for",
+      "on",
+      "with",
+      "at",
+      "by",
+      "from",
+      "as",
+      "into",
+      "through",
+      "and",
+      "but",
+      "or",
+      "nor",
+      "so",
+      "yet",
+      "this",
+      "that",
+      "these",
+      "those",
+      "it",
+      "its",
+      "not",
+      "no"
+    ]);
+    SUPERSEDABLE_TABLES = [
+      { table: "brain_decisions", textCol: "decision", type: "decision" },
+      { table: "brain_learnings", textCol: "insight", type: "learning" },
+      { table: "brain_patterns", textCol: "pattern", type: "pattern" },
+      { table: "brain_observations", textCol: "narrative", type: "observation" }
+    ];
+  }
+});
+
 // packages/core/src/memory/patterns.ts
 var patterns_exports = {};
 __export(patterns_exports, {
@@ -22206,6 +22410,22 @@ async function storePattern(projectRoot, params) {
     { type: saved.type, impact: saved.impact ?? void 0 }
   ).catch(() => {
   });
+  detectSupersession(projectRoot, {
+    id: saved.id,
+    text: saved.pattern + " " + saved.context,
+    createdAt: saved.extractedAt ?? (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+  }).then((candidates) => {
+    for (const candidate of candidates) {
+      supersedeMemory(
+        projectRoot,
+        candidate.existingId,
+        saved.id,
+        "auto:pattern-supersedes \u2014 high overlap detected at store time"
+      ).catch(() => {
+      });
+    }
+  }).catch(() => {
+  });
   return {
     ...saved,
     examples: JSON.parse(saved.examplesJson || "[]")
@@ -22262,6 +22482,7 @@ var init_patterns = __esm({
     init_brain_accessor();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -22353,6 +22574,22 @@ async function storeLearning(projectRoot, params) {
     { source: saved.source, confidence: saved.confidence, actionable: saved.actionable }
   ).catch(() => {
   });
+  detectSupersession(projectRoot, {
+    id: saved.id,
+    text: saved.insight,
+    createdAt: saved.createdAt ?? (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+  }).then((candidates) => {
+    for (const candidate of candidates) {
+      supersedeMemory(
+        projectRoot,
+        candidate.existingId,
+        saved.id,
+        "auto:learning-supersedes \u2014 high overlap detected at store time"
+      ).catch(() => {
+      });
+    }
+  }).catch(() => {
+  });
   return {
     ...saved,
     applicableTypes: JSON.parse(saved.applicableTypesJson || "[]")
@@ -22413,6 +22650,7 @@ var init_learnings = __esm({
     init_brain_accessor();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -22451,16 +22689,6 @@ var init_mvi_helpers = __esm({
   }
 });
 
-// packages/core/src/store/typed-query.ts
-function typedAll(stmt, ...params) {
-  return stmt.all(...params);
-}
-var init_typed_query = __esm({
-  "packages/core/src/store/typed-query.ts"() {
-    "use strict";
-  }
-});
-
 // packages/core/src/memory/brain-similarity.ts
 function parseIdPrefix(id) {
   if (id.startsWith("D-") || /^D\d/.test(id)) return "decision";
@@ -24245,6 +24473,22 @@ async function storeDecision(projectRoot, params) {
     }
   } catch {
   }
+  detectSupersession(projectRoot, {
+    id: saved.id,
+    text: saved.decision + " " + saved.rationale,
+    createdAt: saved.createdAt ?? (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+  }).then((candidates) => {
+    for (const candidate of candidates) {
+      supersedeMemory(
+        projectRoot,
+        candidate.existingId,
+        saved.id,
+        "auto:decision-supersedes \u2014 high overlap detected at store time"
+      ).catch(() => {
+      });
+    }
+  }).catch(() => {
+  });
   return saved;
 }
 async function recallDecision(projectRoot, id) {
@@ -24297,6 +24541,7 @@ var init_decisions2 = __esm({
     init_sqlite2();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -45369,11 +45614,11 @@ var brain_consolidator_exports = {};
 __export(brain_consolidator_exports, {
   detectContradictions: () => detectContradictions
 });
-function extractKeywords(text3) {
+function extractKeywords2(text3) {
   const words = text3.toLowerCase().replace(/[^a-z0-9\s\-_]/g, " ").split(/\s+/);
   const keywords = /* @__PURE__ */ new Set();
   for (const w2 of words) {
-    if (w2.length >= 4 && !STOP_WORDS.has(w2)) {
+    if (w2.length >= 4 && !STOP_WORDS2.has(w2)) {
       keywords.add(w2);
     }
   }
@@ -45422,7 +45667,7 @@ async function detectContradictions(projectRoot) {
     const keywordMap = /* @__PURE__ */ new Map();
     const negationMap = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      keywordMap.set(entry.id, extractKeywords(entry.text));
+      keywordMap.set(entry.id, extractKeywords2(entry.text));
       negationMap.set(entry.id, findNegationMarkers(entry.text));
     }
     for (let i = 0; i < entries.length; i++) {
@@ -45436,7 +45681,7 @@ async function detectContradictions(projectRoot) {
         const keywordsB = keywordMap.get(entryB.id);
         const negationsB = negationMap.get(entryB.id);
         const shared = keywordIntersection(keywordsA, keywordsB);
-        if (shared.length < MIN_SHARED_KEYWORDS) continue;
+        if (shared.length < MIN_SHARED_KEYWORDS2) continue;
         const negationsOnlyInA = negationsA.filter((m2) => !negationsB.includes(m2));
         const negationsOnlyInB = negationsB.filter((m2) => !negationsA.includes(m2));
         const negationFlip = negationsOnlyInA.length > 0 || negationsOnlyInB.length > 0;
@@ -45454,8 +45699,8 @@ async function detectContradictions(projectRoot) {
           sharedKeywords: shared.slice(0, 10),
           negationMarkers: negMarkers.slice(0, 5)
         });
-        const nodeA = buildNodeId(table, entryA.id);
-        const nodeB = buildNodeId(table, entryB.id);
+        const nodeA = buildNodeId2(table, entryA.id);
+        const nodeB = buildNodeId2(table, entryB.id);
         try {
           nativeDb.prepare(`
               INSERT OR IGNORE INTO brain_page_edges
@@ -45484,7 +45729,7 @@ async function detectContradictions(projectRoot) {
   }
   return results;
 }
-function buildNodeId(table, entryId) {
+function buildNodeId2(table, entryId) {
   const typeMap = {
     brain_observations: "observation",
     brain_learnings: "learning",
@@ -45494,13 +45739,13 @@ function buildNodeId(table, entryId) {
   const type = typeMap[table] ?? "entry";
   return `${type}:${entryId}`;
 }
-var MIN_SHARED_KEYWORDS, NEGATION_MARKERS, STOP_WORDS;
+var MIN_SHARED_KEYWORDS2, NEGATION_MARKERS, STOP_WORDS2;
 var init_brain_consolidator = __esm({
   "packages/core/src/memory/brain-consolidator.ts"() {
     "use strict";
     init_brain_sqlite();
     init_typed_query();
-    MIN_SHARED_KEYWORDS = 3;
+    MIN_SHARED_KEYWORDS2 = 3;
     NEGATION_MARKERS = [
       "not",
       "never",
@@ -45521,7 +45766,7 @@ var init_brain_consolidator = __esm({
       "undone",
       "superseded"
     ];
-    STOP_WORDS = /* @__PURE__ */ new Set([
+    STOP_WORDS2 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -45576,6 +45821,390 @@ var init_brain_consolidator = __esm({
   }
 });
 
+// packages/core/src/memory/graph-memory-bridge.ts
+var graph_memory_bridge_exports = {};
+__export(graph_memory_bridge_exports, {
+  autoLinkMemories: () => autoLinkMemories,
+  linkMemoryToCode: () => linkMemoryToCode,
+  listCodeLinks: () => listCodeLinks,
+  queryCodeForMemory: () => queryCodeForMemory,
+  queryMemoriesForCode: () => queryMemoriesForCode
+});
+function extractFilePaths(text3) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const m2 of text3.matchAll(FILE_PATH_PATTERN)) {
+    const p2 = m2[1];
+    if (p2) paths.add(p2);
+  }
+  return Array.from(paths);
+}
+function extractSymbolCandidates(text3) {
+  const syms = /* @__PURE__ */ new Set();
+  for (const m2 of text3.matchAll(SYMBOL_PATTERN)) {
+    const s3 = m2[1];
+    if (s3 && s3.length >= 4 && !SYMBOL_STOP_WORDS.has(s3.toLowerCase())) {
+      syms.add(s3);
+    }
+  }
+  return Array.from(syms);
+}
+function metadataText(metaJson) {
+  if (!metaJson) return "";
+  try {
+    const obj = JSON.parse(metaJson);
+    return Object.values(obj).filter((v2) => typeof v2 === "string").join(" ");
+  } catch {
+    return "";
+  }
+}
+async function linkMemoryToCode(projectRoot, memoryId, codeSymbol) {
+  try {
+    const brainDb = await getBrainDb(projectRoot);
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!nexusNative) return false;
+    const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(codeSymbol);
+    if (!nexusNode) return false;
+    const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const idParts = memoryId.split(":");
+    const nodeType = idParts[0] ?? "observation";
+    await brainDb.insert(brainPageNodes).values({
+      id: memoryId,
+      nodeType,
+      label: memoryId,
+      qualityScore: 0.5,
+      contentHash: null,
+      lastActivityAt: now2,
+      createdAt: now2,
+      updatedAt: now2
+    }).onConflictDoUpdate({
+      target: brainPageNodes.id,
+      set: { lastActivityAt: now2, updatedAt: now2 }
+    });
+    await brainDb.insert(brainPageEdges).values({
+      fromId: memoryId,
+      toId: codeSymbol,
+      edgeType: "code_reference",
+      weight: 1,
+      provenance: "manual",
+      createdAt: now2
+    }).onConflictDoNothing();
+    return true;
+  } catch (err) {
+    console.warn("[graph-memory-bridge] linkMemoryToCode failed:", err);
+    return false;
+  }
+}
+async function autoLinkMemories(projectRoot) {
+  const result = { scanned: 0, linked: 0, alreadyLinked: 0, links: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainNodes = typedAll(
+      brainNative.prepare(`
+        SELECT id, node_type, label, quality_score, metadata_json
+        FROM brain_page_nodes
+        WHERE node_type IN ('observation', 'decision', 'pattern', 'learning')
+          AND quality_score >= 0.3
+        ORDER BY quality_score DESC
+        LIMIT 500
+      `)
+    );
+    result.scanned = brainNodes.length;
+    if (brainNodes.length === 0) return result;
+    const nexusNodes2 = typedAll(
+      nexusNative.prepare(`
+        SELECT id, label, name, file_path, kind
+        FROM nexus_nodes
+        WHERE kind NOT IN ('community', 'process', 'folder')
+        LIMIT 20000
+      `)
+    );
+    if (nexusNodes2.length === 0) return result;
+    const byFilePath = /* @__PURE__ */ new Map();
+    const byNameExact = /* @__PURE__ */ new Map();
+    const byNameLower = /* @__PURE__ */ new Map();
+    for (const node of nexusNodes2) {
+      if (node.file_path) {
+        const fp = node.file_path.toLowerCase();
+        const existing = byFilePath.get(fp) ?? [];
+        existing.push(node);
+        byFilePath.set(fp, existing);
+      }
+      if (node.name) {
+        const exact = byNameExact.get(node.name) ?? [];
+        exact.push(node);
+        byNameExact.set(node.name, exact);
+        const lower = node.name.toLowerCase();
+        const fuzzy = byNameLower.get(lower) ?? [];
+        fuzzy.push(node);
+        byNameLower.set(lower, fuzzy);
+      }
+    }
+    const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const existingEdges = /* @__PURE__ */ new Set();
+    const rawEdges = typedAll(
+      brainNative.prepare(`
+        SELECT from_id, to_id FROM brain_page_edges WHERE edge_type = 'code_reference'
+      `)
+    );
+    for (const e of rawEdges) {
+      existingEdges.add(`${e.from_id}|${e.to_id}`);
+    }
+    for (const brainNode of brainNodes) {
+      const corpus = `${brainNode.label} ${metadataText(brainNode.metadata_json)}`;
+      const filePaths = extractFilePaths(corpus);
+      const symbolCandidates = extractSymbolCandidates(corpus);
+      const candidates = [];
+      for (const fp of filePaths) {
+        const matches = byFilePath.get(fp.toLowerCase());
+        if (matches) {
+          for (const n of matches) {
+            candidates.push({ nexusNode: n, strategy: "exact-file", weight: 1 });
+          }
+        }
+      }
+      for (const sym of symbolCandidates) {
+        const exactMatches = byNameExact.get(sym);
+        if (exactMatches) {
+          for (const n of exactMatches) {
+            candidates.push({ nexusNode: n, strategy: "exact-symbol", weight: 1 });
+          }
+        }
+      }
+      const exactSymSet = new Set(
+        symbolCandidates.flatMap((s3) => byNameExact.get(s3) ?? []).map((n) => n.id)
+      );
+      for (const sym of symbolCandidates) {
+        if (sym.length < 5) continue;
+        const lower = sym.toLowerCase();
+        const fuzzyMatches = byNameLower.get(lower);
+        if (fuzzyMatches) {
+          for (const n of fuzzyMatches) {
+            if (!exactSymSet.has(n.id)) {
+              candidates.push({ nexusNode: n, strategy: "fuzzy-symbol", weight: 0.6 });
+            }
+          }
+        }
+      }
+      const bestByNexusId = /* @__PURE__ */ new Map();
+      for (const c of candidates) {
+        const existing = bestByNexusId.get(c.nexusNode.id);
+        if (!existing || c.weight > existing.weight) {
+          bestByNexusId.set(c.nexusNode.id, c);
+        }
+      }
+      const sortedCandidates = Array.from(bestByNexusId.values()).sort((a, b2) => b2.weight - a.weight).slice(0, 10);
+      for (const { nexusNode, strategy, weight } of sortedCandidates) {
+        const edgeKey = `${brainNode.id}|${nexusNode.id}`;
+        if (existingEdges.has(edgeKey)) {
+          result.alreadyLinked++;
+          continue;
+        }
+        brainNative.prepare(`
+            INSERT OR IGNORE INTO brain_page_nodes
+              (id, node_type, label, quality_score, content_hash, metadata_json, last_activity_at, created_at, updated_at)
+            VALUES (?, ?, ?, ?, NULL, NULL, ?, ?, ?)
+          `).run(
+          brainNode.id,
+          brainNode.node_type,
+          brainNode.label,
+          brainNode.quality_score,
+          now2,
+          now2,
+          now2
+        );
+        try {
+          brainNative.prepare(`
+              INSERT OR IGNORE INTO brain_page_edges
+                (from_id, to_id, edge_type, weight, provenance, created_at)
+              VALUES (?, ?, 'code_reference', ?, ?, ?)
+            `).run(brainNode.id, nexusNode.id, weight, `auto:${strategy}`, now2);
+          existingEdges.add(edgeKey);
+          result.linked++;
+          result.links.push({
+            brainNodeId: brainNode.id,
+            nexusNodeId: nexusNode.id,
+            nexusLabel: nexusNode.label,
+            matchStrategy: strategy,
+            weight
+          });
+        } catch (edgeErr) {
+          console.warn("[graph-memory-bridge] edge insert failed:", edgeErr);
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] autoLinkMemories failed:", err);
+  }
+  return result;
+}
+async function queryMemoriesForCode(projectRoot, symbol2) {
+  const result = { nexusNodeId: symbol2, memories: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    if (!brainNative) return result;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT n.id, n.node_type, n.label, n.quality_score,
+               e.weight, e.provenance
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.to_id = ?
+          AND e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, n.quality_score DESC
+        LIMIT 50
+      `),
+      symbol2
+    );
+    result.memories = rows.map((r) => ({
+      nodeId: r.id,
+      nodeType: r.node_type,
+      label: r.label,
+      qualityScore: r.quality_score,
+      edgeWeight: r.weight,
+      matchStrategy: r.provenance?.replace("auto:", "") ?? "manual"
+    }));
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryMemoriesForCode failed:", err);
+  }
+  return result;
+}
+async function queryCodeForMemory(projectRoot, memoryId) {
+  const result = { brainNodeId: memoryId, codeNodes: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainEdges = typedAll(
+      brainNative.prepare(`
+        SELECT to_id, weight, provenance
+        FROM brain_page_edges
+        WHERE from_id = ?
+          AND edge_type = 'code_reference'
+        ORDER BY weight DESC
+        LIMIT 50
+      `),
+      memoryId
+    );
+    if (brainEdges.length === 0) return result;
+    for (const edge of brainEdges) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(edge.to_id);
+      if (nexusNode) {
+        result.codeNodes.push({
+          nexusNodeId: nexusNode.id,
+          label: nexusNode.label,
+          filePath: nexusNode.file_path,
+          kind: nexusNode.kind,
+          edgeWeight: edge.weight,
+          matchStrategy: edge.provenance?.replace("auto:", "") ?? "manual"
+        });
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryCodeForMemory failed:", err);
+  }
+  return result;
+}
+async function listCodeLinks(projectRoot, limit = 100) {
+  const entries = [];
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return entries;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT e.from_id, e.to_id, e.weight, e.created_at,
+               n.node_type, n.label
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, e.created_at DESC
+        LIMIT ?
+      `),
+      limit
+    );
+    for (const row of rows) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(row.to_id);
+      entries.push({
+        brainNodeId: row.from_id,
+        brainNodeType: row.node_type,
+        brainNodeLabel: row.label,
+        nexusNodeId: row.to_id,
+        nexusNodeLabel: nexusNode?.label ?? row.to_id,
+        filePath: nexusNode?.file_path ?? null,
+        kind: nexusNode?.kind ?? "unknown",
+        weight: row.weight,
+        createdAt: row.created_at
+      });
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] listCodeLinks failed:", err);
+  }
+  return entries;
+}
+var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS;
+var init_graph_memory_bridge = __esm({
+  "packages/core/src/memory/graph-memory-bridge.ts"() {
+    "use strict";
+    init_brain_schema();
+    init_brain_sqlite();
+    init_nexus_sqlite();
+    init_typed_query();
+    FILE_PATH_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_\-./]+\.(?:ts|tsx|js|jsx|rs|go|py|mjs|cjs))(?:$|\s|['"`)])/g;
+    SYMBOL_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*(?:[A-Z][a-zA-Z0-9_]*)+|[a-zA-Z_]{4,}[a-zA-Z0-9_]*)\b/g;
+    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "const",
+      "async",
+      "await",
+      "return",
+      "export",
+      "import",
+      "from",
+      "type",
+      "interface",
+      "function",
+      "class",
+      "this",
+      "super",
+      "extends",
+      "implements",
+      "with",
+      "that",
+      "then",
+      "when",
+      "have",
+      "been",
+      "will",
+      "should",
+      "could",
+      "would",
+      "error",
+      "result",
+      "value",
+      "data",
+      "info",
+      "note",
+      "todo",
+      "done",
+      "fail",
+      "pass"
+    ]);
+  }
+});
+
 // packages/core/src/memory/brain-lifecycle.ts
 var brain_lifecycle_exports = {};
 __export(brain_lifecycle_exports, {
@@ -45609,11 +46238,11 @@ async function applyTemporalDecay(projectRoot, options) {
     tablesProcessed: ["brain_learnings"]
   };
 }
-function extractKeywords2(text3) {
+function extractKeywords3(text3) {
   const words = text3.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/);
   const keywords = /* @__PURE__ */ new Set();
   for (const w2 of words) {
-    if (w2.length >= 4 && !STOP_WORDS2.has(w2)) {
+    if (w2.length >= 4 && !STOP_WORDS3.has(w2)) {
       keywords.add(w2);
     }
   }
@@ -45651,7 +46280,7 @@ async function consolidateMemories(projectRoot, options) {
   }
   const entries = oldObservations.map((obs) => ({
     ...obs,
-    keywords: extractKeywords2(`${obs.title} ${obs.narrative ?? ""}`),
+    keywords: extractKeywords3(`${obs.title} ${obs.narrative ?? ""}`),
     clustered: false
   }));
   const clusters = [];
@@ -45875,6 +46504,13 @@ async function runConsolidation(projectRoot) {
   } catch (err) {
     console.warn("[consolidation] Step 7 summary generation failed:", err);
   }
+  try {
+    const { autoLinkMemories: autoLinkMemories2 } = await Promise.resolve().then(() => (init_graph_memory_bridge(), graph_memory_bridge_exports));
+    const bridgeResult = await autoLinkMemories2(projectRoot);
+    result.graphLinksCreated = bridgeResult.linked;
+  } catch (err) {
+    console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
+  }
   return result;
 }
 async function deduplicateByEmbedding(projectRoot) {
@@ -46053,13 +46689,13 @@ async function strengthenCoRetrievedEdges(projectRoot) {
   }
   return strengthened;
 }
-var STOP_WORDS2;
+var STOP_WORDS3;
 var init_brain_lifecycle = __esm({
   "packages/core/src/memory/brain-lifecycle.ts"() {
     "use strict";
     init_brain_accessor();
     init_typed_query();
-    STOP_WORDS2 = /* @__PURE__ */ new Set([
+    STOP_WORDS3 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -46664,6 +47300,358 @@ var init_session_hooks = __esm({
   }
 });
 
+// packages/core/src/memory/quality-feedback.ts
+var quality_feedback_exports = {};
+__export(quality_feedback_exports, {
+  correlateOutcomes: () => correlateOutcomes,
+  getMemoryQualityReport: () => getMemoryQualityReport,
+  trackMemoryUsage: () => trackMemoryUsage
+});
+async function ensureUsageLogTable(projectRoot) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  if (!nativeDb) return;
+  try {
+    nativeDb.prepare(
+      `CREATE TABLE IF NOT EXISTS brain_usage_log (
+          id         INTEGER PRIMARY KEY AUTOINCREMENT,
+          entry_id   TEXT    NOT NULL,
+          task_id    TEXT,
+          used       INTEGER NOT NULL DEFAULT 0,
+          outcome    TEXT    NOT NULL DEFAULT 'unknown',
+          created_at TEXT    NOT NULL DEFAULT (datetime('now'))
+        )`
+    ).run();
+    nativeDb.prepare(
+      `CREATE INDEX IF NOT EXISTS idx_brain_usage_log_entry_id
+         ON brain_usage_log(entry_id)`
+    ).run();
+    nativeDb.prepare(
+      `CREATE INDEX IF NOT EXISTS idx_brain_usage_log_task_id
+         ON brain_usage_log(task_id)`
+    ).run();
+  } catch {
+  }
+}
+async function ensurePruneCandidateColumn(projectRoot) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  if (!nativeDb) return;
+  const tables = [
+    "brain_decisions",
+    "brain_patterns",
+    "brain_learnings",
+    "brain_observations"
+  ];
+  for (const tbl of tables) {
+    try {
+      nativeDb.prepare(`ALTER TABLE ${tbl} ADD COLUMN prune_candidate INTEGER DEFAULT 0`).run();
+    } catch {
+    }
+  }
+}
+async function trackMemoryUsage(projectRoot, memoryId, used, taskId, outcome = "unknown") {
+  if (!memoryId?.trim()) return;
+  await ensureUsageLogTable(projectRoot);
+  const { getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  const nativeDb = getBrainNativeDb2();
+  if (!nativeDb) return;
+  const now2 = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+  try {
+    nativeDb.prepare(
+      `INSERT INTO brain_usage_log (entry_id, task_id, used, outcome, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(memoryId, taskId ?? null, used ? 1 : 0, outcome, now2);
+  } catch {
+  }
+}
+function tableForId(id) {
+  if (id.startsWith("D-") || /^D\d/.test(id)) return "brain_decisions";
+  if (id.startsWith("P-") || /^P\d/.test(id)) return "brain_patterns";
+  if (id.startsWith("L-") || /^L\d/.test(id)) return "brain_learnings";
+  if (id.startsWith("O-") || id.startsWith("CM-") || /^O/.test(id)) return "brain_observations";
+  return null;
+}
+function applyQualityDelta(nativeDb, table, id, delta, now2) {
+  if (!nativeDb) return;
+  try {
+    nativeDb.prepare(
+      `UPDATE ${table}
+         SET quality_score = MAX(0.0, MIN(1.0, COALESCE(quality_score, 0.5) + ?)),
+             updated_at    = ?
+         WHERE id = ?`
+    ).run(delta, now2, id);
+  } catch {
+  }
+}
+async function correlateOutcomes(projectRoot) {
+  await ensureUsageLogTable(projectRoot);
+  await ensurePruneCandidateColumn(projectRoot);
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const ranAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!nativeDb) {
+    return { boosted: 0, penalized: 0, flaggedForPruning: 0, ranAt };
+  }
+  const now2 = ranAt.replace("T", " ").slice(0, 19);
+  let boosted = 0;
+  let penalized = 0;
+  let usageRows = [];
+  try {
+    usageRows = typedAll(
+      nativeDb.prepare(
+        `SELECT entry_id, outcome, SUM(used) AS used_count
+         FROM brain_usage_log
+         WHERE outcome IN ('success', 'failure')
+         GROUP BY entry_id, outcome`
+      )
+    );
+  } catch {
+    usageRows = [];
+  }
+  for (const row of usageRows) {
+    const table = tableForId(row.entry_id);
+    if (!table) continue;
+    if (row.outcome === "success" && row.used_count > 0) {
+      applyQualityDelta(nativeDb, table, row.entry_id, 0.05, now2);
+      boosted++;
+    } else if (row.outcome === "failure" && row.used_count > 0) {
+      applyQualityDelta(nativeDb, table, row.entry_id, -0.05, now2);
+      penalized++;
+    }
+  }
+  const cutoffDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString().replace("T", " ").slice(0, 19);
+  let flaggedForPruning = 0;
+  const pruneTargetTables = [
+    { table: "brain_decisions", dateCol: "created_at" },
+    { table: "brain_patterns", dateCol: "extracted_at" },
+    { table: "brain_learnings", dateCol: "created_at" },
+    { table: "brain_observations", dateCol: "created_at" }
+  ];
+  for (const { table, dateCol } of pruneTargetTables) {
+    try {
+      const result = nativeDb.prepare(
+        `UPDATE ${table}
+           SET prune_candidate = 1
+           WHERE COALESCE(citation_count, 0) = 0
+             AND ${dateCol} < ?`
+      ).run(cutoffDate);
+      flaggedForPruning += result.changes ?? 0;
+    } catch {
+    }
+  }
+  return { boosted, penalized, flaggedForPruning, ranAt };
+}
+async function getMemoryQualityReport(projectRoot) {
+  await ensureUsageLogTable(projectRoot);
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const emptyReport = {
+    totalRetrievals: 0,
+    uniqueEntriesRetrieved: 0,
+    usageRate: 0,
+    topRetrieved: [],
+    neverRetrieved: [],
+    qualityDistribution: { low: 0, medium: 0, high: 0 },
+    tierDistribution: { short: 0, medium: 0, long: 0, unknown: 0 },
+    noiseRatio: 0
+  };
+  if (!nativeDb) return emptyReport;
+  let totalRetrievals = 0;
+  let uniqueEntriesRetrieved = 0;
+  try {
+    const logCount = typedAll(
+      nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_retrieval_log")
+    );
+    totalRetrievals = logCount[0]?.cnt ?? 0;
+    const uniqueCount = typedAll(
+      nativeDb.prepare(
+        `SELECT COUNT(DISTINCT value) AS cnt
+         FROM brain_retrieval_log,
+              json_each('["' || replace(entry_ids, ',', '","') || '"]')`
+      )
+    );
+    uniqueEntriesRetrieved = uniqueCount[0]?.cnt ?? 0;
+  } catch {
+  }
+  let usageRate = 0;
+  try {
+    const totalUsage = typedAll(
+      nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_usage_log")
+    );
+    const usedCount = typedAll(
+      nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_usage_log WHERE used = 1")
+    );
+    const total = totalUsage[0]?.cnt ?? 0;
+    const used = usedCount[0]?.cnt ?? 0;
+    usageRate = total > 0 ? used / total : 0;
+  } catch {
+  }
+  const topRetrieved = [];
+  try {
+    const rows = typedAll(
+      nativeDb.prepare(
+        `SELECT id,
+                'decision' AS type,
+                decision    AS title,
+                COALESCE(citation_count, 0) AS citation_count
+         FROM brain_decisions
+         UNION ALL
+         SELECT id,
+                'pattern'  AS type,
+                pattern     AS title,
+                COALESCE(citation_count, 0) AS citation_count
+         FROM brain_patterns
+         UNION ALL
+         SELECT id,
+                'learning' AS type,
+                insight     AS title,
+                COALESCE(citation_count, 0) AS citation_count
+         FROM brain_learnings
+         UNION ALL
+         SELECT id,
+                'observation' AS type,
+                title         AS title,
+                COALESCE(citation_count, 0) AS citation_count
+         FROM brain_observations
+         ORDER BY citation_count DESC
+         LIMIT 10`
+      )
+    );
+    for (const r of rows) {
+      topRetrieved.push({
+        id: r.id,
+        type: r.type,
+        title: String(r.title ?? "").slice(0, 120),
+        citationCount: r.citation_count
+      });
+    }
+  } catch {
+  }
+  const neverRetrieved = [];
+  try {
+    const rows = typedAll(
+      nativeDb.prepare(
+        `SELECT id,
+                'decision' AS type,
+                decision    AS title,
+                COALESCE(quality_score, 0.5) AS quality_score
+         FROM brain_decisions
+         WHERE COALESCE(citation_count, 0) = 0
+         UNION ALL
+         SELECT id,
+                'pattern'  AS type,
+                pattern     AS title,
+                COALESCE(quality_score, 0.5) AS quality_score
+         FROM brain_patterns
+         WHERE COALESCE(citation_count, 0) = 0
+         UNION ALL
+         SELECT id,
+                'learning' AS type,
+                insight     AS title,
+                COALESCE(quality_score, 0.5) AS quality_score
+         FROM brain_learnings
+         WHERE COALESCE(citation_count, 0) = 0
+         UNION ALL
+         SELECT id,
+                'observation' AS type,
+                title         AS title,
+                COALESCE(quality_score, 0.5) AS quality_score
+         FROM brain_observations
+         WHERE COALESCE(citation_count, 0) = 0
+         ORDER BY quality_score ASC
+         LIMIT 10`
+      )
+    );
+    for (const r of rows) {
+      neverRetrieved.push({
+        id: r.id,
+        type: r.type,
+        title: String(r.title ?? "").slice(0, 120),
+        qualityScore: r.quality_score
+      });
+    }
+  } catch {
+  }
+  let qualityDistribution = { low: 0, medium: 0, high: 0 };
+  try {
+    const rows = typedAll(
+      nativeDb.prepare(
+        `SELECT
+           SUM(CASE WHEN qs < 0.3 THEN 1 ELSE 0 END)               AS low,
+           SUM(CASE WHEN qs >= 0.3 AND qs <= 0.6 THEN 1 ELSE 0 END) AS medium,
+           SUM(CASE WHEN qs > 0.6 THEN 1 ELSE 0 END)               AS high
+         FROM (
+           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_decisions
+           UNION ALL
+           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_patterns
+           UNION ALL
+           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_learnings
+           UNION ALL
+           SELECT COALESCE(quality_score, 0.5) AS qs FROM brain_observations
+         )`
+      )
+    );
+    if (rows[0]) {
+      qualityDistribution = {
+        low: rows[0].low ?? 0,
+        medium: rows[0].medium ?? 0,
+        high: rows[0].high ?? 0
+      };
+    }
+  } catch {
+  }
+  const tierDistribution = { short: 0, medium: 0, long: 0, unknown: 0 };
+  try {
+    const rows = typedAll(
+      nativeDb.prepare(
+        `SELECT memory_tier AS tier, COUNT(*) AS cnt
+         FROM (
+           SELECT memory_tier FROM brain_decisions
+           UNION ALL
+           SELECT memory_tier FROM brain_patterns
+           UNION ALL
+           SELECT memory_tier FROM brain_learnings
+           UNION ALL
+           SELECT memory_tier FROM brain_observations
+         )
+         GROUP BY memory_tier`
+      )
+    );
+    for (const r of rows) {
+      const tier = r.tier?.toLowerCase() ?? "unknown";
+      if (tier === "short" || tier === "medium" || tier === "long") {
+        tierDistribution[tier] += r.cnt;
+      } else {
+        tierDistribution.unknown += r.cnt;
+      }
+    }
+  } catch {
+  }
+  const totalEntries = qualityDistribution.low + qualityDistribution.medium + qualityDistribution.high;
+  const noiseRatio = totalEntries > 0 ? qualityDistribution.low / totalEntries : 0;
+  return {
+    totalRetrievals,
+    uniqueEntriesRetrieved,
+    usageRate,
+    topRetrieved,
+    neverRetrieved,
+    qualityDistribution,
+    tierDistribution,
+    noiseRatio
+  };
+}
+var init_quality_feedback = __esm({
+  "packages/core/src/memory/quality-feedback.ts"() {
+    "use strict";
+    init_typed_query();
+  }
+});
+
 // packages/core/src/hooks/handlers/task-hooks.ts
 async function handleToolStart(projectRoot, payload) {
   const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
@@ -46697,6 +47685,13 @@ async function handleToolComplete(projectRoot, payload) {
     } catch {
     }
   });
+  setImmediate(async () => {
+    try {
+      const { correlateOutcomes: correlateOutcomes2 } = await Promise.resolve().then(() => (init_quality_feedback(), quality_feedback_exports));
+      await correlateOutcomes2(projectRoot);
+    } catch {
+    }
+  });
   await maybeRefreshMemoryBridge(projectRoot);
 }
 var init_task_hooks = __esm({
@@ -53194,7 +54189,7 @@ function generateRecommendation2(changeType, affectedCount, cascadeDepth, taskId
   }
 }
 function scoreTaskMatch(change, task) {
-  const STOP_WORDS4 = /* @__PURE__ */ new Set([
+  const STOP_WORDS5 = /* @__PURE__ */ new Set([
     "a",
     "an",
     "the",
@@ -53216,7 +54211,7 @@ function scoreTaskMatch(change, task) {
     "do",
     "not"
   ]);
-  const tokenise = (text3) => text3.toLowerCase().split(/\W+/).filter((t) => t.length > 2 && !STOP_WORDS4.has(t));
+  const tokenise = (text3) => text3.toLowerCase().split(/\W+/).filter((t) => t.length > 2 && !STOP_WORDS5.has(t));
   const changeTokens = new Set(tokenise(change));
   if (changeTokens.size === 0) return 0;
   const taskText = `${task.title ?? ""} ${task.description ?? ""}`;
@@ -59666,6 +60661,7 @@ __export(memory_exports, {
   bulkLink: () => bulkLink,
   compactManifest: () => compactManifest,
   consolidateMemories: () => consolidateMemories,
+  correlateOutcomes: () => correlateOutcomes,
   detectContradictions: () => detectContradictions,
   ensureFts5Tables: () => ensureFts5Tables,
   fetchBrainEntries: () => fetchBrainEntries,
@@ -59676,6 +60672,7 @@ __export(memory_exports, {
   getLinkedLearnings: () => getLinkedLearnings,
   getLinkedPatterns: () => getLinkedPatterns,
   getMemoryLinks: () => getMemoryLinks,
+  getMemoryQualityReport: () => getMemoryQualityReport,
   getTaskLinks: () => getTaskLinks,
   hybridSearch: () => hybridSearch,
   learningStats: () => learningStats,
@@ -59717,6 +60714,7 @@ __export(memory_exports, {
   storePattern: () => storePattern,
   storeVerifiedCandidate: () => storeVerifiedCandidate,
   timelineBrain: () => timelineBrain,
+  trackMemoryUsage: () => trackMemoryUsage,
   unlinkMemoryFromTask: () => unlinkMemoryFromTask,
   updateDecisionOutcome: () => updateDecisionOutcome,
   updateResearch: () => updateResearch,
@@ -60339,6 +61337,7 @@ var init_memory = __esm({
     init_extraction_gate();
     init_learnings();
     init_patterns();
+    init_quality_feedback();
   }
 });
 
@@ -64053,8 +65052,8 @@ var init_deps = __esm({
 });
 
 // packages/core/src/nexus/discover.ts
-function extractKeywords3(text3) {
-  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w2) => w2.length > 2 && !STOP_WORDS3.has(w2));
+function extractKeywords4(text3) {
+  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w2) => w2.length > 2 && !STOP_WORDS4.has(w2));
 }
 async function discoverRelated(taskQuery, method = "auto", limit = 10) {
   if (!validateSyntax(taskQuery)) {
@@ -64077,7 +65076,7 @@ async function discoverRelated(taskQuery, method = "auto", limit = 10) {
   const sourceLabels = new Set(sourceTask.labels ?? []);
   const sourceDesc = (sourceTask.description ?? "").toLowerCase();
   const sourceTitle = (sourceTask.title ?? "").toLowerCase();
-  const sourceWords = extractKeywords3(sourceTitle + " " + sourceDesc);
+  const sourceWords = extractKeywords4(sourceTitle + " " + sourceDesc);
   const parsed = parseQuery(taskQuery);
   const registry2 = await readRegistry();
   if (!registry2) {
@@ -64112,7 +65111,7 @@ async function discoverRelated(taskQuery, method = "auto", limit = 10) {
       }
       if (method === "description" || method === "auto") {
         const taskDesc = ((task.description ?? "") + " " + (task.title ?? "")).toLowerCase();
-        const taskWords = extractKeywords3(taskDesc);
+        const taskWords = extractKeywords4(taskDesc);
         const commonWords = sourceWords.filter((w2) => taskWords.includes(w2));
         if (commonWords.length > 0) {
           const descScore = commonWords.length / Math.max(sourceWords.length, taskWords.length, 1);
@@ -64211,14 +65210,14 @@ async function searchAcrossProjects(pattern, projectFilter, limit = 20) {
   const sliced = results.slice(0, limit);
   return { pattern, results: sliced, resultCount: sliced.length };
 }
-var STOP_WORDS3;
+var STOP_WORDS4;
 var init_discover = __esm({
   "packages/core/src/nexus/discover.ts"() {
     "use strict";
     init_data_accessor();
     init_query4();
     init_registry3();
-    STOP_WORDS3 = /* @__PURE__ */ new Set([
+    STOP_WORDS4 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -65201,6 +66200,19 @@ async function completeTask(options, cwd, accessor) {
     })()
   ).catch(() => {
   });
+  try {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    await hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: options.taskId,
+      taskTitle: task.title,
+      previousStatus: before.status,
+      newStatus: "done",
+      unblockedCount: unblockedTasks.length
+    }).catch(() => {
+    });
+  } catch {
+  }
   return {
     task,
     ...autoCompleted.length > 0 && { autoCompleted },
@@ -66038,7 +67050,7 @@ __export(nexus_exports, {
   criticalPath: () => criticalPath,
   discoverRelated: () => discoverRelated,
   executeTransfer: () => executeTransfer,
-  extractKeywords: () => extractKeywords3,
+  extractKeywords: () => extractKeywords4,
   generateProjectHash: () => generateProjectHash,
   getCurrentProject: () => getCurrentProject,
   getNexusCacheDir: () => getNexusCacheDir,
@@ -70464,6 +71476,7 @@ __export(research_exports, {
   bulkLink: () => bulkLink,
   compactManifest: () => compactManifest,
   consolidateMemories: () => consolidateMemories,
+  correlateOutcomes: () => correlateOutcomes,
   detectContradictions: () => detectContradictions,
   ensureFts5Tables: () => ensureFts5Tables,
   fetchBrainEntries: () => fetchBrainEntries,
@@ -70474,6 +71487,7 @@ __export(research_exports, {
   getLinkedLearnings: () => getLinkedLearnings,
   getLinkedPatterns: () => getLinkedPatterns,
   getMemoryLinks: () => getMemoryLinks,
+  getMemoryQualityReport: () => getMemoryQualityReport,
   getTaskLinks: () => getTaskLinks,
   hybridSearch: () => hybridSearch,
   learningStats: () => learningStats,
@@ -70515,6 +71529,7 @@ __export(research_exports, {
   storePattern: () => storePattern,
   storeVerifiedCandidate: () => storeVerifiedCandidate,
   timelineBrain: () => timelineBrain,
+  trackMemoryUsage: () => trackMemoryUsage,
   unlinkMemoryFromTask: () => unlinkMemoryFromTask,
   updateDecisionOutcome: () => updateDecisionOutcome,
   updateResearch: () => updateResearch,
@@ -90884,6 +91899,22 @@ async function memoryGraphRemove(params, projectRoot) {
     };
   }
 }
+async function memoryQualityReport(projectRoot) {
+  try {
+    const root = resolveRoot(projectRoot);
+    const { getMemoryQualityReport: getMemoryQualityReport2 } = await Promise.resolve().then(() => (init_quality_feedback(), quality_feedback_exports));
+    const report = await getMemoryQualityReport2(root);
+    return { success: true, data: report };
+  } catch (error48) {
+    return {
+      success: false,
+      error: {
+        code: "E_QUALITY_REPORT",
+        message: error48 instanceof Error ? error48.message : String(error48)
+      }
+    };
+  }
+}
 var init_engine_compat = __esm({
   "packages/core/src/memory/engine-compat.ts"() {
     "use strict";
@@ -109522,12 +110553,12 @@ import { join as join119 } from "node:path";
 function typedAll4(db, sql14, ...params) {
   return db.prepare(sql14).all(...params);
 }
-function typedGet(db, sql14, ...params) {
+function typedGet2(db, sql14, ...params) {
   return db.prepare(sql14).get(...params);
 }
 function queryIndexMeta(db, projectId) {
   try {
-    const nodeMeta = typedGet(
+    const nodeMeta = typedGet2(
       db,
       `SELECT COUNT(*) as total_nodes,
               COUNT(CASE WHEN kind = 'file' THEN 1 END) as file_count,
@@ -109536,7 +110567,7 @@ function queryIndexMeta(db, projectId) {
        WHERE project_id = ?`,
       projectId
     );
-    const relMeta = typedGet(
+    const relMeta = typedGet2(
       db,
       `SELECT COUNT(*) as total_relations
        FROM nexus_relations
@@ -109631,7 +110662,7 @@ function queryCommunities(db, projectId, limit = 6) {
 }
 function queryProcessCount(db, projectId) {
   try {
-    const row = typedGet(
+    const row = typedGet2(
       db,
       `SELECT COUNT(*) as count
        FROM nexus_nodes
@@ -111232,6 +112263,7 @@ __export(internal_exports, {
   coreValidateProtocol: () => coreValidateProtocol,
   coreValidateSchema: () => coreValidateSchema,
   coreValidateTask: () => coreValidateTask,
+  correlateOutcomes: () => correlateOutcomes,
   createBackup: () => createBackup,
   createConduit: () => createConduit,
   createDataAccessor: () => createDataAccessor,
@@ -111384,6 +112416,7 @@ __export(internal_exports, {
   getLinksByTaskId: () => getLinksByTaskId,
   getLogDir: () => getLogDir,
   getLogger: () => getLogger,
+  getMemoryQualityReport: () => getMemoryQualityReport,
   getMigrationStatus: () => getMigrationStatus2,
   getNativeDb: () => getNativeDb,
   getNativeOperations: () => getNativeOperations,
@@ -111554,6 +112587,7 @@ __export(internal_exports, {
   memoryPatternFind: () => memoryPatternFind,
   memoryPatternStats: () => memoryPatternStats,
   memoryPatternStore: () => memoryPatternStore,
+  memoryQualityReport: () => memoryQualityReport,
   memoryReasonSimilar: () => memoryReasonSimilar,
   memoryReasonWhy: () => memoryReasonWhy,
   memorySearchHybrid: () => memorySearchHybrid,
@@ -111766,6 +112800,7 @@ __export(internal_exports, {
   tokenUsageMethodSchema: () => tokenUsageMethodSchema,
   tokenUsageTransportSchema: () => tokenUsageTransportSchema,
   touchLink: () => touchLink,
+  trackMemoryUsage: () => trackMemoryUsage,
   ui: () => ui_exports,
   uncancelTask: () => uncancelTask,
   unpackBundle: () => unpackBundle,
@@ -111853,6 +112888,7 @@ var init_internal = __esm({
     init_claude_mem_migration();
     init_engine_compat();
     init_pipeline_manifest_sqlite();
+    init_quality_feedback();
     init_token_service();
     init_deps();
     init_discover();
@@ -115018,6 +116054,66 @@ var init_registry5 = __esm({
         sessionRequired: false,
         requiredParams: []
       },
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "quality",
+        description: "Memory quality report: retrieval stats, noise ratio, tier distribution",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: []
+      },
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "code.links",
+        description: "List code_reference edges connecting memories to nexus code symbols",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: []
+      },
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "code.memories-for-code",
+        description: "Find memories linked to a code symbol via code_reference edges",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: ["symbol"]
+      },
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "code.for-memory",
+        description: "Find code symbols linked to a memory entry via code_reference edges",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: ["memoryId"]
+      },
+      {
+        gateway: "mutate",
+        domain: "memory",
+        operation: "code.link",
+        description: "Create code_reference edge from memory to nexus symbol",
+        tier: 1,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: ["memoryId", "codeSymbol"]
+      },
+      {
+        gateway: "mutate",
+        domain: "memory",
+        operation: "code.auto-link",
+        description: "Scan memories for entity references and auto-link to nexus nodes",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: []
+      },
       {
         gateway: "mutate",
         domain: "pipeline",
@@ -118039,7 +119135,31 @@ async function orchestrateSpawnExecute(taskId, adapterId, protocolType, projectR
       }
     } catch {
     }
+    try {
+      const { hooks: hooks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      await hooks2.dispatch("SubagentStart", cwd, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId,
+        agentId: cleoSpawnContext.options?.preferredAgent ?? `worker-${taskId}`,
+        role: protocolType || "worker",
+        providerId: adapter.providerId
+      }).catch(() => {
+      });
+    } catch {
+    }
     const result = await adapter.spawn(cleoSpawnContext);
+    try {
+      const { hooks: hooks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      await hooks2.dispatch("SubagentStop", cwd, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        taskId,
+        agentId: cleoSpawnContext.options?.preferredAgent ?? `worker-${taskId}`,
+        status: result.status,
+        instanceId: result.instanceId
+      }).catch(() => {
+      });
+    } catch {
+    }
     void sendConduitEvent(cwd, "cleo-core", {
       event: "agent.spawned",
       taskId,
@@ -123521,6 +124641,33 @@ var init_memory2 = __esm({
               );
               return wrapResult(result, "query", "memory", operation, startTime);
             }
+            case "quality": {
+              const result = await memoryQualityReport(projectRoot);
+              return wrapResult(result, "query", "memory", operation, startTime);
+            }
+            case "code.links": {
+              const { listCodeLinks: listCodeLinks2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await listCodeLinks2(projectRoot);
+              return wrapResult(result, "query", "memory", operation, startTime);
+            }
+            case "code.memories-for-code": {
+              const symbol2 = params?.symbol;
+              if (!symbol2) {
+                return errorResult("query", "memory", operation, "E_INVALID_INPUT", "symbol is required", startTime);
+              }
+              const { queryMemoriesForCode: queryMemoriesForCode2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await queryMemoriesForCode2(projectRoot, symbol2);
+              return wrapResult({ success: true, data: result }, "query", "memory", operation, startTime);
+            }
+            case "code.for-memory": {
+              const memoryId = params?.memoryId;
+              if (!memoryId) {
+                return errorResult("query", "memory", operation, "E_INVALID_INPUT", "memoryId is required", startTime);
+              }
+              const { queryCodeForMemory: queryCodeForMemory2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await queryCodeForMemory2(projectRoot, memoryId);
+              return wrapResult({ success: true, data: result }, "query", "memory", operation, startTime);
+            }
             default:
               return unsupportedOp("query", "memory", operation, startTime);
           }
@@ -123691,6 +124838,21 @@ var init_memory2 = __esm({
               );
               return wrapResult(result, "mutate", "memory", operation, startTime);
             }
+            case "code.link": {
+              const memoryId = params?.memoryId;
+              const codeSymbol = params?.codeSymbol;
+              if (!memoryId || !codeSymbol) {
+                return errorResult("mutate", "memory", operation, "E_INVALID_INPUT", "memoryId and codeSymbol are required", startTime);
+              }
+              const { linkMemoryToCode: linkMemoryToCode2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const linked = await linkMemoryToCode2(projectRoot, memoryId, codeSymbol);
+              return wrapResult({ success: true, data: { linked } }, "mutate", "memory", operation, startTime);
+            }
+            case "code.auto-link": {
+              const { autoLinkMemories: autoLinkMemories2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+              const result = await autoLinkMemories2(projectRoot);
+              return wrapResult({ success: true, data: result }, "mutate", "memory", operation, startTime);
+            }
             default:
               return unsupportedOp("mutate", "memory", operation, startTime);
           }
@@ -123723,7 +124885,11 @@ var init_memory2 = __esm({
             "graph.stats",
             "reason.why",
             "reason.similar",
-            "search.hybrid"
+            "search.hybrid",
+            "quality",
+            "code.links",
+            "code.memories-for-code",
+            "code.for-memory"
           ],
           mutate: [
             "observe",
@@ -123732,7 +124898,9 @@ var init_memory2 = __esm({
             "learning.store",
             "link",
             "graph.add",
-            "graph.remove"
+            "graph.remove",
+            "code.link",
+            "code.auto-link"
           ]
         };
       }
@@ -133450,6 +134618,66 @@ function registerBrainCommand(program) {
       process.exit(1);
     }
   });
+  brain.command("quality").description(
+    "Show memory quality metrics: retrieval rates, top/never-retrieved entries, quality distribution, and noise ratio."
+  ).option("--json", "Output results as JSON").action(async (opts) => {
+    const root = getProjectRoot();
+    const isJson = !!opts.json;
+    try {
+      const report = await getMemoryQualityReport(root);
+      if (isJson) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: report,
+              meta: { operation: "brain.quality", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log("\nBrain Memory Quality Report");
+      console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+      console.log(`  Total retrievals:       ${report.totalRetrievals}`);
+      console.log(`  Unique entries hit:     ${report.uniqueEntriesRetrieved}`);
+      console.log(`  Usage rate:             ${(report.usageRate * 100).toFixed(1)}%`);
+      console.log(`  Noise ratio:            ${(report.noiseRatio * 100).toFixed(1)}%`);
+      console.log("\nQuality Distribution");
+      console.log(`  Low  (<0.3):    ${report.qualityDistribution.low}`);
+      console.log(`  Med  (0.3-0.6): ${report.qualityDistribution.medium}`);
+      console.log(`  High (>0.6):    ${report.qualityDistribution.high}`);
+      console.log("\nTier Distribution");
+      console.log(`  Short:   ${report.tierDistribution.short}`);
+      console.log(`  Medium:  ${report.tierDistribution.medium}`);
+      console.log(`  Long:    ${report.tierDistribution.long}`);
+      if (report.tierDistribution.unknown > 0) {
+        console.log(`  Unknown: ${report.tierDistribution.unknown}`);
+      }
+      if (report.topRetrieved.length > 0) {
+        console.log("\nTop 10 Most Retrieved");
+        for (const e of report.topRetrieved) {
+          console.log(`  [${e.citationCount}x] ${e.id}  ${e.title.slice(0, 60)}`);
+        }
+      }
+      if (report.neverRetrieved.length > 0) {
+        console.log("\nNever Retrieved (pruning candidates)");
+        for (const e of report.neverRetrieved) {
+          console.log(`  q=${e.qualityScore.toFixed(2)}  ${e.id}  ${e.title.slice(0, 60)}`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (isJson) {
+        console.log(JSON.stringify({ success: false, error: message }));
+      } else {
+        console.error(`Brain quality report failed: ${message}`);
+      }
+      process.exit(1);
+    }
+  });
 }
 
 // packages/cleo/src/cli/commands/briefing.ts
@@ -136519,6 +137747,47 @@ function registerMemoryBrainCommand(program) {
       { command: "memory", operation: "memory.search.hybrid" }
     );
   });
+  memory.command("code-links").description("Show code \u2194 memory connections (code_reference edges between brain and nexus)").option("--limit <n>", "Maximum entries to return (default 100)", parseInt).option("--json", "Output as JSON").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.links",
+      {
+        ...opts["limit"] !== void 0 && { limit: opts["limit"] }
+      },
+      { command: "memory", operation: "memory.code.links" }
+    );
+  });
+  memory.command("code-auto-link").description("Scan brain memory nodes for entity references and auto-link to nexus code nodes").option("--json", "Output as JSON").action(async () => {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "code.auto-link",
+      {},
+      {
+        command: "memory",
+        operation: "memory.code.auto-link"
+      }
+    );
+  });
+  memory.command("code-memories-for-code <symbol>").description("Find brain memory nodes that reference a given nexus code symbol").option("--json", "Output as JSON").action(async (symbol2) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.memories-for-code",
+      { symbol: symbol2 },
+      { command: "memory", operation: "memory.code.memories-for-code" }
+    );
+  });
+  memory.command("code-for-memory <memoryId>").description("Find nexus code nodes referenced by a given brain memory entry").option("--json", "Output as JSON").action(async (memoryId) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "code.for-memory",
+      { memoryId },
+      { command: "memory", operation: "memory.code.for-memory" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/migrate-claude-mem.ts