@velvetmonkey/flywheel-memory 2.0.47 → 2.0.49

package/dist/index.js

@@ -3493,23 +3493,39 @@ import {
 } from "@velvetmonkey/vault-core";
 
 // src/core/write/wikilinkFeedback.ts
-var MIN_FEEDBACK_COUNT = 5;
-var SUPPRESSION_THRESHOLD = 0.3;
-var FEEDBACK_BOOST_MIN_SAMPLES = 5;
+var PRIOR_ALPHA = 8;
+var PRIOR_BETA = 1;
+var SUPPRESSION_POSTERIOR_THRESHOLD = 0.35;
+var SUPPRESSION_MIN_OBSERVATIONS = 20;
+var MAX_SUPPRESSION_PENALTY = -15;
+var FEEDBACK_BOOST_MIN_SAMPLES = 3;
 var FOLDER_SUPPRESSION_MIN_COUNT = 5;
+var SUPPRESSION_TTL_DAYS = 30;
+var FEEDBACK_DECAY_HALF_LIFE_DAYS = 30;
+var FEEDBACK_DECAY_LAMBDA = Math.LN2 / FEEDBACK_DECAY_HALF_LIFE_DAYS;
+function computePosteriorMean(weightedCorrect, weightedFp) {
+  const alpha = PRIOR_ALPHA + weightedCorrect;
+  const beta_ = PRIOR_BETA + weightedFp;
+  return alpha / (alpha + beta_);
+}
 var FEEDBACK_BOOST_TIERS = [
-  { minAccuracy: 0.95, minSamples: 20, boost: 5 },
-  { minAccuracy: 0.8, minSamples: 5, boost: 2 },
-  { minAccuracy: 0.6, minSamples: 5, boost: 0 },
-  { minAccuracy: 0.4, minSamples: 5, boost: -2 },
-  { minAccuracy: 0, minSamples: 5, boost: -4 }
+  { minAccuracy: 0.85, minSamples: 5, boost: 10 },
+  // Strong reward for high accuracy
+  { minAccuracy: 0.7, minSamples: 3, boost: 6 },
+  // Most TPs land here
+  { minAccuracy: 0.5, minSamples: 3, boost: 0 },
+  // Neutral — Layer 0 suppression handles demotion
+  { minAccuracy: 0.3, minSamples: 3, boost: 0 },
+  // Neutral — no double-penalty with Layer 0
+  { minAccuracy: 0, minSamples: 3, boost: 0 }
+  // Neutral — no double-penalty with Layer 0
 ];
-function recordFeedback(stateDb2, entity, context, notePath, correct) {
+function recordFeedback(stateDb2, entity, context, notePath, correct, confidence = 1) {
   try {
     console.error(`[Flywheel] recordFeedback: entity="${entity}" context="${context}" notePath="${notePath}" correct=${correct}`);
     const result = stateDb2.db.prepare(
-      "INSERT INTO wikilink_feedback (entity, context, note_path, correct) VALUES (?, ?, ?, ?)"
-    ).run(entity, context, notePath, correct ? 1 : 0);
+      "INSERT INTO wikilink_feedback (entity, context, note_path, correct, confidence) VALUES (?, ?, ?, ?, ?)"
+    ).run(entity, context, notePath, correct ? 1 : 0, confidence);
     console.error(`[Flywheel] recordFeedback: inserted id=${result.lastInsertRowid}`);
   } catch (e) {
     console.error(`[Flywheel] recordFeedback failed for entity="${entity}": ${e}`);
@@ -3559,16 +3575,91 @@ function getEntityStats(stateDb2) {
     };
   });
 }
