@velvetmonkey/flywheel-memory 2.0.48 → 2.0.50

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);
@@ -3607,26 +3706,20 @@ function unsuppressEntity(stateDb2, entity) {
   ).run(entity);
   return result.changes > 0;
 }
-function isSuppressed(stateDb2, entity, folder) {
+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;
       }
     }
@@ -3656,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)
@@ -3730,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 = ?"
@@ -3783,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);
       }
@@ -3806,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);
@@ -5271,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",
@@ -5300,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 {
@@ -5329,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)) {
@@ -5341,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);
           }
         }
       }
@@ -5362,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,
@@ -5369,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
@@ -5964,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,
@@ -5977,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,
@@ -6125,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 };
@@ -6137,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;
     }
@@ -6164,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;
     }
@@ -6189,7 +6335,7 @@ function getEdgeWeightBoostScore(entityName, map) {
 }
 async function suggestRelatedLinks(content, options = {}) {
   const {
-    maxSuggestions = 3,
+    maxSuggestions = 8,
     excludeLinked = true,
     strictness = getEffectiveStrictness(options.notePath),
     notePath,
@@ -6231,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();
@@ -6247,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);
@@ -6272,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 || "",
@@ -6290,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) {
@@ -6317,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 || "",
@@ -6344,6 +6500,7 @@ async function suggestRelatedLinks(content, options = {}) {
                 crossFolderBoost,
                 hubBoost,
                 feedbackAdjustment: feedbackAdj,
+                suppressionPenalty: suppPenalty,
                 edgeWeightBoost
               }
             });
@@ -6370,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
           );
@@ -6387,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,
@@ -6403,6 +6557,7 @@ async function suggestRelatedLinks(content, options = {}) {
                 crossFolderBoost: layerCrossFolderBoost,
                 hubBoost: layerHubBoost,
                 feedbackAdjustment: layerFeedbackAdj,
+                suppressionPenalty: layerSuppPenalty,
                 semanticBoost: boost,
                 edgeWeightBoost: layerEdgeWeightBoost
               }
@@ -7226,7 +7381,7 @@ function refreshIfStale(vaultPath2, index, excludeTags) {
 }
 
 // src/index.ts
-import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3, findEntityMatches as findEntityMatches2, getProtectedZones as getProtectedZones2, rangeOverlapsProtectedZone } from "@velvetmonkey/vault-core";
+import { openStateDb, scanVaultEntities as scanVaultEntities3, getSessionId, getAllEntitiesFromDb as getAllEntitiesFromDb3, findEntityMatches as findEntityMatches2, getProtectedZones as getProtectedZones2, rangeOverlapsProtectedZone, detectImplicitEntities as detectImplicitEntities3 } from "@velvetmonkey/vault-core";
 
 // src/tools/read/graph.ts
 import * as fs9 from "fs";
