@cleocode/core 2026.4.37 → 2026.4.38

package/dist/index.js

@@ -18648,6 +18648,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 w of words) {
+    if (w.length >= 4 && !STOP_WORDS.has(w)) {
+      keywords.add(w);
+    }
+  }
+  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 w of kwA) {
+    if (kwB.has(w)) shared.push(w);
+  }
+  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 now = (/* @__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(now, now, 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, now);
+  } 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, b) => b.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, {
@@ -18745,6 +18949,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 || "[]")
@@ -18801,6 +19021,7 @@ var init_patterns = __esm({
     init_brain_accessor();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -18892,6 +19113,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 || "[]")
@@ -18952,6 +19189,7 @@ var init_learnings = __esm({
     init_brain_accessor();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -18990,16 +19228,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";
@@ -20784,6 +21012,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) {
@@ -20836,6 +21080,7 @@ var init_decisions2 = __esm({
     init_sqlite2();
     init_graph_auto_populate();
     init_quality_scoring();
+    init_temporal_supersession();
   }
 });
 
@@ -41908,11 +42153,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 w of words) {
-    if (w.length >= 4 && !STOP_WORDS.has(w)) {
+    if (w.length >= 4 && !STOP_WORDS2.has(w)) {
       keywords.add(w);
     }
   }
@@ -41961,7 +42206,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++) {
@@ -41975,7 +42220,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((m) => !negationsB.includes(m));
         const negationsOnlyInB = negationsB.filter((m) => !negationsA.includes(m));
         const negationFlip = negationsOnlyInA.length > 0 || negationsOnlyInB.length > 0;
@@ -41993,8 +42238,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
@@ -42023,7 +42268,7 @@ async function detectContradictions(projectRoot) {
   }
   return results;
 }
-function buildNodeId(table, entryId) {
+function buildNodeId2(table, entryId) {
   const typeMap = {
     brain_observations: "observation",
     brain_learnings: "learning",
@@ -42033,13 +42278,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",
@@ -42060,7 +42305,7 @@ var init_brain_consolidator = __esm({
       "undone",
       "superseded"
     ];
-    STOP_WORDS = /* @__PURE__ */ new Set([
+    STOP_WORDS2 = /* @__PURE__ */ new Set([
       "the",
       "a",
       "an",
@@ -42148,11 +42393,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 w of words) {
-    if (w.length >= 4 && !STOP_WORDS2.has(w)) {
+    if (w.length >= 4 && !STOP_WORDS3.has(w)) {
       keywords.add(w);
     }
   }
@@ -42190,7 +42435,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 = [];
@@ -42592,13 +42837,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",
@@ -43203,6 +43448,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 now = (/* @__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, now);
+  } 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, now) {
+  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, now, 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 now = 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, now);
+      boosted++;
+    } else if (row.outcome === "failure" && row.used_count > 0) {
+      applyQualityDelta(nativeDb, table, row.entry_id, -0.05, now);
+      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));
@@ -43236,6 +43833,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({
@@ -57502,7 +58106,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",
@@ -57524,7 +58128,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 ?? ""}`;
@@ -60490,6 +61094,7 @@ __export(memory_exports, {
   bulkLink: () => bulkLink,
   compactManifest: () => compactManifest,
   consolidateMemories: () => consolidateMemories,
+  correlateOutcomes: () => correlateOutcomes,
   detectContradictions: () => detectContradictions,
   ensureFts5Tables: () => ensureFts5Tables,
   fetchBrainEntries: () => fetchBrainEntries,
@@ -60500,6 +61105,7 @@ __export(memory_exports, {
   getLinkedLearnings: () => getLinkedLearnings,
   getLinkedPatterns: () => getLinkedPatterns,
   getMemoryLinks: () => getMemoryLinks,
+  getMemoryQualityReport: () => getMemoryQualityReport,
   getTaskLinks: () => getTaskLinks,
   hybridSearch: () => hybridSearch,
   learningStats: () => learningStats,
@@ -60541,6 +61147,7 @@ __export(memory_exports, {
   storePattern: () => storePattern,
   storeVerifiedCandidate: () => storeVerifiedCandidate,
   timelineBrain: () => timelineBrain,
+  trackMemoryUsage: () => trackMemoryUsage,
   unlinkMemoryFromTask: () => unlinkMemoryFromTask,
   updateDecisionOutcome: () => updateDecisionOutcome,
   updateResearch: () => updateResearch,
@@ -60932,6 +61539,7 @@ async function verifyAndStoreBatch(projectRoot, candidates) {
 // packages/core/src/memory/index.ts
 init_learnings();
 init_patterns();
+init_quality_feedback();
 function getResearchPath(cwd) {
   return join49(getCleoDirAbsolute(cwd), "research.json");
 }
@@ -63848,7 +64456,7 @@ __export(nexus_exports, {
   criticalPath: () => criticalPath,
   discoverRelated: () => discoverRelated,
   executeTransfer: () => executeTransfer,
-  extractKeywords: () => extractKeywords3,
+  extractKeywords: () => extractKeywords4,
   generateProjectHash: () => generateProjectHash,
   getCurrentProject: () => getCurrentProject,
   getNexusCacheDir: () => getNexusCacheDir,
@@ -64391,7 +64999,7 @@ async function orphanDetection() {
 // packages/core/src/nexus/discover.ts
 init_data_accessor();
 init_registry3();
-var STOP_WORDS3 = /* @__PURE__ */ new Set([
+var STOP_WORDS4 = /* @__PURE__ */ new Set([
   "the",
   "a",
   "an",
@@ -64473,8 +65081,8 @@ var STOP_WORDS3 = /* @__PURE__ */ new Set([
   "it",
   "its"
 ]);
-function extractKeywords3(text3) {
-  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS3.has(w));
+function extractKeywords4(text3) {
+  return text3.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS4.has(w));
 }
 async function discoverRelated(taskQuery, method = "auto", limit = 10) {
   if (!validateSyntax(taskQuery)) {
@@ -64497,7 +65105,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) {
@@ -64532,7 +65140,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((w) => taskWords.includes(w));
         if (commonWords.length > 0) {
           const descScore = commonWords.length / Math.max(sourceWords.length, taskWords.length, 1);
@@ -69574,6 +70182,7 @@ __export(research_exports, {
   bulkLink: () => bulkLink,
   compactManifest: () => compactManifest,
   consolidateMemories: () => consolidateMemories,
+  correlateOutcomes: () => correlateOutcomes,
   detectContradictions: () => detectContradictions,
   ensureFts5Tables: () => ensureFts5Tables,
   fetchBrainEntries: () => fetchBrainEntries,
@@ -69584,6 +70193,7 @@ __export(research_exports, {
   getLinkedLearnings: () => getLinkedLearnings,
   getLinkedPatterns: () => getLinkedPatterns,
   getMemoryLinks: () => getMemoryLinks,
+  getMemoryQualityReport: () => getMemoryQualityReport,
   getTaskLinks: () => getTaskLinks,
   hybridSearch: () => hybridSearch,
   learningStats: () => learningStats,
@@ -69625,6 +70235,7 @@ __export(research_exports, {
   storePattern: () => storePattern,
   storeVerifiedCandidate: () => storeVerifiedCandidate,
   timelineBrain: () => timelineBrain,
+  trackMemoryUsage: () => trackMemoryUsage,
   unlinkMemoryFromTask: () => unlinkMemoryFromTask,
   updateDecisionOutcome: () => updateDecisionOutcome,
   updateResearch: () => updateResearch,