-function updateSuppressionList(stateDb2) {
-  const stats = stateDb2.db.prepare(`
-    SELECT
+function computeFeedbackWeight(createdAt, now) {
+  const ref = now ?? /* @__PURE__ */ new Date();
+  const normalized = createdAt.includes("T") ? createdAt : createdAt.replace(" ", "T") + "Z";
+  const ageDays = (ref.getTime() - new Date(normalized).getTime()) / (24 * 60 * 60 * 1e3);
+  if (ageDays < 1 / 1440) return 1;
+  return Math.exp(-FEEDBACK_DECAY_LAMBDA * ageDays);
+}
+function getWeightedEntityStats(stateDb2, now) {
+  const rows = stateDb2.db.prepare(`
+    SELECT entity, correct, confidence, created_at
+    FROM wikilink_feedback
+    ORDER BY entity COLLATE NOCASE
+  `).all();
+  const acc = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = row.entity.toLowerCase();
+    if (!acc.has(key)) {
+      acc.set(key, { weightedTotal: 0, weightedCorrect: 0, weightedFp: 0, rawTotal: 0 });
+    }
+    const stats = acc.get(key);
+    const recencyWeight = computeFeedbackWeight(row.created_at, now);
+    const weight = recencyWeight * (row.confidence ?? 1);
+    stats.weightedTotal += weight;
+    stats.rawTotal++;
+    if (row.correct === 1) {
+      stats.weightedCorrect += weight;
+    } else {
+      stats.weightedFp += weight;
+    }
+    if (stats.rawTotal === 1 || !acc.has(row.entity)) {
+    }
+  }
+  const entityNames = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = row.entity.toLowerCase();
+    if (!entityNames.has(key)) entityNames.set(key, row.entity);
+  }
+  const result = [];
+  for (const [key, stats] of acc) {
+    const entity = entityNames.get(key) ?? key;
+    result.push({
       entity,
-      COUNT(*) as total,
-      SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as false_positives
+      weightedTotal: stats.weightedTotal,
+      weightedCorrect: stats.weightedCorrect,
+      weightedFp: stats.weightedFp,
+      rawTotal: stats.rawTotal,
+      weightedAccuracy: stats.weightedTotal > 0 ? stats.weightedCorrect / stats.weightedTotal : 0,
+      weightedFpRate: stats.weightedTotal > 0 ? stats.weightedFp / stats.weightedTotal : 0
+    });
+  }
+  return result;
+}
+function getWeightedFolderStats(stateDb2, entity, folder, now) {
+  const rows = stateDb2.db.prepare(`
+    SELECT correct, confidence, created_at
     FROM wikilink_feedback
-    GROUP BY entity COLLATE NOCASE
-    HAVING total >= ?
-  `).all(MIN_FEEDBACK_COUNT);
+    WHERE entity = ? COLLATE NOCASE AND (
+      CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
+      ELSE note_path LIKE ? || '/%'
+      END
+    )
+  `).all(entity, folder, folder);
+  let weightedTotal = 0;
+  let weightedCorrect = 0;
+  let weightedFp = 0;
+  for (const row of rows) {
+    const recencyWeight = computeFeedbackWeight(row.created_at, now);
+    const weight = recencyWeight * (row.confidence ?? 1);
+    weightedTotal += weight;
+    if (row.correct === 1) {
+      weightedCorrect += weight;
+    } else {
+      weightedFp += weight;
+    }
+  }
+  return {
+    weightedTotal,
+    weightedFp,
+    weightedAccuracy: weightedTotal > 0 ? weightedCorrect / weightedTotal : 0,
+    weightedFpRate: weightedTotal > 0 ? weightedFp / weightedTotal : 0,
+    rawTotal: rows.length
+  };
+}
+function updateSuppressionList(stateDb2, now) {
+  const weightedStats = getWeightedEntityStats(stateDb2, now);
   let updated = 0;
   const upsert = stateDb2.db.prepare(`
     INSERT INTO wikilink_suppressions (entity, false_positive_rate, updated_at)
@@ -3581,10 +3672,18 @@ function updateSuppressionList(stateDb2) {
     "DELETE FROM wikilink_suppressions WHERE entity = ?"
   );
   const transaction = stateDb2.db.transaction(() => {
-    for (const stat4 of stats) {
-      const fpRate = stat4.false_positives / stat4.total;
-      if (fpRate >= SUPPRESSION_THRESHOLD) {
-        upsert.run(stat4.entity, fpRate);
+    stateDb2.db.prepare(
+      `DELETE FROM wikilink_suppressions
+       WHERE datetime(updated_at, '+' || ? || ' days') <= datetime('now')`
+    ).run(SUPPRESSION_TTL_DAYS);
+    for (const stat4 of weightedStats) {
+      const posteriorMean = computePosteriorMean(stat4.weightedCorrect, stat4.weightedFp);
+      const totalObs = PRIOR_ALPHA + stat4.weightedCorrect + PRIOR_BETA + stat4.weightedFp;
+      if (totalObs < SUPPRESSION_MIN_OBSERVATIONS) {
+        continue;
+      }
+      if (posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD) {
+        upsert.run(stat4.entity, 1 - posteriorMean);
         updated++;
       } else {
         remove.run(stat4.entity);
@@ -3594,26 +3693,33 @@ function updateSuppressionList(stateDb2) {
   transaction();
   return updated;
 }
-function isSuppressed(stateDb2, entity, folder) {
+function suppressEntity(stateDb2, entity) {
+  stateDb2.db.prepare(`
+    INSERT INTO wikilink_suppressions (entity, false_positive_rate, updated_at)
+    VALUES (?, 1.0, datetime('now'))
+    ON CONFLICT(entity) DO UPDATE SET false_positive_rate = 1.0, updated_at = datetime('now')
+  `).run(entity);
+}
+function unsuppressEntity(stateDb2, entity) {
+  const result = stateDb2.db.prepare(
+    "DELETE FROM wikilink_suppressions WHERE entity = ? COLLATE NOCASE"
+  ).run(entity);
+  return result.changes > 0;
+}
+function isSuppressed(stateDb2, entity, folder, now) {
   const row = stateDb2.db.prepare(
-    "SELECT entity FROM wikilink_suppressions WHERE entity = ? COLLATE NOCASE"
-  ).get(entity);
+    `SELECT entity, updated_at FROM wikilink_suppressions
+     WHERE entity = ? COLLATE NOCASE
+     AND datetime(updated_at, '+' || ? || ' days') > datetime('now')`
+  ).get(entity, SUPPRESSION_TTL_DAYS);
   if (row) return true;
   if (folder !== void 0) {
-    const folderStats = stateDb2.db.prepare(`
-      SELECT
-        COUNT(*) as total,
-        SUM(CASE WHEN correct = 0 THEN 1 ELSE 0 END) as false_positives
-      FROM wikilink_feedback
-      WHERE entity = ? COLLATE NOCASE AND (
-        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
-        ELSE note_path LIKE ? || '/%'
-        END
-      )
-    `).get(entity, folder, folder);
-    if (folderStats && folderStats.total >= FOLDER_SUPPRESSION_MIN_COUNT) {
-      const fpRate = folderStats.false_positives / folderStats.total;
-      if (fpRate >= SUPPRESSION_THRESHOLD) {
+    const stats = getWeightedFolderStats(stateDb2, entity, folder, now);
+    if (stats.rawTotal >= FOLDER_SUPPRESSION_MIN_COUNT) {
+      const folderCorrect = stats.weightedTotal - stats.weightedFp;
+      const posteriorMean = computePosteriorMean(folderCorrect, stats.weightedFp);
+      const totalObs = PRIOR_ALPHA + folderCorrect + PRIOR_BETA + stats.weightedFp;
+      if (totalObs >= SUPPRESSION_MIN_OBSERVATIONS && posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD) {
         return true;
       }
     }
@@ -3643,59 +3749,65 @@ function computeBoostFromAccuracy(accuracy, sampleCount) {
   }
   return 0;
 }
-function getAllFeedbackBoosts(stateDb2, folder) {
-  const globalRows = stateDb2.db.prepare(`
-    SELECT
-      entity,
-      COUNT(*) as total,
-      SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
-    FROM wikilink_feedback
-    GROUP BY entity
-    HAVING total >= ?
-  `).all(FEEDBACK_BOOST_MIN_SAMPLES);
-  let folderStats = null;
+function getAllFeedbackBoosts(stateDb2, folder, now) {
+  const globalStats = getWeightedEntityStats(stateDb2, now);
+  let folderStatsMap = null;
   if (folder !== void 0) {
-    const folderRows = stateDb2.db.prepare(`
-      SELECT
-        entity,
-        COUNT(*) as total,
-        SUM(CASE WHEN correct = 1 THEN 1 ELSE 0 END) as correct_count
-      FROM wikilink_feedback
-      WHERE (
-        CASE WHEN ? = '' THEN note_path NOT LIKE '%/%'
-        ELSE note_path LIKE ? || '/%'
-        END
-      )
-      GROUP BY entity
-      HAVING total >= ?
-    `).all(folder, folder, FEEDBACK_BOOST_MIN_SAMPLES);
-    folderStats = /* @__PURE__ */ new Map();
-    for (const row of folderRows) {
-      folderStats.set(row.entity, {
-        accuracy: row.correct_count / row.total,
-        count: row.total
-      });
+    folderStatsMap = /* @__PURE__ */ new Map();
+    for (const gs of globalStats) {
+      const fs32 = getWeightedFolderStats(stateDb2, gs.entity, folder, now);
+      if (fs32.rawTotal >= FEEDBACK_BOOST_MIN_SAMPLES) {
+        folderStatsMap.set(gs.entity, {
+          weightedAccuracy: fs32.weightedAccuracy,
+          rawCount: fs32.rawTotal
+        });
+      }
     }
   }
   const boosts = /* @__PURE__ */ new Map();
-  for (const row of globalRows) {
+  for (const stat4 of globalStats) {
+    if (stat4.rawTotal < FEEDBACK_BOOST_MIN_SAMPLES) continue;
     let accuracy;
     let sampleCount;
-    const fs32 = folderStats?.get(row.entity);
-    if (fs32 && fs32.count >= FEEDBACK_BOOST_MIN_SAMPLES) {
-      accuracy = fs32.accuracy;
-      sampleCount = fs32.count;
+    const fs32 = folderStatsMap?.get(stat4.entity);
+    if (fs32 && fs32.rawCount >= FEEDBACK_BOOST_MIN_SAMPLES) {
+      accuracy = fs32.weightedAccuracy;
+      sampleCount = fs32.rawCount;
     } else {
-      accuracy = row.correct_count / row.total;
-      sampleCount = row.total;
+      accuracy = stat4.weightedAccuracy;
+      sampleCount = stat4.rawTotal;
     }
     const boost = computeBoostFromAccuracy(accuracy, sampleCount);
     if (boost !== 0) {
-      boosts.set(row.entity, boost);
+      boosts.set(stat4.entity, boost);
     }
   }
   return boosts;
 }
+function getAllSuppressionPenalties(stateDb2, now) {
+  const penalties = /* @__PURE__ */ new Map();
+  const weightedStats = getWeightedEntityStats(stateDb2, now);
+  for (const stat4 of weightedStats) {
+    const posteriorMean = computePosteriorMean(stat4.weightedCorrect, stat4.weightedFp);
+    const totalObs = PRIOR_ALPHA + stat4.weightedCorrect + PRIOR_BETA + stat4.weightedFp;
+    if (totalObs >= SUPPRESSION_MIN_OBSERVATIONS && posteriorMean < SUPPRESSION_POSTERIOR_THRESHOLD) {
+      const penalty = Math.round(MAX_SUPPRESSION_PENALTY * (1 - posteriorMean / SUPPRESSION_POSTERIOR_THRESHOLD));
+      if (penalty < 0) {
+        penalties.set(stat4.entity, penalty);
+      }
+    }
+  }
+  const rows = stateDb2.db.prepare(
+    `SELECT entity, updated_at FROM wikilink_suppressions
+     WHERE datetime(updated_at, '+' || ? || ' days') > datetime('now')`
+  ).all(SUPPRESSION_TTL_DAYS);
+  for (const row of rows) {
+    if (!penalties.has(row.entity)) {
+      penalties.set(row.entity, MAX_SUPPRESSION_PENALTY);
+    }
+  }
+  return penalties;
+}
 function trackWikilinkApplications(stateDb2, notePath, entities) {
   const upsert = stateDb2.db.prepare(`
     INSERT INTO wikilink_applications (entity, note_path, applied_at, status)
@@ -3717,6 +3829,18 @@ function getTrackedApplications(stateDb2, notePath) {
   ).all(notePath);
   return rows.map((r) => r.entity);
 }
+function getTrackedApplicationsWithTime(stateDb2, notePath) {
+  return stateDb2.db.prepare(
+    `SELECT entity, applied_at FROM wikilink_applications WHERE note_path = ? AND status = 'applied'`
+  ).all(notePath);
+}
+function computeImplicitRemovalConfidence(appliedAt) {
+  const normalized = appliedAt.includes("T") ? appliedAt : appliedAt.replace(" ", "T") + "Z";
+  const ageHours = (Date.now() - new Date(normalized).getTime()) / (60 * 60 * 1e3);
+  if (ageHours <= 1) return 1;
+  if (ageHours <= 24) return 0.85;
+  return 0.7;
+}
 function getStoredNoteLinks(stateDb2, notePath) {
   const rows = stateDb2.db.prepare(
     "SELECT target FROM note_links WHERE note_path = ?"
@@ -3770,17 +3894,18 @@ function updateStoredNoteTags(stateDb2, notePath, currentTags) {
   tx();
 }
 function processImplicitFeedback(stateDb2, notePath, currentContent) {
-  const tracked = getTrackedApplications(stateDb2, notePath);
-  if (tracked.length === 0) return [];
+  const trackedWithTime = getTrackedApplicationsWithTime(stateDb2, notePath);
+  if (trackedWithTime.length === 0) return [];
   const currentLinks = extractLinkedEntities(currentContent);
   const removed = [];
   const markRemoved = stateDb2.db.prepare(
     `UPDATE wikilink_applications SET status = 'removed' WHERE entity = ? AND note_path = ?`
   );
   const transaction = stateDb2.db.transaction(() => {
-    for (const entity of tracked) {
+    for (const { entity, applied_at } of trackedWithTime) {
       if (!currentLinks.has(entity.toLowerCase())) {
-        recordFeedback(stateDb2, entity, "implicit:removed", notePath, false);
+        const confidence = computeImplicitRemovalConfidence(applied_at);
+        recordFeedback(stateDb2, entity, "implicit:removed", notePath, false, confidence);
         markRemoved.run(entity, notePath);
         removed.push(entity);
       }
@@ -3793,11 +3918,11 @@ function processImplicitFeedback(stateDb2, notePath, currentContent) {
   return removed;
 }
 var TIER_LABELS = [
-  { label: "Champion (+5)", boost: 5, minAccuracy: 0.95, minSamples: 20 },
-  { label: "Strong (+2)", boost: 2, minAccuracy: 0.8, minSamples: 5 },
-  { label: "Neutral (0)", boost: 0, minAccuracy: 0.6, minSamples: 5 },
-  { label: "Weak (-2)", boost: -2, minAccuracy: 0.4, minSamples: 5 },
-  { label: "Poor (-4)", boost: -4, minAccuracy: 0, minSamples: 5 }
+  { label: "Champion (+10)", boost: 10, minAccuracy: 0.85, minSamples: 5 },
+  { label: "Strong (+6)", boost: 6, minAccuracy: 0.7, minSamples: 3 },
+  { label: "Neutral (0)", boost: 0, minAccuracy: 0.5, minSamples: 3 },
+  { label: "Neutral (0)", boost: 0, minAccuracy: 0.3, minSamples: 3 },
+  { label: "Neutral (0)", boost: 0, minAccuracy: 0, minSamples: 3 }
 ];
 function getDashboardData(stateDb2) {
   const entityStats = getEntityStats(stateDb2);
@@ -5258,14 +5383,14 @@ function stem(word) {
 }
 function tokenize(text) {
   const cleanText = text.replace(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g, "$1").replace(/[*_`#\[\]()]/g, " ").toLowerCase();
-  const words = cleanText.match(/\b[a-z]{3,}\b/g) || [];
+  const words = cleanText.match(/\b[a-z][a-z0-9]{2,}\b/g) || [];
   return words.filter((word) => !STOPWORDS.has(word));
 }
 
 // src/core/shared/cooccurrence.ts
 import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
 import path10 from "path";
-var DEFAULT_MIN_COOCCURRENCE = 2;
+var DEFAULT_MIN_COOCCURRENCE = 0.5;
 var EXCLUDED_FOLDERS2 = /* @__PURE__ */ new Set([
   "templates",
   ".obsidian",
@@ -5287,12 +5412,12 @@ function noteContainsEntity(content, entityName) {
   }
   return matchCount / entityTokens.length >= 0.5;
 }
-function incrementCooccurrence(associations, entityA, entityB) {
+function incrementCooccurrence(associations, entityA, entityB, weight = 1) {
   if (!associations[entityA]) {
     associations[entityA] = /* @__PURE__ */ new Map();
   }
   const current = associations[entityA].get(entityB) || 0;
-  associations[entityA].set(entityB, current + 1);
+  associations[entityA].set(entityB, current + weight);
 }
 async function* walkMarkdownFiles2(dir, baseDir) {
   try {
@@ -5316,6 +5441,7 @@ async function* walkMarkdownFiles2(dir, baseDir) {
 async function mineCooccurrences(vaultPath2, entities, options = {}) {
   const { minCount = DEFAULT_MIN_COOCCURRENCE } = options;
   const associations = {};
+  const documentFrequency = /* @__PURE__ */ new Map();
   let notesScanned = 0;
   const validEntities = entities.filter((e) => e.length <= 30);
   for await (const file of walkMarkdownFiles2(vaultPath2, vaultPath2)) {
@@ -5328,10 +5454,15 @@ async function mineCooccurrences(vaultPath2, entities, options = {}) {
           mentionedEntities.push(entity);
         }
       }
+      for (const entity of mentionedEntities) {
+        documentFrequency.set(entity, (documentFrequency.get(entity) || 0) + 1);
+      }
+      const degree = mentionedEntities.length;
+      const adamicAdarWeight = degree >= 3 ? 1 / Math.log(degree) : 1;
       for (const entityA of mentionedEntities) {
         for (const entityB of mentionedEntities) {
           if (entityA !== entityB) {
-            incrementCooccurrence(associations, entityA, entityB);
+            incrementCooccurrence(associations, entityA, entityB, adamicAdarWeight);
           }
         }
       }
@@ -5349,6 +5480,8 @@ async function mineCooccurrences(vaultPath2, entities, options = {}) {
   return {
     associations,
     minCount,
+    documentFrequency,
+    totalNotesScanned: notesScanned,
     _metadata: {
       generated_at: (/* @__PURE__ */ new Date()).toISOString(),
       total_associations: totalAssociations,
@@ -5356,26 +5489,50 @@ async function mineCooccurrences(vaultPath2, entities, options = {}) {
     }
   };
 }
-var MAX_COOCCURRENCE_BOOST = 6;
+var MAX_COOCCURRENCE_BOOST = 12;
+var PMI_SCALE = 12;
+function computeNpmi(coocCount, dfEntity, dfSeed, totalNotes) {
+  if (coocCount === 0 || dfEntity === 0 || dfSeed === 0 || totalNotes === 0) return 0;
+  const pxy = coocCount / totalNotes;
+  const px = dfEntity / totalNotes;
+  const py = dfSeed / totalNotes;
+  const pmi = Math.log(pxy / (px * py));
+  const negLogPxy = -Math.log(pxy);
+  if (negLogPxy === 0) return 1;
+  const npmi = pmi / negLogPxy;
+  return Math.max(0, Math.min(1, npmi));
+}
 function getCooccurrenceBoost(entityName, matchedEntities, cooccurrenceIndex2, recencyIndex2) {
   if (!cooccurrenceIndex2) return 0;
-  let boost = 0;
-  const { associations, minCount } = cooccurrenceIndex2;
+  const { associations, minCount, documentFrequency, totalNotesScanned } = cooccurrenceIndex2;
+  const dfEntity = documentFrequency.get(entityName) || 0;
+  if (dfEntity === 0 || totalNotesScanned === 0) return 0;
+  let bestNpmi = 0;
   for (const matched of matchedEntities) {
     const entityAssocs = associations[matched];
-    if (entityAssocs) {
-      const count = entityAssocs.get(entityName) || 0;
-      if (count >= minCount) {
-        boost += 3;
-      }
-    }
-  }
-  if (boost > 0 && recencyIndex2) {
+    if (!entityAssocs) continue;
+    const coocCount = entityAssocs.get(entityName) || 0;
+    if (coocCount < minCount) continue;
+    const dfSeed = documentFrequency.get(matched) || 0;
+    const npmi = computeNpmi(coocCount, dfEntity, dfSeed, totalNotesScanned);
+    bestNpmi = Math.max(bestNpmi, npmi);
+  }
+  if (bestNpmi === 0) return 0;
+  let boost = bestNpmi * PMI_SCALE;
+  if (recencyIndex2) {
     const recencyBoostVal = getRecencyBoost(entityName, recencyIndex2);
     const recencyMultiplier = recencyBoostVal > 0 ? 1.5 : 0.5;
-    boost = Math.round(boost * recencyMultiplier);
+    boost = boost * recencyMultiplier;
   }
-  return Math.min(boost, MAX_COOCCURRENCE_BOOST);
+  return Math.min(Math.round(boost), MAX_COOCCURRENCE_BOOST);
+}
+function tokenIdf(token, coocIndex) {
+  if (!coocIndex || coocIndex.totalNotesScanned === 0) return 1;
+  const df = coocIndex.documentFrequency.get(token);
+  if (df === void 0) return 1;
+  const N = coocIndex.totalNotesScanned;
+  const rawIdf = Math.log((N + 1) / (df + 1));
+  return Math.max(0.5, Math.min(2.5, rawIdf));
 }
 
 // src/core/write/edgeWeights.ts
@@ -5951,8 +6108,8 @@ function isLikelyArticleTitle(name) {
 var STRICTNESS_CONFIGS = {
   conservative: {
     minWordLength: 3,
-    minSuggestionScore: 15,
-    // Requires exact match (10) + at least one stem (5)
+    minSuggestionScore: 18,
+    // Requires exact match (10) + stem (5) + at least one boost
     minMatchRatio: 0.6,
     // 60% of multi-word entity must match
     requireMultipleMatches: true,
@@ -5964,8 +6121,8 @@ var STRICTNESS_CONFIGS = {
   },
   balanced: {
     minWordLength: 3,
-    minSuggestionScore: 8,
-    // At least one exact match or two stem matches
+    minSuggestionScore: 10,
+    // Exact match (10) or two stem matches
     minMatchRatio: 0.4,
     // 40% of multi-word entity must match
     requireMultipleMatches: false,
@@ -6112,7 +6269,7 @@ function getAdaptiveMinScore(contentLength, baseScore) {
 var MIN_SUGGESTION_SCORE = STRICTNESS_CONFIGS.balanced.minSuggestionScore;
 var MIN_MATCH_RATIO = STRICTNESS_CONFIGS.balanced.minMatchRatio;
 var FULL_ALIAS_MATCH_BONUS = 8;
-function scoreNameAgainstContent(name, contentTokens, contentStems, config) {
+function scoreNameAgainstContent(name, contentTokens, contentStems, config, coocIndex) {
   const nameTokens = tokenize(name);
   if (nameTokens.length === 0) {
     return { score: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0 };
@@ -6124,24 +6281,26 @@ function scoreNameAgainstContent(name, contentTokens, contentStems, config) {
   for (let i = 0; i < nameTokens.length; i++) {
     const token = nameTokens[i];
     const nameStem = nameStems[i];
+    const idfWeight = coocIndex ? tokenIdf(token, coocIndex) : 1;
     if (contentTokens.has(token)) {
-      score += config.exactMatchBonus;
+      score += config.exactMatchBonus * idfWeight;
       matchedWords++;
       exactMatches++;
     } else if (contentStems.has(nameStem)) {
-      score += config.stemMatchBonus;
+      score += config.stemMatchBonus * idfWeight;
       matchedWords++;
     }
   }
+  score = Math.round(score * 10) / 10;
   return { score, matchedWords, exactMatches, totalTokens: nameTokens.length };
 }
-function scoreEntity(entity, contentTokens, contentStems, config) {
+function scoreEntity(entity, contentTokens, contentStems, config, coocIndex) {
   const entityName = getEntityName2(entity);
   const aliases = getEntityAliases(entity);
-  const nameResult = scoreNameAgainstContent(entityName, contentTokens, contentStems, config);
+  const nameResult = scoreNameAgainstContent(entityName, contentTokens, contentStems, config, coocIndex);
   let bestAliasResult = { score: 0, matchedWords: 0, exactMatches: 0, totalTokens: 0 };
   for (const alias of aliases) {
-    const aliasResult = scoreNameAgainstContent(alias, contentTokens, contentStems, config);
+    const aliasResult = scoreNameAgainstContent(alias, contentTokens, contentStems, config, coocIndex);
     if (aliasResult.score > bestAliasResult.score) {
       bestAliasResult = aliasResult;
     }
@@ -6151,7 +6310,7 @@ function scoreEntity(entity, contentTokens, contentStems, config) {
   if (totalTokens === 0) return 0;
   for (const alias of aliases) {
     const aliasLower = alias.toLowerCase();
-    if (aliasLower.length >= 4 && !/\s/.test(aliasLower) && contentTokens.has(aliasLower)) {
+    if (aliasLower.length >= 3 && !/\s/.test(aliasLower) && contentTokens.has(aliasLower)) {
       score += FULL_ALIAS_MATCH_BONUS;
       break;
     }
@@ -6176,7 +6335,7 @@ function getEdgeWeightBoostScore(entityName, map) {
 }
 async function suggestRelatedLinks(content, options = {}) {
   const {
-    maxSuggestions = 3,
+    maxSuggestions = 8,
     excludeLinked = true,
     strictness = getEffectiveStrictness(options.notePath),
     notePath,
@@ -6218,6 +6377,7 @@ async function suggestRelatedLinks(content, options = {}) {
   const linkedEntities = excludeLinked ? extractLinkedEntities(content) : /* @__PURE__ */ new Set();
   const noteFolder = notePath ? notePath.split("/")[0] : void 0;
   const feedbackBoosts = moduleStateDb5 ? getAllFeedbackBoosts(moduleStateDb5, noteFolder) : /* @__PURE__ */ new Map();
+  const suppressionPenalties = moduleStateDb5 ? getAllSuppressionPenalties(moduleStateDb5) : /* @__PURE__ */ new Map();
   const edgeWeightMap = moduleStateDb5 ? getEntityEdgeWeightMap(moduleStateDb5) : /* @__PURE__ */ new Map();
   const scoredEntities = [];
   const directlyMatchedEntities = /* @__PURE__ */ new Set();
@@ -6234,13 +6394,7 @@ async function suggestRelatedLinks(content, options = {}) {
     if (linkedEntities.has(entityName.toLowerCase())) {
       continue;
     }
-    if (moduleStateDb5 && !disabled.has("feedback")) {
-      const noteFolder2 = notePath ? notePath.split("/").slice(0, -1).join("/") : void 0;
-      if (isSuppressed(moduleStateDb5, entityName, noteFolder2)) {
-        continue;
-      }
-    }
-    const contentScore = disabled.has("exact_match") && disabled.has("stem_match") ? 0 : scoreEntity(entity, contentTokens, contentStems, config);
+    const contentScore = disabled.has("exact_match") && disabled.has("stem_match") ? 0 : scoreEntity(entity, contentTokens, contentStems, config, cooccurrenceIndex);
     let score = contentScore;
     if (contentScore > 0) {
       entitiesWithContentMatch.add(entityName);
@@ -6259,10 +6413,12 @@ async function suggestRelatedLinks(content, options = {}) {
     score += layerFeedbackAdj;
     const layerEdgeWeightBoost = disabled.has("edge_weight") ? 0 : getEdgeWeightBoostScore(entityName, edgeWeightMap);
     score += layerEdgeWeightBoost;
-    if (score > 0) {
+    if (contentScore > 0) {
       directlyMatchedEntities.add(entityName);
     }
-    if (score >= adaptiveMinScore) {
+    const layerSuppressionPenalty = disabled.has("feedback") ? 0 : suppressionPenalties.get(entityName) ?? 0;
+    score += layerSuppressionPenalty;
+    if (contentScore > 0 && score >= adaptiveMinScore) {
       scoredEntities.push({
         name: entityName,
         path: entity.path || "",
@@ -6277,23 +6433,31 @@ async function suggestRelatedLinks(content, options = {}) {
           crossFolderBoost: layerCrossFolderBoost,
           hubBoost: layerHubBoost,
           feedbackAdjustment: layerFeedbackAdj,
+          suppressionPenalty: layerSuppressionPenalty,
           edgeWeightBoost: layerEdgeWeightBoost
         }
       });
     }
   }
-  if (!disabled.has("cooccurrence") && cooccurrenceIndex && directlyMatchedEntities.size > 0) {
+  const cooccurrenceSeeds = new Set(directlyMatchedEntities);
+  if (linkedEntities.size > 0) {
+    const lowerToDisplay = /* @__PURE__ */ new Map();
+    for (const { entity } of entitiesWithTypes) {
+      if (entity.name) lowerToDisplay.set(entity.name.toLowerCase(), entity.name);
+    }
+    for (const linked of linkedEntities) {
+      const displayName = lowerToDisplay.get(linked);
+      if (displayName) cooccurrenceSeeds.add(displayName);
+    }
+  }
+  if (!disabled.has("cooccurrence") && cooccurrenceIndex && cooccurrenceSeeds.size > 0) {
     for (const { entity, category } of entitiesWithTypes) {
       const entityName = entity.name;
       if (!entityName) continue;
       if (!disabled.has("length_filter") && entityName.length > MAX_ENTITY_LENGTH) continue;
       if (!disabled.has("article_filter") && isLikelyArticleTitle(entityName)) continue;
       if (linkedEntities.has(entityName.toLowerCase())) continue;
-      if (moduleStateDb5 && !disabled.has("feedback")) {
-        const noteFolder2 = notePath ? notePath.split("/").slice(0, -1).join("/") : void 0;
-        if (isSuppressed(moduleStateDb5, entityName, noteFolder2)) continue;
-      }
-      const boost = getCooccurrenceBoost(entityName, directlyMatchedEntities, cooccurrenceIndex, recencyIndex);
+      const boost = getCooccurrenceBoost(entityName, cooccurrenceSeeds, cooccurrenceIndex, recencyIndex);
       if (boost > 0) {
         const existing = scoredEntities.find((e) => e.name === entityName);
         if (existing) {
@@ -6304,19 +6468,24 @@ async function suggestRelatedLinks(content, options = {}) {
           const hasContentOverlap = entityTokens.some(
             (token) => contentTokens.has(token) || contentStems.has(stem(token))
           );
-          if (!hasContentOverlap) {
+          const strongCooccurrence = boost >= 4;
+          if (!hasContentOverlap && !strongCooccurrence) {
             continue;
           }
-          entitiesWithContentMatch.add(entityName);
+          if (hasContentOverlap || strongCooccurrence) {
+            entitiesWithContentMatch.add(entityName);
+          }
           const typeBoost = disabled.has("type_boost") ? 0 : TYPE_BOOST[category] || 0;
           const contextBoost = disabled.has("context_boost") ? 0 : contextBoosts[category] || 0;
-          const recencyBoostVal = disabled.has("recency") ? 0 : recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0;
+          const recencyBoostVal = hasContentOverlap && !disabled.has("recency") ? recencyIndex ? getRecencyBoost(entityName, recencyIndex) : 0 : 0;
           const crossFolderBoost = disabled.has("cross_folder") ? 0 : notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
           const hubBoost = disabled.has("hub_boost") ? 0 : getHubBoost(entity);
           const feedbackAdj = disabled.has("feedback") ? 0 : feedbackBoosts.get(entityName) ?? 0;
           const edgeWeightBoost = disabled.has("edge_weight") ? 0 : getEdgeWeightBoostScore(entityName, edgeWeightMap);
-          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj + edgeWeightBoost;
-          if (totalBoost >= adaptiveMinScore) {
+          const suppPenalty = disabled.has("feedback") ? 0 : suppressionPenalties.get(entityName) ?? 0;
+          const totalBoost = boost + typeBoost + contextBoost + recencyBoostVal + crossFolderBoost + hubBoost + feedbackAdj + edgeWeightBoost + suppPenalty;
+          const effectiveMinScore = !hasContentOverlap ? Math.max(adaptiveMinScore, 10) : adaptiveMinScore;
+          if (totalBoost >= effectiveMinScore) {
             scoredEntities.push({
               name: entityName,
               path: entity.path || "",
@@ -6331,6 +6500,7 @@ async function suggestRelatedLinks(content, options = {}) {
                 crossFolderBoost,
                 hubBoost,
                 feedbackAdjustment: feedbackAdj,
+                suppressionPenalty: suppPenalty,
                 edgeWeightBoost
               }
             });
@@ -6357,10 +6527,6 @@ async function suggestRelatedLinks(content, options = {}) {
           existing.score += boost;
           existing.breakdown.semanticBoost = boost;
         } else if (!linkedEntities.has(match.entityName.toLowerCase())) {
-          if (moduleStateDb5 && !disabled.has("feedback")) {
-            const noteFolder2 = notePath ? notePath.split("/").slice(0, -1).join("/") : void 0;
-            if (isSuppressed(moduleStateDb5, match.entityName, noteFolder2)) continue;
-          }
           const entityWithType = entitiesWithTypes.find(
             (et) => et.entity.name === match.entityName
           );
@@ -6374,7 +6540,8 @@ async function suggestRelatedLinks(content, options = {}) {
           const layerCrossFolderBoost = disabled.has("cross_folder") ? 0 : notePath && entity.path ? getCrossFolderBoost(entity.path, notePath) : 0;
           const layerFeedbackAdj = disabled.has("feedback") ? 0 : feedbackBoosts.get(match.entityName) ?? 0;
           const layerEdgeWeightBoost = disabled.has("edge_weight") ? 0 : getEdgeWeightBoostScore(match.entityName, edgeWeightMap);
-          const totalScore = boost + layerTypeBoost + layerContextBoost + layerHubBoost + layerCrossFolderBoost + layerFeedbackAdj + layerEdgeWeightBoost;
+          const layerSuppPenalty = disabled.has("feedback") ? 0 : suppressionPenalties.get(match.entityName) ?? 0;
+          const totalScore = boost + layerTypeBoost + layerContextBoost + layerHubBoost + layerCrossFolderBoost + layerFeedbackAdj + layerEdgeWeightBoost + layerSuppPenalty;
           if (totalScore >= adaptiveMinScore) {
             scoredEntities.push({
               name: match.entityName,
@@ -6390,6 +6557,7 @@ async function suggestRelatedLinks(content, options = {}) {
                 crossFolderBoost: layerCrossFolderBoost,
                 hubBoost: layerHubBoost,
                 feedbackAdjustment: layerFeedbackAdj,
+                suppressionPenalty: layerSuppPenalty,
                 semanticBoost: boost,
                 edgeWeightBoost: layerEdgeWeightBoost
               }
@@ -7846,11 +8014,12 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         text: z2.string().describe("The text to analyze for potential wikilinks"),
         limit: z2.coerce.number().default(50).describe("Maximum number of suggestions to return"),
         offset: z2.coerce.number().default(0).describe("Number of suggestions to skip (for pagination)"),
-        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion")
+        detail: z2.boolean().default(false).describe("Include per-layer score breakdown for each suggestion"),
+        note_path: z2.string().optional().describe("Path of the note being analyzed (enables strictness override for daily notes)")
       },
       outputSchema: SuggestWikilinksOutputSchema
     },
-    async ({ text, limit: requestedLimit, offset, detail }) => {
+    async ({ text, limit: requestedLimit, offset, detail, note_path }) => {
       const limit = Math.min(requestedLimit ?? 50, MAX_LIMIT);
       const index = getIndex();
       const allMatches = findEntityMatches(text, index.entities);
@@ -7865,7 +8034,8 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
         const scored = await suggestRelatedLinks(text, {
           detail: true,
           maxSuggestions: limit,
-          strictness: "balanced"
+          strictness: "balanced",
+          ...note_path ? { notePath: note_path } : {}
         });
         if (scored.detailed) {
           output.scored_suggestions = scored.detailed;
@@ -12888,7 +13058,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       preserveListNesting: z11.boolean().default(true).describe("Detect and preserve the indentation level of surrounding list items. Set false to disable."),
       bumpHeadings: z11.boolean().default(true).describe("Auto-bump heading levels in inserted content so they nest under the target section (e.g., ## in a ## section becomes ###). Set false to disable."),
       suggestOutgoingLinks: z11.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Set false to disable.'),
-      maxSuggestions: z11.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      maxSuggestions: z11.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       validate: z11.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
       normalize: z11.boolean().default(true).describe("Auto-fix common issues before formatting (replace \u2022 with -, trim excessive whitespace, etc.)"),
       guardrails: z11.enum(["warn", "strict", "off"]).default("warn").describe('Output validation mode: "warn" returns issues but proceeds, "strict" blocks on errors, "off" disables'),
@@ -13034,7 +13204,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
       commit: z11.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z11.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text"),
       suggestOutgoingLinks: z11.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Set false to disable.'),
-      maxSuggestions: z11.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      maxSuggestions: z11.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       validate: z11.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
       normalize: z11.boolean().default(true).describe("Auto-fix common issues before formatting (replace \u2022 with -, trim excessive whitespace, etc.)"),
       guardrails: z11.enum(["warn", "strict", "off"]).default("warn").describe('Output validation mode: "warn" returns issues but proceeds, "strict" blocks on errors, "off" disables'),
@@ -13062,7 +13232,7 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
             throw new Error(validationResult.blockReason || "Output validation failed");
           }
           let workingReplacement = validationResult.content;
-          let { content: processedReplacement } = maybeApplyWikilinks(workingReplacement, skipWikilinks, notePath);
+          let { content: processedReplacement } = maybeApplyWikilinks(workingReplacement, skipWikilinks, notePath, ctx.content);
           if (suggestOutgoingLinks && !skipWikilinks && processedReplacement.length >= 100) {
             const result = await suggestRelatedLinks(processedReplacement, { maxSuggestions, notePath });
             if (result.suffix) {
@@ -13232,7 +13402,7 @@ function registerTaskTools(server2, vaultPath2) {
       commit: z12.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z12.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
       suggestOutgoingLinks: z12.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]"). Set false to disable.'),
-      maxSuggestions: z12.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      maxSuggestions: z12.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       preserveListNesting: z12.boolean().default(true).describe("Preserve indentation when inserting into nested lists. Default: true"),
       validate: z12.boolean().default(true).describe("Check input for common issues"),
       normalize: z12.boolean().default(true).describe("Auto-fix common issues before formatting"),
@@ -13373,7 +13543,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
       commit: z14.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z14.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
       suggestOutgoingLinks: z14.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]], [[Philosophy]]").'),
-      maxSuggestions: z14.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      maxSuggestions: z14.number().min(1).max(10).default(5).describe("Maximum number of suggested wikilinks to append (1-10, default: 5)"),
       agent_id: z14.string().optional().describe("Agent identifier for multi-agent scoping"),
       session_id: z14.string().optional().describe("Session identifier for conversation scoping")
     },
@@ -15857,7 +16027,7 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
       title: "Wikilink Feedback",
       description: 'Report and query wikilink accuracy feedback. Modes: "report" (record feedback), "list" (view recent feedback), "stats" (entity accuracy statistics), "dashboard" (full feedback loop data), "entity_timeline" (score history for an entity), "layer_timeseries" (per-layer contribution over time), "snapshot_diff" (compare two graph snapshots).',
       inputSchema: {
-        mode: z21.enum(["report", "list", "stats", "dashboard", "entity_timeline", "layer_timeseries", "snapshot_diff"]).describe("Operation mode"),
+        mode: z21.enum(["report", "list", "stats", "dashboard", "entity_timeline", "layer_timeseries", "snapshot_diff", "suppress", "unsuppress"]).describe("Operation mode"),
         entity: z21.string().optional().describe("Entity name (required for report and entity_timeline modes, optional filter for list/stats)"),
         note_path: z21.string().optional().describe("Note path where the wikilink appeared (for report mode)"),
         context: z21.string().optional().describe("Surrounding text context (for report mode)"),
@@ -15904,6 +16074,9 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
             ).run(entity, note_path);
           }
           const suppressionUpdated = updateSuppressionList(stateDb2) > 0;
+          if (!correct) {
+            suppressEntity(stateDb2, entity);
+          }
           result = {
             mode: "report",
             reported: {
@@ -15982,6 +16155,38 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
           };
           break;
         }
+        case "suppress": {
+          if (!entity) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "entity is required for suppress mode" }) }],
+              isError: true
+            };
+          }
+          suppressEntity(stateDb2, entity);
+          result = {
+            mode: "suppress",
+            entity,
+            suppressed: true,
+            total_suppressed: getSuppressedCount(stateDb2)
+          };
+          break;
+        }
+        case "unsuppress": {
+          if (!entity) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "entity is required for unsuppress mode" }) }],
+              isError: true
+            };
+          }
+          const wasRemoved = unsuppressEntity(stateDb2, entity);
+          result = {
+            mode: "unsuppress",
+            entity,
+            was_suppressed: wasRemoved,
+            total_suppressed: getSuppressedCount(stateDb2)
+          };
+          break;
+        }
       }
       return {
         content: [
@@ -15995,8 +16200,142 @@ function registerWikilinkFeedbackTools(server2, getStateDb) {
   );
 }
 
-// src/tools/write/config.ts
+// src/tools/write/corrections.ts
 import { z as z22 } from "zod";
+
+// src/core/write/corrections.ts
+function recordCorrection(stateDb2, type, description, source = "user", entity, notePath) {
+  const result = stateDb2.db.prepare(`
+    INSERT INTO corrections (entity, note_path, correction_type, description, source)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(entity ?? null, notePath ?? null, type, description, source);
+  return stateDb2.db.prepare(
+    "SELECT * FROM corrections WHERE id = ?"
+  ).get(result.lastInsertRowid);
+}
+function listCorrections(stateDb2, status, entity, limit = 50) {
+  const conditions = [];
+  const params = [];
+  if (status) {
+    conditions.push("status = ?");
+    params.push(status);
+  }
+  if (entity) {
+    conditions.push("entity = ? COLLATE NOCASE");
+    params.push(entity);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit);
+  return stateDb2.db.prepare(
+    `SELECT * FROM corrections ${where} ORDER BY created_at DESC LIMIT ?`
+  ).all(...params);
+}
+function resolveCorrection(stateDb2, id, newStatus) {
+  const result = stateDb2.db.prepare(`
+    UPDATE corrections
+    SET status = ?, resolved_at = datetime('now')
+    WHERE id = ?
+  `).run(newStatus, id);
+  return result.changes > 0;
+}
+
+// src/tools/write/corrections.ts
+function registerCorrectionTools(server2, getStateDb) {
+  server2.tool(
+    "vault_record_correction",
+    'Record a persistent correction (e.g., "that link is wrong", "undo that"). Survives across sessions.',
+    {
+      correction_type: z22.enum(["wrong_link", "wrong_entity", "wrong_category", "general"]).describe("Type of correction"),
+      description: z22.string().describe("What went wrong and what should be done"),
+      entity: z22.string().optional().describe("Entity name (if correction is about a specific entity)"),
+      note_path: z22.string().optional().describe("Note path (if correction is about a specific note)")
+    },
+    async ({ correction_type, description, entity, note_path }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const correction = recordCorrection(stateDb2, correction_type, description, "user", entity, note_path);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            recorded: true,
+            correction
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "vault_list_corrections",
+    "List recorded corrections, optionally filtered by status or entity.",
+    {
+      status: z22.enum(["pending", "applied", "dismissed"]).optional().describe("Filter by status"),
+      entity: z22.string().optional().describe("Filter by entity name"),
+      limit: z22.number().min(1).max(200).default(50).describe("Max entries to return")
+    },
+    async ({ status, entity, limit }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const corrections = listCorrections(stateDb2, status, entity, limit);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            corrections,
+            count: corrections.length
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "vault_resolve_correction",
+    "Resolve a correction by marking it as applied or dismissed.",
+    {
+      correction_id: z22.number().describe("ID of the correction to resolve"),
+      status: z22.enum(["applied", "dismissed"]).describe("New status")
+    },
+    async ({ correction_id, status }) => {
+      const stateDb2 = getStateDb();
+      if (!stateDb2) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "StateDb not available" }) }],
+          isError: true
+        };
+      }
+      const resolved = resolveCorrection(stateDb2, correction_id, status);
+      if (!resolved) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Correction ${correction_id} not found` }) }],
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            resolved: true,
+            correction_id,
+            status
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/write/config.ts
+import { z as z23 } from "zod";
 import { saveFlywheelConfigToDb as saveFlywheelConfigToDb2 } from "@velvetmonkey/vault-core";
 function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
   server2.registerTool(
@@ -16005,9 +16344,9 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
       title: "Flywheel Config",
       description: 'Read or update Flywheel configuration.\n- "get": Returns the current FlywheelConfig\n- "set": Updates a single config key and returns the updated config\n\nExample: flywheel_config({ mode: "get" })\nExample: flywheel_config({ mode: "set", key: "exclude_analysis_tags", value: ["habit", "daily"] })',
       inputSchema: {
-        mode: z22.enum(["get", "set"]).describe("Operation mode"),
-        key: z22.string().optional().describe("Config key to update (required for set mode)"),
-        value: z22.unknown().optional().describe("New value for the key (required for set mode)")
+        mode: z23.enum(["get", "set"]).describe("Operation mode"),
+        key: z23.string().optional().describe("Config key to update (required for set mode)"),
+        value: z23.unknown().optional().describe("New value for the key (required for set mode)")
       }
     },
     async ({ mode, key, value }) => {
@@ -16045,7 +16384,7 @@ function registerConfigTools(server2, getConfig, setConfig, getStateDb) {
 }
 
 // src/tools/write/enrich.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 import * as fs29 from "fs/promises";
 import * as path30 from "path";
 function hasSkipWikilinks(content) {
@@ -16100,9 +16439,9 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
     "vault_init",
     "Initialize vault for Flywheel \u2014 scans legacy notes with zero wikilinks and applies entity links. Safe to re-run (idempotent). Use dry_run (default) to preview.",
     {
-      dry_run: z23.boolean().default(true).describe("If true (default), preview what would be linked without modifying files"),
-      batch_size: z23.number().default(50).describe("Maximum notes to process per invocation (default: 50)"),
-      offset: z23.number().default(0).describe("Skip this many eligible notes (for pagination across invocations)")
+      dry_run: z24.boolean().default(true).describe("If true (default), preview what would be linked without modifying files"),
+      batch_size: z24.number().default(50).describe("Maximum notes to process per invocation (default: 50)"),
+      offset: z24.number().default(0).describe("Skip this many eligible notes (for pagination across invocations)")
     },
     async ({ dry_run, batch_size, offset }) => {
       const startTime = Date.now();
@@ -16197,7 +16536,7 @@ function registerInitTools(server2, vaultPath2, getStateDb) {
 }
 
 // src/tools/read/metrics.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/core/shared/metrics.ts
 var ALL_METRICS = [
@@ -16363,10 +16702,10 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
       title: "Vault Growth",
       description: 'Track vault growth over time. Modes: "current" (live snapshot), "history" (time series), "trends" (deltas vs N days ago), "index_activity" (rebuild history). Tracks 11 metrics: note_count, link_count, orphan_count, tag_count, entity_count, avg_links_per_note, link_density, connected_ratio, wikilink_accuracy, wikilink_feedback_volume, wikilink_suppressed_count.',
       inputSchema: {
-        mode: z24.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
-        metric: z24.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
-        days_back: z24.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
-        limit: z24.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
+        mode: z25.enum(["current", "history", "trends", "index_activity"]).describe("Query mode: current snapshot, historical time series, trend analysis, or index rebuild activity"),
+        metric: z25.string().optional().describe('Filter to specific metric (e.g., "note_count"). Omit for all metrics.'),
+        days_back: z25.number().optional().describe("Number of days to look back for history/trends (default: 30)"),
+        limit: z25.number().optional().describe("Number of recent events to return for index_activity mode (default: 20)")
       }
     },
     async ({ mode, metric, days_back, limit: eventLimit }) => {
@@ -16439,7 +16778,7 @@ function registerMetricsTools(server2, getIndex, getStateDb) {
 }
 
 // src/tools/read/activity.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/core/shared/toolTracking.ts
 function recordToolInvocation(stateDb2, event) {
@@ -16599,10 +16938,10 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
       title: "Vault Activity",
       description: 'Track tool usage patterns and session activity. Modes:\n- "session": Current session summary (tools called, notes accessed)\n- "sessions": List of recent sessions\n- "note_access": Notes ranked by query frequency\n- "tool_usage": Tool usage patterns (most-used tools, avg duration)',
       inputSchema: {
-        mode: z25.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
-        session_id: z25.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
-        days_back: z25.number().optional().describe("Number of days to look back (default: 30)"),
-        limit: z25.number().optional().describe("Maximum results to return (default: 20)")
+        mode: z26.enum(["session", "sessions", "note_access", "tool_usage"]).describe("Activity query mode"),
+        session_id: z26.string().optional().describe("Specific session ID (for session mode, defaults to current)"),
+        days_back: z26.number().optional().describe("Number of days to look back (default: 30)"),
+        limit: z26.number().optional().describe("Maximum results to return (default: 20)")
       }
     },
     async ({ mode, session_id, days_back, limit: resultLimit }) => {
@@ -16669,7 +17008,7 @@ function registerActivityTools(server2, getStateDb, getSessionId2) {
 }
 
 // src/tools/read/similarity.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/core/read/similarity.ts
 import * as fs30 from "fs";
@@ -16933,9 +17272,9 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
       title: "Find Similar Notes",
       description: "Find notes similar to a given note using FTS5 keyword matching. When embeddings have been built (via init_semantic), automatically uses hybrid ranking (BM25 + embedding similarity via Reciprocal Rank Fusion). Use exclude_linked to filter out notes already connected via wikilinks.",
       inputSchema: {
-        path: z26.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
-        limit: z26.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
-        exclude_linked: z26.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
+        path: z27.string().describe('Path to the source note (relative to vault root, e.g. "projects/alpha.md")'),
+        limit: z27.number().optional().describe("Maximum number of similar notes to return (default: 10)"),
+        exclude_linked: z27.boolean().optional().describe("Exclude notes already linked to/from the source note (default: true)")
       }
     },
     async ({ path: path33, limit, exclude_linked }) => {
@@ -16979,7 +17318,7 @@ function registerSimilarityTools(server2, getIndex, getVaultPath, getStateDb) {
 }
 
 // src/tools/read/semantic.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 import { getAllEntitiesFromDb } from "@velvetmonkey/vault-core";
 function registerSemanticTools(server2, getVaultPath, getStateDb) {
   server2.registerTool(
@@ -16988,7 +17327,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
       title: "Initialize Semantic Search",
       description: "Download the embedding model and build semantic search index for this vault. After running, search and find_similar automatically use hybrid ranking (BM25 + semantic). Run once per vault \u2014 subsequent calls skip already-embedded notes unless force=true.",
       inputSchema: {
-        force: z27.boolean().optional().describe(
+        force: z28.boolean().optional().describe(
           "Rebuild all embeddings even if they already exist (default: false)"
         )
       }
@@ -17068,7 +17407,7 @@ function registerSemanticTools(server2, getVaultPath, getStateDb) {
 
 // src/tools/read/merges.ts
 init_levenshtein();
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 import { getAllEntitiesFromDb as getAllEntitiesFromDb2, getDismissedMergePairs, recordMergeDismissal } from "@velvetmonkey/vault-core";
 function normalizeName(name) {
   return name.toLowerCase().replace(/[.\-_]/g, "").replace(/js$/, "").replace(/ts$/, "");
@@ -17078,7 +17417,7 @@ function registerMergeTools2(server2, getStateDb) {
     "suggest_entity_merges",
     "Find potential duplicate entities that could be merged based on name similarity",
     {
-      limit: z28.number().optional().default(50).describe("Maximum number of suggestions to return")
+      limit: z29.number().optional().default(50).describe("Maximum number of suggestions to return")
     },
     async ({ limit }) => {
       const stateDb2 = getStateDb();
@@ -17180,11 +17519,11 @@ function registerMergeTools2(server2, getStateDb) {
     "dismiss_merge_suggestion",
     "Permanently dismiss a merge suggestion so it never reappears",
     {
-      source_path: z28.string().describe("Path of the source entity"),
-      target_path: z28.string().describe("Path of the target entity"),
-      source_name: z28.string().describe("Name of the source entity"),
-      target_name: z28.string().describe("Name of the target entity"),
-      reason: z28.string().describe("Original suggestion reason")
+      source_path: z29.string().describe("Path of the source entity"),
+      target_path: z29.string().describe("Path of the target entity"),
+      source_name: z29.string().describe("Name of the source entity"),
+      target_name: z29.string().describe("Name of the target entity"),
+      reason: z29.string().describe("Original suggestion reason")
     },
     async ({ source_path, target_path, source_name, target_name, reason }) => {
       const stateDb2 = getStateDb();
@@ -17583,6 +17922,7 @@ registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
 registerTagTools(server, () => vaultIndex, () => vaultPath);
 registerWikilinkFeedbackTools(server, () => stateDb);
+registerCorrectionTools(server, () => stateDb);
 registerInitTools(server, vaultPath, () => stateDb);
 registerConfigTools(
   server,
@@ -18259,7 +18599,7 @@ async function runPostIndexWork(index) {
                   (e) => e.nameLower === link || (e.aliases ?? []).some((a) => a.toLowerCase() === link)
                 );
                 if (entity) {
-                  recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true);
+                  recordFeedback(stateDb, entity.name, "implicit:kept", entry.file, true, 0.8);
                   markPositive.run(entry.file, link);
                 }
               }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.47",
+  "version": "2.0.49",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. Select from 42 tools for search, backlinks, graph queries, mutations, and hybrid semantic search.",
   "type": "module",
   "main": "dist/index.js",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.47",
+    "@velvetmonkey/vault-core": "^2.0.49",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",