@@ -7754,6 +7909,7 @@ function registerGraphTools(server2, getIndex, getVaultPath, getStateDb) {
 
 // src/tools/read/wikilinks.ts
 import { z as z2 } from "zod";
+import { detectImplicitEntities as detectImplicitEntities2 } from "@velvetmonkey/vault-core";
 function findEntityMatches(text, entities) {
   const matches = [];
   const sortedEntities = Array.from(entities.entries()).filter(([name]) => name.length >= 2).sort((a, b) => b[0].length - a[0].length);
@@ -7868,12 +8024,69 @@ function registerWikilinkTools(server2, getIndex, getVaultPath) {
       const index = getIndex();
       const allMatches = findEntityMatches(text, index.entities);
       const matches = allMatches.slice(offset, offset + limit);
+      const linkedSet = new Set(allMatches.map((m) => m.entity.toLowerCase()));
+      const prospects = [];
+      const prospectSeen = /* @__PURE__ */ new Set();
+      for (const [target, links] of index.backlinks) {
+        if (links.length < 2) continue;
+        if (index.entities.has(target.toLowerCase())) continue;
+        if (linkedSet.has(target.toLowerCase())) continue;
+        const targetLower = target.toLowerCase();
+        const textLower = text.toLowerCase();
+        let searchPos = 0;
+        while (searchPos < textLower.length) {
+          const pos = textLower.indexOf(targetLower, searchPos);
+          if (pos === -1) break;
+          const end = pos + target.length;
+          const before = pos > 0 ? text[pos - 1] : " ";
+          const after = end < text.length ? text[end] : " ";
+          if (/[\s\n\r.,;:!?()[\]{}'"<>-]/.test(before) && /[\s\n\r.,;:!?()[\]{}'"<>-]/.test(after)) {
+            if (!prospectSeen.has(targetLower)) {
+              prospectSeen.add(targetLower);
+              prospects.push({
+                entity: text.substring(pos, end),
+                start: pos,
+                end,
+                source: "dead_link",
+                confidence: links.length >= 3 ? "high" : "medium",
+                backlink_count: links.length
+              });
+            }
+            break;
+          }
+          searchPos = pos + 1;
+        }
+      }
+      const implicit = detectImplicitEntities2(text);
+      for (const imp of implicit) {
+        const impLower = imp.text.toLowerCase();
+        if (linkedSet.has(impLower)) continue;
+        if (prospectSeen.has(impLower)) {
+          const existing = prospects.find((p) => p.entity.toLowerCase() === impLower);
+          if (existing) {
+            existing.source = "both";
+            existing.confidence = "high";
+          }
+          continue;
+        }
+        prospectSeen.add(impLower);
+        prospects.push({
+          entity: imp.text,
+          start: imp.start,
+          end: imp.end,
+          source: "implicit",
+          confidence: "low"
+        });
+      }
       const output = {
         input_length: text.length,
         suggestion_count: allMatches.length,
         returned_count: matches.length,
         suggestions: matches
       };
+      if (prospects.length > 0) {
+        output.prospects = prospects;
+      }
       if (detail) {
         const scored = await suggestRelatedLinks(text, {
           detail: true,
@@ -12901,7 +13114,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'),
@@ -13047,7 +13260,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'),
@@ -13245,7 +13458,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"),
@@ -13386,7 +13599,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")
     },
@@ -18442,7 +18655,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);
                 }
               }
@@ -18468,14 +18681,22 @@ async function runPostIndexWork(index) {
             }
           }
         }
+        const newDeadLinks = [];
+        for (const diff of linkDiffs) {
+          const newDead = diff.added.filter((target) => !vaultIndex.entities.has(target.toLowerCase()));
+          if (newDead.length > 0) {
+            newDeadLinks.push({ file: diff.file, targets: newDead });
+          }
+        }
         tracker.end({
           total_resolved: totalResolved,
           total_dead: totalDead,
           links: forwardLinkResults,
           link_diffs: linkDiffs,
-          survived: survivedLinks
+          survived: survivedLinks,
+          new_dead_links: newDeadLinks
         });
-        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead`);
+        serverLog("watcher", `Forward links: ${totalResolved} resolved, ${totalDead} dead${newDeadLinks.length > 0 ? `, ${newDeadLinks.reduce((s, d) => s + d.targets.length, 0)} new dead` : ""}`);
         tracker.start("wikilink_check", { files: filteredEvents.length });
         const trackedLinks = [];
         if (stateDb) {
@@ -18539,6 +18760,7 @@ async function runPostIndexWork(index) {
         tracker.end({ tracked: trackedLinks, mentions: mentionResults });
         serverLog("watcher", `Wikilink check: ${trackedLinks.reduce((s, t) => s + t.entities.length, 0)} tracked links in ${trackedLinks.length} files, ${mentionResults.reduce((s, m) => s + m.entities.length, 0)} unwikified mentions`);
         tracker.start("implicit_feedback", { files: filteredEvents.length });
+        const preSuppressed = stateDb ? new Set(getAllSuppressionPenalties(stateDb).keys()) : /* @__PURE__ */ new Set();
         const feedbackResults = [];
         if (stateDb) {
           for (const event of filteredEvents) {
@@ -18583,10 +18805,84 @@ async function runPostIndexWork(index) {
             }
           }
         }
-        tracker.end({ removals: feedbackResults, additions: additionResults });
+        const newlySuppressed = [];
+        if (stateDb) {
+          const postSuppressed = getAllSuppressionPenalties(stateDb);
+          for (const entity of postSuppressed.keys()) {
+            if (!preSuppressed.has(entity)) {
+              newlySuppressed.push(entity);
+            }
+          }
+        }
+        tracker.end({ removals: feedbackResults, additions: additionResults, newly_suppressed: newlySuppressed });
         if (feedbackResults.length > 0 || additionResults.length > 0) {
           serverLog("watcher", `Implicit feedback: ${feedbackResults.length} removals, ${additionResults.length} manual additions detected`);
         }
+        if (newlySuppressed.length > 0) {
+          serverLog("watcher", `Suppression: ${newlySuppressed.length} entities newly suppressed: ${newlySuppressed.join(", ")}`);
+        }
+        tracker.start("prospect_scan", { files: filteredEvents.length });
+        const prospectResults = [];
+        for (const event of filteredEvents) {
+          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+          try {
+            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const zones = getProtectedZones2(content);
+            const linkedSet = new Set(
+              (forwardLinkResults.find((r) => r.file === event.path)?.resolved ?? []).concat(forwardLinkResults.find((r) => r.file === event.path)?.dead ?? []).map((n) => n.toLowerCase())
+            );
+            const knownEntitySet = new Set(entitiesAfter.map((e) => e.nameLower));
+            const implicitMatches = detectImplicitEntities3(content);
+            const implicitNames = implicitMatches.filter((imp) => !linkedSet.has(imp.text.toLowerCase()) && !knownEntitySet.has(imp.text.toLowerCase())).map((imp) => imp.text);
+            const deadLinkMatches = [];
+            for (const [key, links] of vaultIndex.backlinks) {
+              if (links.length < 2 || vaultIndex.entities.has(key) || linkedSet.has(key)) continue;
+              const matches = findEntityMatches2(content, key, true);
+              if (matches.some((m) => !rangeOverlapsProtectedZone(m.start, m.end, zones))) {
+                deadLinkMatches.push(key);
+              }
+            }
+            if (implicitNames.length > 0 || deadLinkMatches.length > 0) {
+              prospectResults.push({ file: event.path, implicit: implicitNames, deadLinkMatches });
+            }
+          } catch {
+          }
+        }
+        tracker.end({ prospects: prospectResults });
+        if (prospectResults.length > 0) {
+          const implicitCount = prospectResults.reduce((s, p) => s + p.implicit.length, 0);
+          const deadCount = prospectResults.reduce((s, p) => s + p.deadLinkMatches.length, 0);
+          serverLog("watcher", `Prospect scan: ${implicitCount} implicit entities, ${deadCount} dead link matches across ${prospectResults.length} files`);
+        }
+        tracker.start("suggestion_scoring", { files: filteredEvents.length });
+        const suggestionResults = [];
+        for (const event of filteredEvents) {
+          if (event.type === "delete" || !event.path.endsWith(".md")) continue;
+          try {
+            const content = await fs31.readFile(path32.join(vaultPath, event.path), "utf-8");
+            const result = await suggestRelatedLinks(content, {
+              maxSuggestions: 5,
+              strictness: "balanced",
+              notePath: event.path,
+              detail: true
+            });
+            if (result.detailed && result.detailed.length > 0) {
+              suggestionResults.push({
+                file: event.path,
+                top: result.detailed.slice(0, 5).map((s) => ({
+                  entity: s.entity,
+                  score: s.totalScore,
+                  confidence: s.confidence
+                }))
+              });
+            }
+          } catch {
+          }
+        }
+        tracker.end({ scored_files: suggestionResults.length, suggestions: suggestionResults });
+        if (suggestionResults.length > 0) {
+          serverLog("watcher", `Suggestion scoring: ${suggestionResults.length} files scored`);
+        }
         tracker.start("tag_scan", { files: filteredEvents.length });
         const tagDiffs = [];
         if (stateDb) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.48",
+  "version": "2.0.50",
   "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.48",
+    "@velvetmonkey/vault-core": "^2.0.50",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",