@velvetmonkey/flywheel-memory 2.0.150 → 2.0.152

package/dist/index.js

@@ -127,6 +127,50 @@ var init_levenshtein = __esm({
   }
 });
 
+// src/core/shared/serverLog.ts
+function serverLog(component, message, level = "info") {
+  const entry = {
+    ts: Date.now(),
+    component,
+    message,
+    level
+  };
+  buffer.push(entry);
+  if (buffer.length > MAX_ENTRIES) {
+    buffer.shift();
+  }
+  const now = /* @__PURE__ */ new Date();
+  const hms = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
+  const prefix = level === "error" ? "[Memory] ERROR" : level === "warn" ? "[Memory] WARN" : "[Memory]";
+  console.error(`${prefix} [${hms}] [${component}] ${message}`);
+}
+function getServerLog(options = {}) {
+  const { since, component, limit = 100 } = options;
+  let entries = buffer;
+  if (since) {
+    entries = entries.filter((e) => e.ts > since);
+  }
+  if (component) {
+    entries = entries.filter((e) => e.component === component);
+  }
+  if (entries.length > limit) {
+    entries = entries.slice(-limit);
+  }
+  return {
+    entries,
+    server_uptime_ms: Date.now() - serverStartTs
+  };
+}
+var MAX_ENTRIES, buffer, serverStartTs;
+var init_serverLog = __esm({
+  "src/core/shared/serverLog.ts"() {
+    "use strict";
+    MAX_ENTRIES = 200;
+    buffer = [];
+    serverStartTs = Date.now();
+  }
+});
+
 // src/vault-scope.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 function getActiveScopeOrNull() {
@@ -280,7 +324,27 @@ async function embedTextCached(text) {
   return embedding;
 }
 function contentHash(content) {
-  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return crypto.createHash("sha256").update(content + EMBEDDING_TEXT_VERSION).digest("hex").slice(0, 16);
+}
+function buildNoteEmbeddingText(content, filePath) {
+  const title = filePath.replace(/\.md$/, "").split("/").pop() || "";
+  const fmMatch = content.match(/^---[\s\S]*?---\n([\s\S]*)$/);
+  const body = fmMatch ? fmMatch[1] : content;
+  const frontmatter = fmMatch ? content.slice(0, content.indexOf("---", 3) + 3) : "";
+  const tags = [];
+  const arrayMatch = frontmatter.match(/^tags:\s*\[([^\]]*)\]/m);
+  if (arrayMatch) {
+    tags.push(...arrayMatch[1].split(",").map((t) => t.trim().replace(/['"]/g, "")).filter(Boolean));
+  } else {
+    const listMatch = frontmatter.match(/^tags:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (listMatch) {
+      const items = listMatch[1].matchAll(/^\s+-\s+(.+)/gm);
+      for (const m of items) tags.push(m[1].trim().replace(/['"]/g, ""));
+    }
+  }
+  const parts = [`Note: ${title}`];
+  if (tags.length > 0) parts.push(`Tags: ${tags.slice(0, 5).join(", ")}`);
+  return parts.join(". ") + ".\n\n" + body;
 }
 function shouldIndexFile(filePath) {
   const parts = filePath.split("/");
@@ -321,7 +385,7 @@ async function buildEmbeddingsIndex(vaultPath2, onProgress) {
         if (onProgress) onProgress(progress);
         continue;
       }
-      const embedding = await embedText(content);
+      const embedding = await embedText(buildNoteEmbeddingText(content, file.path));
       const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
       upsert.run(file.path, buf, hash, activeModelConfig.id, Date.now());
     } catch (err) {
@@ -351,7 +415,7 @@ async function updateEmbedding(notePath, absolutePath) {
     const hash = contentHash(content);
     const existing = db4.prepare("SELECT content_hash FROM note_embeddings WHERE path = ?").get(notePath);
     if (existing?.content_hash === hash) return;
-    const embedding = await embedText(content);
+    const embedding = await embedText(buildNoteEmbeddingText(content, notePath));
     const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
     db4.prepare(`
       INSERT OR REPLACE INTO note_embeddings (path, embedding, content_hash, model, updated_at)
@@ -652,7 +716,7 @@ function getEntityEmbeddingsCount() {
     return 0;
   }
 }
-var MODEL_REGISTRY, DEFAULT_MODEL, activeModelConfig, EXCLUDED_DIRS2, MAX_FILE_SIZE2, db, pipeline, initPromise, embeddingsBuilding, embeddingCache, EMBEDDING_CACHE_MAX, entityEmbeddingsMap;
+var MODEL_REGISTRY, DEFAULT_MODEL, activeModelConfig, EXCLUDED_DIRS2, MAX_FILE_SIZE2, db, pipeline, initPromise, embeddingsBuilding, embeddingCache, EMBEDDING_CACHE_MAX, entityEmbeddingsMap, EMBEDDING_TEXT_VERSION;
 var init_embeddings = __esm({
   "src/core/read/embeddings.ts"() {
     "use strict";
@@ -683,50 +747,7 @@ var init_embeddings = __esm({
     embeddingCache = /* @__PURE__ */ new Map();
     EMBEDDING_CACHE_MAX = 500;
     entityEmbeddingsMap = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/core/shared/serverLog.ts
-function serverLog(component, message, level = "info") {
-  const entry = {
-    ts: Date.now(),
-    component,
-    message,
-    level
-  };
-  buffer.push(entry);
-  if (buffer.length > MAX_ENTRIES) {
-    buffer.shift();
-  }
-  const now = /* @__PURE__ */ new Date();
-  const hms = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
-  const prefix = level === "error" ? "[Memory] ERROR" : level === "warn" ? "[Memory] WARN" : "[Memory]";
-  console.error(`${prefix} [${hms}] [${component}] ${message}`);
-}
-function getServerLog(options = {}) {
-  const { since, component, limit = 100 } = options;
-  let entries = buffer;
-  if (since) {
-    entries = entries.filter((e) => e.ts > since);
-  }
-  if (component) {
-    entries = entries.filter((e) => e.component === component);
-  }
-  if (entries.length > limit) {
-    entries = entries.slice(-limit);
-  }
-  return {
-    entries,
-    server_uptime_ms: Date.now() - serverStartTs
-  };
-}
-var MAX_ENTRIES, buffer, serverStartTs;
-var init_serverLog = __esm({
-  "src/core/shared/serverLog.ts"() {
-    "use strict";
-    MAX_ENTRIES = 200;
-    buffer = [];
-    serverStartTs = Date.now();
+    EMBEDDING_TEXT_VERSION = 2;
   }
 });
 
@@ -810,8 +831,8 @@ function getRecencyBoost(entityName, index) {
   if (ageHours < 168) return 1;
   return 0;
 }
-function loadRecencyFromStateDb() {
-  const stateDb2 = getStateDb();
+function loadRecencyFromStateDb(explicitStateDb) {
+  const stateDb2 = explicitStateDb ?? getStateDb();
   if (!stateDb2) return null;
   try {
     const rows = getAllRecencyFromDb(stateDb2);
@@ -833,8 +854,8 @@ function loadRecencyFromStateDb() {
     return null;
   }
 }
-function saveRecencyToStateDb(index) {
-  const stateDb2 = getStateDb();
+function saveRecencyToStateDb(index, explicitStateDb) {
+  const stateDb2 = explicitStateDb ?? getStateDb();
   if (!stateDb2) {
     console.error("[Flywheel] saveRecencyToStateDb: No StateDb available");
     return;
@@ -3487,6 +3508,7 @@ function isValidWikilinkText(text) {
   if (target !== target.trim()) return false;
   const trimmed = target.trim();
   if (trimmed.length === 0) return false;
+  if (/\n/.test(trimmed)) return false;
   if (/[?!;]/.test(trimmed)) return false;
   if (/[,.]$/.test(trimmed)) return false;
   if (trimmed.includes(">")) return false;
@@ -3501,7 +3523,9 @@ function isValidWikilinkText(text) {
 }
 function sanitizeWikilinks(content) {
   const removed = [];
-  const sanitized = content.replace(/\[\[([^\]]+?)\]\]/g, (fullMatch, inner) => {
+  let repaired = content.replace(/\[\s*\n\s*\[/g, "[[");
+  repaired = repaired.replace(/\]\s*\n\s*\]/g, "]]");
+  const sanitized = repaired.replace(/\[\[([^\]]+?)\]\]/g, (fullMatch, inner) => {
     if (isValidWikilinkText(inner)) {
       return fullMatch;
     }
@@ -4416,7 +4440,7 @@ var init_wikilinks = __esm({
     init_vault_scope();
     moduleStateDb4 = null;
     moduleConfig = null;
-    ALL_IMPLICIT_PATTERNS = ["proper-nouns", "single-caps", "camel-case", "acronyms", "quoted-terms"];
+    ALL_IMPLICIT_PATTERNS = ["proper-nouns", "single-caps", "camel-case", "acronyms", "quoted-terms", "ticket-refs"];
     entityIndex = null;
     indexReady = false;
     indexError2 = null;
@@ -4891,6 +4915,38 @@ function isPreformattedList(content) {
   /^\d+\.\s/.test(firstLine) || // Numbered
   /^[-*+]\s*\[[ xX]\]/.test(firstLine);
 }
+function sanitizeForList(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      result.push(`**${headingMatch[2]}**`);
+      continue;
+    }
+    const starBulletMatch = line.match(/^(\s*)\*\s(.+)$/);
+    if (starBulletMatch) {
+      result.push(`${starBulletMatch[1]}- ${starBulletMatch[2]}`);
+      continue;
+    }
+    if (/^-{3,}$/.test(line.trim()) || /^\*{3,}$/.test(line.trim()) || /^_{3,}$/.test(line.trim())) {
+      result.push("\u2014");
+      continue;
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
 function formatContent(content, format) {
   const trimmed = content.trim();
   if (trimmed === "") {
@@ -4914,9 +4970,10 @@ function formatContent(content, format) {
       return trimmed;
     case "bullet": {
       if (isPreformattedList(trimmed)) {
-        return trimmed;
+        return sanitizeForList(trimmed);
       }
-      const lines = trimmed.split("\n");
+      const sanitized = sanitizeForList(trimmed);
+      const lines = sanitized.split("\n");
       return lines.map((line, i) => {
         if (i === 0) return `- ${line}`;
         if (line === "") return "  ";
@@ -4947,13 +5004,14 @@ function formatContent(content, format) {
     }
     case "timestamp-bullet": {
       if (isPreformattedList(trimmed)) {
-        return trimmed;
+        return sanitizeForList(trimmed);
       }
+      const sanitized = sanitizeForList(trimmed);
       const now = /* @__PURE__ */ new Date();
       const hours = String(now.getHours()).padStart(2, "0");
       const minutes = String(now.getMinutes()).padStart(2, "0");
       const prefix = `- **${hours}:${minutes}** `;
-      const lines = trimmed.split("\n");
+      const lines = sanitized.split("\n");
       const indent = "  ";
       return lines.map((line, i) => {
         if (i === 0) return `${prefix}${line}`;
@@ -6596,6 +6654,7 @@ function createEmptyNote(file) {
 
 // src/core/read/graph.ts
 init_levenshtein();
+init_serverLog();
 init_embeddings();
 init_vault_scope();
 init_levenshtein();
@@ -6664,14 +6723,14 @@ async function buildVaultIndexInternal(vaultPath2, startTime, onProgress) {
         return { file, note };
       })
     );
-    for (const result of results) {
+    for (let j = 0; j < results.length; j++) {
+      const result = results[j];
       if (result.status === "fulfilled") {
         notes.set(result.value.note.path, result.value.note);
       } else {
-        const batchIndex = results.indexOf(result);
-        if (batchIndex >= 0 && batch[batchIndex]) {
-          parseErrors.push(batch[batchIndex].path);
-        }
+        const filePath = batch[j]?.path ?? "<unknown>";
+        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        parseErrors.push({ path: filePath, reason });
       }
       parsedCount++;
     }
@@ -6683,9 +6742,13 @@ async function buildVaultIndexInternal(vaultPath2, startTime, onProgress) {
     }
   }
   if (parseErrors.length > 0) {
-    console.error(`Failed to parse ${parseErrors.length} files:`);
-    for (const errorPath of parseErrors) {
-      console.error(`  - ${errorPath}`);
+    const msg = `Failed to parse ${parseErrors.length} file(s):`;
+    console.error(msg);
+    serverLog("index", msg, "error");
+    for (const err of parseErrors) {
+      const detail = `  - ${err.path}: ${err.reason}`;
+      console.error(detail);
+      serverLog("index", detail, "error");
     }
   }
   const entities = /* @__PURE__ */ new Map();
@@ -7877,7 +7940,8 @@ import {
   rangeOverlapsProtectedZone,
   detectImplicitEntities as detectImplicitEntities2,
   checkDbIntegrity,
-  safeBackupAsync
+  safeBackupAsync,
+  recordEntityMention as recordEntityMention2
 } from "@velvetmonkey/vault-core";
 init_serverLog();
 
@@ -8816,6 +8880,7 @@ var PipelineRunner = class {
       await runStep("forward_links", tracker, { files: p.events.length }, () => this.forwardLinks());
       await this.wikilinkCheck();
       await this.implicitFeedback();
+      await runStep("incremental_recency", tracker, { files: p.events.length }, () => this.incrementalRecency());
       await runStep("corrections", tracker, {}, () => this.corrections());
       await runStep("prospect_scan", tracker, { files: p.events.length }, () => this.prospectScan());
       await this.suggestionScoring();
@@ -8912,9 +8977,19 @@ var PipelineRunner = class {
       const rows = p.sd.db.prepare("SELECT name, hub_score FROM entities").all();
       for (const r of rows) this.hubBefore.set(r.name, r.hub_score);
     }
+    const entityScanAgeMs = p.ctx.lastEntityScanAt > 0 ? Date.now() - p.ctx.lastEntityScanAt : Infinity;
+    if (entityScanAgeMs < 5 * 60 * 1e3) {
+      tracker.start("entity_scan", {});
+      tracker.skip("entity_scan", `cache valid (${Math.round(entityScanAgeMs / 1e3)}s old)`);
+      this.entitiesBefore = p.sd ? getAllEntitiesFromDb(p.sd) : [];
+      this.entitiesAfter = this.entitiesBefore;
+      serverLog("watcher", `Entity scan: throttled (${Math.round(entityScanAgeMs / 1e3)}s old)`);
+      return;
+    }
     this.entitiesBefore = p.sd ? getAllEntitiesFromDb(p.sd) : [];
     tracker.start("entity_scan", { note_count: vaultIndex2.notes.size });
     await p.updateEntitiesInStateDb(p.vp, p.sd);
+    p.ctx.lastEntityScanAt = Date.now();
     this.entitiesAfter = p.sd ? getAllEntitiesFromDb(p.sd) : [];
     const entityDiff = computeEntityDiff(this.entitiesBefore, this.entitiesAfter);
     const categoryChanges = [];
@@ -8951,6 +9026,11 @@ var PipelineRunner = class {
   // ── Step 3: Hub scores ────────────────────────────────────────────
   async hubScores() {
     const { p } = this;
+    const hubAgeMs = p.ctx.lastHubScoreRebuildAt > 0 ? Date.now() - p.ctx.lastHubScoreRebuildAt : Infinity;
+    if (hubAgeMs < 5 * 60 * 1e3) {
+      serverLog("watcher", `Hub scores: throttled (${Math.round(hubAgeMs / 1e3)}s old)`);
+      return { skipped: true, age_ms: hubAgeMs };
+    }
     const vaultIndex2 = p.getVaultIndex();
     const hubUpdated = await exportHubScores(vaultIndex2, p.sd);
     const hubDiffs = [];
@@ -8961,18 +9041,19 @@ var PipelineRunner = class {
         if (prev !== r.hub_score) hubDiffs.push({ entity: r.name, before: prev, after: r.hub_score });
       }
     }
+    p.ctx.lastHubScoreRebuildAt = Date.now();
     serverLog("watcher", `Hub scores: ${hubUpdated ?? 0} updated`);
     return { updated: hubUpdated ?? 0, diffs: hubDiffs.slice(0, 10) };
   }
   // ── Step 3.5: Recency ─────────────────────────────────────────────
   async recency() {
     const { p } = this;
-    const cachedRecency = loadRecencyFromStateDb();
+    const cachedRecency = loadRecencyFromStateDb(p.sd ?? void 0);
     const cacheAgeMs = cachedRecency ? Date.now() - (cachedRecency.lastUpdated ?? 0) : Infinity;
     if (cacheAgeMs >= 60 * 60 * 1e3) {
       const entities = this.entitiesAfter.map((e) => ({ name: e.name, path: e.path, aliases: e.aliases }));
       const recencyIndex2 = await buildRecencyIndex(p.vp, entities);
-      saveRecencyToStateDb(recencyIndex2);
+      saveRecencyToStateDb(recencyIndex2, p.sd ?? void 0);
       serverLog("watcher", `Recency: rebuilt ${recencyIndex2.lastMentioned.size} entities`);
       return { rebuilt: true, entities: recencyIndex2.lastMentioned.size };
     }
@@ -9082,9 +9163,16 @@ var PipelineRunner = class {
     const { p, tracker } = this;
     const vaultIndex2 = p.getVaultIndex();
     if (p.sd) {
+      const cacheAgeMs = p.ctx.lastIndexCacheSaveAt > 0 ? Date.now() - p.ctx.lastIndexCacheSaveAt : Infinity;
+      if (cacheAgeMs < 30 * 1e3) {
+        tracker.start("index_cache", {});
+        tracker.skip("index_cache", `saved recently (${Math.round(cacheAgeMs / 1e3)}s ago)`);
+        return;
+      }
       tracker.start("index_cache", { note_count: vaultIndex2.notes.size });
       try {
         saveVaultIndexToCache(p.sd, vaultIndex2);
+        p.ctx.lastIndexCacheSaveAt = Date.now();
         tracker.end({ saved: true });
         serverLog("watcher", "Index cache saved");
       } catch (err) {
@@ -9341,6 +9429,7 @@ var PipelineRunner = class {
       );
       for (const diff of this.linkDiffs) {
         if (deletedFiles.has(diff.file)) continue;
+        const newlyTracked = [];
         for (const target of diff.added) {
           if (checkApplication.get(target, diff.file)) continue;
           const entity = this.entitiesAfter.find(
@@ -9349,8 +9438,15 @@ var PipelineRunner = class {
           if (entity) {
             recordFeedback(p.sd, entity.name, "implicit:manual_added", diff.file, true);
             additionResults.push({ entity: entity.name, file: diff.file });
+            newlyTracked.push({
+              entity: entity.name,
+              matchedTerm: entity.nameLower === target ? void 0 : target
+            });
           }
         }
+        if (newlyTracked.length > 0) {
+          trackWikilinkApplications(p.sd, diff.file, newlyTracked);
+        }
       }
     }
     const newlySuppressed = [];
@@ -9370,6 +9466,20 @@ var PipelineRunner = class {
       serverLog("watcher", `Suppression: ${newlySuppressed.length} entities newly suppressed: ${newlySuppressed.join(", ")}`);
     }
   }
+  // ── Step 10.1: Incremental recency ──────────────────────────────
+  async incrementalRecency() {
+    const { p } = this;
+    if (!p.sd) return { skipped: true };
+    let updated = 0;
+    const now = /* @__PURE__ */ new Date();
+    for (const entry of this.forwardLinkResults) {
+      for (const target of entry.resolved) {
+        recordEntityMention2(p.sd, target, now);
+        updated++;
+      }
+    }
+    return { entities_updated: updated };
+  }
   // ── Step 10.5: Corrections ────────────────────────────────────────
   async corrections() {
     const { p } = this;
@@ -9635,7 +9745,7 @@ import { openStateDb, scanVaultEntities as scanVaultEntities4, getAllEntitiesFro
 
 // src/core/write/memory.ts
 init_wikilinkFeedback();
-import { recordEntityMention as recordEntityMention2 } from "@velvetmonkey/vault-core";
+import { recordEntityMention as recordEntityMention3 } from "@velvetmonkey/vault-core";
 var entityCacheMap = /* @__PURE__ */ new Map();
 var ENTITY_CACHE_TTL_MS = 6e4;
 function getEntityList(stateDb2) {
@@ -9676,7 +9786,7 @@ function updateGraphSignals(stateDb2, memoryKey, entities) {
   if (entities.length === 0) return;
   const now = /* @__PURE__ */ new Date();
   for (const entity of entities) {
-    recordEntityMention2(stateDb2, entity, now);
+    recordEntityMention3(stateDb2, entity, now);
   }
   const sourcePath = `memory:${memoryKey}`;
   const targets = new Set(entities.map((e) => e.toLowerCase()));
@@ -13854,6 +13964,38 @@ function enrichResultLight(result, index, stateDb2) {
   }
   return enriched;
 }
+function enrichEntityCompact(entityName, stateDb2, index) {
+  const enriched = {};
+  if (stateDb2) {
+    try {
+      const entity = getEntityByName2(stateDb2, entityName);
+      if (entity) {
+        enriched.category = entity.category;
+        enriched.hub_score = entity.hubScore;
+        if (entity.aliases.length > 0) enriched.aliases = entity.aliases;
+        enriched.path = entity.path;
+      }
+    } catch {
+    }
+  }
+  if (index) {
+    const entityPath = enriched.path ?? index.entities.get(entityName.toLowerCase());
+    if (entityPath) {
+      const note = index.notes.get(entityPath);
+      const normalizedPath = entityPath.toLowerCase().replace(/\.md$/, "");
+      const backlinks = index.backlinks.get(normalizedPath) || [];
+      enriched.backlink_count = backlinks.length;
+      if (note) {
+        if (Object.keys(note.frontmatter).length > 0) enriched.frontmatter = note.frontmatter;
+        if (note.tags.length > 0) enriched.tags = note.tags;
+        if (note.outlinks.length > 0) {
+          enriched.outlink_names = getOutlinkNames(note.outlinks, entityPath, index, stateDb2, COMPACT_OUTLINK_NAMES);
+        }
+      }
+    }
+  }
+  return enriched;
+}
 
 // src/core/read/multihop.ts
 import { getEntityByName as getEntityByName3, searchEntities } from "@velvetmonkey/vault-core";
@@ -14156,6 +14298,151 @@ function extractDates(text) {
 
 // src/tools/read/query.ts
 init_stemmer();
+
+// src/tools/read/structure.ts
+import * as fs14 from "fs";
+import * as path17 from "path";
+var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
+function extractHeadings2(content) {
+  const lines = content.split("\n");
+  const headings = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
+    }
+    if (inCodeBlock) continue;
+    const match = line.match(HEADING_REGEX2);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].trim(),
+        line: i + 1
+        // 1-indexed
+      });
+    }
+  }
+  return headings;
+}
+function buildSections(headings, totalLines) {
+  if (headings.length === 0) return [];
+  const sections = [];
+  const stack = [];
+  for (let i = 0; i < headings.length; i++) {
+    const heading = headings[i];
+    const nextHeading = headings[i + 1];
+    const lineEnd = nextHeading ? nextHeading.line - 1 : totalLines;
+    const section = {
+      heading,
+      line_start: heading.line,
+      line_end: lineEnd,
+      subsections: []
+    };
+    while (stack.length > 0 && stack[stack.length - 1].heading.level >= heading.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      sections.push(section);
+    } else {
+      stack[stack.length - 1].subsections.push(section);
+    }
+    stack.push(section);
+  }
+  return sections;
+}
+async function getNoteStructure(index, notePath, vaultPath2) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path17.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs14.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  const headings = extractHeadings2(content);
+  const sections = buildSections(headings, lines.length);
+  const contentWithoutCode = content.replace(/```[\s\S]*?```/g, "");
+  const words = contentWithoutCode.split(/\s+/).filter((w) => w.length > 0);
+  return {
+    path: notePath,
+    headings,
+    sections,
+    word_count: words.length,
+    line_count: lines.length
+  };
+}
+async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
+  const note = index.notes.get(notePath);
+  if (!note) return null;
+  const absolutePath = path17.join(vaultPath2, notePath);
+  let content;
+  try {
+    content = await fs14.promises.readFile(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  const headings = extractHeadings2(content);
+  const targetHeading = headings.find(
+    (h) => h.text.toLowerCase() === headingText.toLowerCase()
+  );
+  if (!targetHeading) return null;
+  let lineEnd = lines.length;
+  for (const h of headings) {
+    if (h.line > targetHeading.line) {
+      if (includeSubheadings) {
+        if (h.level <= targetHeading.level) {
+          lineEnd = h.line - 1;
+          break;
+        }
+      } else {
+        lineEnd = h.line - 1;
+        break;
+      }
+    }
+  }
+  const sectionLines = lines.slice(targetHeading.line, lineEnd);
+  const sectionContent = sectionLines.join("\n").trim();
+  return {
+    heading: targetHeading.text,
+    level: targetHeading.level,
+    content: sectionContent,
+    line_start: targetHeading.line,
+    line_end: lineEnd
+  };
+}
+async function findSections(index, headingPattern, vaultPath2, folder) {
+  const regex = new RegExp(headingPattern, "i");
+  const results = [];
+  for (const note of index.notes.values()) {
+    if (folder && !note.path.startsWith(folder)) continue;
+    const absolutePath = path17.join(vaultPath2, note.path);
+    let content;
+    try {
+      content = await fs14.promises.readFile(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const headings = extractHeadings2(content);
+    for (const heading of headings) {
+      if (regex.test(heading.text)) {
+        results.push({
+          path: note.path,
+          heading: heading.text,
+          level: heading.level,
+          line: heading.line
+        });
+      }
+    }
+  }
+  return results;
+}
+
+// src/tools/read/query.ts
 function applyGraphReranking(results, stateDb2) {
   if (!stateDb2) return;
   const cooccurrenceIndex2 = getCooccurrenceIndex();
@@ -14188,8 +14475,20 @@ function applyGraphReranking(results, stateDb2) {
 }
 function applySandwichOrdering(results) {
   if (results.length < 3) return;
-  const secondBest = results.splice(1, 1)[0];
-  results.push(secondBest);
+  const n = results.length;
+  const out = new Array(n);
+  let front = 0;
+  let back = n - 1;
+  for (let i = 0; i < n; i++) {
+    if (i % 2 === 0) {
+      out[front++] = results[i];
+    } else {
+      out[back--] = results[i];
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    results[i] = out[i];
+  }
 }
 function applyEntityBridging(results, stateDb2, maxBridgesPerResult = 3) {
   if (!stateDb2 || results.length < 2) return;
@@ -14233,6 +14532,92 @@ function stripInternalFields(results) {
     for (const key of INTERNAL) delete r[key];
   }
 }
+function scoreAndRankMemories(memories, limit) {
+  const now = Date.now();
+  const scored = [];
+  for (const m of memories) {
+    const confidenceBoost = m.confidence * 5;
+    let typeBoost = 0;
+    switch (m.memory_type) {
+      case "fact":
+        typeBoost = 3;
+        break;
+      case "preference":
+        typeBoost = 2;
+        break;
+      case "observation": {
+        const ageDays = (now - m.updated_at) / 864e5;
+        const recencyFactor = Math.max(0.2, 1 - ageDays / 7);
+        typeBoost = 1 + 4 * recencyFactor;
+        break;
+      }
+      case "summary":
+        typeBoost = 1;
+        break;
+    }
+    scored.push({ memory: m, score: confidenceBoost + typeBoost });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map(({ memory: m }) => {
+    const result = {
+      key: m.key,
+      value: m.value,
+      type: m.memory_type
+    };
+    if (m.entity) result.entity = m.entity;
+    if (m.entities_json) {
+      try {
+        const entities = JSON.parse(m.entities_json);
+        if (Array.isArray(entities) && entities.length > 0) result.entities = entities;
+      } catch {
+      }
+    }
+    return result;
+  });
+}
+async function buildEntitySection(entityResults, query, stateDb2, index, limit) {
+  if (!stateDb2 || entityResults.length === 0 && query.length < 20) return [];
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const e of entityResults) {
+    entityMap.set(e.name.toLowerCase(), e);
+  }
+  if (query.length >= 20 && hasEntityEmbeddingsIndex()) {
+    try {
+      const embedding = await embedTextCached(query);
+      const semanticMatches = findSemanticallySimilarEntities(embedding, limit);
+      for (const match of semanticMatches) {
+        if (match.similarity < 0.3) continue;
+        const key = match.entityName.toLowerCase();
+        if (!entityMap.has(key)) {
+          entityMap.set(key, {
+            id: 0,
+            name: match.entityName,
+            nameLower: key,
+            path: "",
+            category: "unknown",
+            aliases: [],
+            hubScore: 0,
+            rank: 0
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (entityMap.size === 0) return [];
+  const enriched = [];
+  let count = 0;
+  for (const [, entity] of entityMap) {
+    if (count >= limit) break;
+    enriched.push({
+      name: entity.name,
+      ...entity.description ? { description: entity.description } : {},
+      ...enrichEntityCompact(entity.name, stateDb2, index)
+    });
+    count++;
+  }
+  return enriched;
+}
 async function enhanceSnippets(results, query, vaultPath2) {
   if (!hasEmbeddingsIndex()) return;
   const queryTokens = tokenize(query).map((t) => t.toLowerCase());
@@ -14256,6 +14641,29 @@ async function enhanceSnippets(results, query, vaultPath2) {
     }
   }
 }
+async function expandToSections(results, index, vaultPath2, maxExpand = 5, maxSectionChars = 2500) {
+  const toExpand = results.slice(0, maxExpand);
+  for (const r of toExpand) {
+    const sectionHeading = r.section;
+    const notePath = r.path;
+    if (!sectionHeading || !notePath) continue;
+    try {
+      const section = await getSectionContent(index, notePath, sectionHeading, vaultPath2, true);
+      if (!section || !section.content) continue;
+      const heading = `## ${section.heading}`;
+      let content = section.content;
+      if (content.length > maxSectionChars) {
+        const truncated = content.slice(0, maxSectionChars);
+        const lastBreak = truncated.lastIndexOf("\n\n");
+        content = (lastBreak > 0 ? truncated.slice(0, lastBreak) : truncated) + "\n\u2026";
+      }
+      r.section_content = `${heading}
+
+${content}`;
+    } catch {
+    }
+  }
+}
 function matchesFrontmatter(note, where) {
   for (const [key, value] of Object.entries(where)) {
     const noteValue = note.frontmatter[key];
@@ -14326,7 +14734,7 @@ function sortNotes(notes, sortBy, order) {
 function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
   server2.tool(
     "search",
-    'Search everything \u2014 notes, entities, and memories \u2014 in one call. Returns a decision surface with three sections: note results (with section provenance, dates, bridges, confidence), matching entity profiles, and relevant memories.\n\nNote results carry full metadata (frontmatter, scored backlinks/outlinks, snippets). Start with just a query, no filters. Narrow with filters only if needed. Use get_note_structure for full content, get_section_content to read one section.\n\nSearches note content (FTS5 + hybrid semantic), entity profiles (people, projects, technologies), and stored memories. Hybrid results included automatically when embeddings are built (via init_semantic).\n\nExample: search({ query: "quarterly review", limit: 5 })\nExample: search({ where: { type: "project", status: "active" } })\n\nMulti-vault: omitting `vault` searches all vaults and merges results. Pass `vault` to search a specific vault.',
+    'Search everything \u2014 notes, entities, and memories \u2014 in one call. Returns a decision surface with three sections: note results (with section provenance, full section content, dates, bridges, confidence), matching entity profiles, and relevant memories.\n\nTop note results carry full metadata (frontmatter, scored backlinks/outlinks, snippets) plus section_content \u2014 the complete ## section around the match (up to 2,500 chars). Start with just a query, no filters. Narrow with filters only if needed. Between snippet, section_content, and frontmatter, most questions can be answered without follow-up reads.\n\nSearches note content (FTS5 + hybrid semantic with contextual embeddings), entity profiles (people, projects, technologies), and stored memories. Hybrid results included automatically when embeddings are built (via init_semantic).\n\nExample: search({ query: "quarterly review", limit: 5 })\nExample: search({ where: { type: "project", status: "active" } })\n\nMulti-vault: omitting `vault` searches all vaults and merges results. Pass `vault` to search a specific vault.',
     {
       query: z5.string().optional().describe("Search query text. Required unless using metadata filters (where, has_tag, folder, etc.)"),
       // Metadata filters
@@ -14440,6 +14848,15 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
           } catch {
           }
         }
+        let memoryResults = [];
+        if (stateDbEntity) {
+          try {
+            const rawMemories = searchMemories(stateDbEntity, { query, limit });
+            memoryResults = scoreAndRankMemories(rawMemories, limit);
+          } catch {
+          }
+        }
+        const entitySectionPromise = buildEntitySection(entityResults, query, stateDbEntity, index, limit);
         let edgeRanked = [];
         if (context_note) {
           const ctxStateDb = getStateDb3();
@@ -14532,12 +14949,16 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
             applyEntityBridging(results2, stateDb2);
             applySandwichOrdering(results2);
             await enhanceSnippets(results2, query, vaultPath2);
+            await expandToSections(results2, index, vaultPath2, detailN);
             stripInternalFields(results2);
+            const entitySection2 = await entitySectionPromise;
             return { content: [{ type: "text", text: JSON.stringify({
               method: "hybrid",
               query,
               total_results: filtered.length,
-              results: results2
+              results: results2,
+              ...entitySection2.length > 0 ? { entities: entitySection2 } : {},
+              ...memoryResults.length > 0 ? { memories: memoryResults } : {}
             }, null, 2) }] };
           } catch (err) {
             console.error("[Semantic] Hybrid search failed, falling back to FTS5:", err instanceof Error ? err.message : err);
@@ -14574,12 +14995,16 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
           applyEntityBridging(results2, stateDb2);
           applySandwichOrdering(results2);
           await enhanceSnippets(results2, query, vaultPath2);
+          await expandToSections(results2, index, vaultPath2, detailN);
           stripInternalFields(results2);
+          const entitySection2 = await entitySectionPromise;
           return { content: [{ type: "text", text: JSON.stringify({
             method: "fts5",
             query,
             total_results: filtered.length,
-            results: results2
+            results: results2,
+            ...entitySection2.length > 0 ? { entities: entitySection2 } : {},
+            ...memoryResults.length > 0 ? { memories: memoryResults } : {}
           }, null, 2) }] };
         }
         const stateDbFts = getStateDb3();
@@ -14595,12 +15020,16 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
         applyEntityBridging(results, stateDbFts);
         applySandwichOrdering(results);
         await enhanceSnippets(results, query, vaultPath2);
+        await expandToSections(results, index, vaultPath2, detailN);
         stripInternalFields(results);
+        const entitySection = await entitySectionPromise;
         return { content: [{ type: "text", text: JSON.stringify({
           method: "fts5",
           query,
           total_results: results.length,
-          results
+          results,
+          ...entitySection.length > 0 ? { entities: entitySection } : {},
+          ...memoryResults.length > 0 ? { memories: memoryResults } : {}
         }, null, 2) }] };
       }
       return { content: [{ type: "text", text: JSON.stringify({ error: "Provide a query or metadata filters (where, has_tag, folder, etc.)" }, null, 2) }] };
@@ -14609,8 +15038,8 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb3) {
 }
 
 // src/tools/read/system.ts
-import * as fs14 from "fs";
-import * as path17 from "path";
+import * as fs15 from "fs";
+import * as path18 from "path";
 import { z as z6 } from "zod";
 import { scanVaultEntities as scanVaultEntities2, getEntityIndexFromDb as getEntityIndexFromDb2 } from "@velvetmonkey/vault-core";
 
@@ -14925,8 +15354,8 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
           continue;
         }
         try {
-          const fullPath = path17.join(vaultPath2, note.path);
-          const content = await fs14.promises.readFile(fullPath, "utf-8");
+          const fullPath = path18.join(vaultPath2, note.path);
+          const content = await fs15.promises.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
@@ -15183,151 +15612,6 @@ function registerSystemTools(server2, getIndex, setIndex, getVaultPath, setConfi
 
 // src/tools/read/primitives.ts
 import { z as z7 } from "zod";
-
-// src/tools/read/structure.ts
-import * as fs15 from "fs";
-import * as path18 from "path";
-var HEADING_REGEX2 = /^(#{1,6})\s+(.+)$/;
-function extractHeadings2(content) {
-  const lines = content.split("\n");
-  const headings = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock) continue;
-    const match = line.match(HEADING_REGEX2);
-    if (match) {
-      headings.push({
-        level: match[1].length,
-        text: match[2].trim(),
-        line: i + 1
-        // 1-indexed
-      });
-    }
-  }
-  return headings;
-}
-function buildSections(headings, totalLines) {
-  if (headings.length === 0) return [];
-  const sections = [];
-  const stack = [];
-  for (let i = 0; i < headings.length; i++) {
-    const heading = headings[i];
-    const nextHeading = headings[i + 1];
-    const lineEnd = nextHeading ? nextHeading.line - 1 : totalLines;
-    const section = {
-      heading,
-      line_start: heading.line,
-      line_end: lineEnd,
-      subsections: []
-    };
-    while (stack.length > 0 && stack[stack.length - 1].heading.level >= heading.level) {
-      stack.pop();
-    }
-    if (stack.length === 0) {
-      sections.push(section);
-    } else {
-      stack[stack.length - 1].subsections.push(section);
-    }
-    stack.push(section);
-  }
-  return sections;
-}
-async function getNoteStructure(index, notePath, vaultPath2) {
-  const note = index.notes.get(notePath);
-  if (!note) return null;
-  const absolutePath = path18.join(vaultPath2, notePath);
-  let content;
-  try {
-    content = await fs15.promises.readFile(absolutePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const lines = content.split("\n");
-  const headings = extractHeadings2(content);
-  const sections = buildSections(headings, lines.length);
-  const contentWithoutCode = content.replace(/```[\s\S]*?```/g, "");
-  const words = contentWithoutCode.split(/\s+/).filter((w) => w.length > 0);
-  return {
-    path: notePath,
-    headings,
-    sections,
-    word_count: words.length,
-    line_count: lines.length
-  };
-}
-async function getSectionContent(index, notePath, headingText, vaultPath2, includeSubheadings = true) {
-  const note = index.notes.get(notePath);
-  if (!note) return null;
-  const absolutePath = path18.join(vaultPath2, notePath);
-  let content;
-  try {
-    content = await fs15.promises.readFile(absolutePath, "utf-8");
-  } catch {
-    return null;
-  }
-  const lines = content.split("\n");
-  const headings = extractHeadings2(content);
-  const targetHeading = headings.find(
-    (h) => h.text.toLowerCase() === headingText.toLowerCase()
-  );
-  if (!targetHeading) return null;
-  let lineEnd = lines.length;
-  for (const h of headings) {
-    if (h.line > targetHeading.line) {
-      if (includeSubheadings) {
-        if (h.level <= targetHeading.level) {
-          lineEnd = h.line - 1;
-          break;
-        }
-      } else {
-        lineEnd = h.line - 1;
-        break;
-      }
-    }
-  }
-  const sectionLines = lines.slice(targetHeading.line, lineEnd);
-  const sectionContent = sectionLines.join("\n").trim();
-  return {
-    heading: targetHeading.text,
-    level: targetHeading.level,
-    content: sectionContent,
-    line_start: targetHeading.line,
-    line_end: lineEnd
-  };
-}
-async function findSections(index, headingPattern, vaultPath2, folder) {
-  const regex = new RegExp(headingPattern, "i");
-  const results = [];
-  for (const note of index.notes.values()) {
-    if (folder && !note.path.startsWith(folder)) continue;
-    const absolutePath = path18.join(vaultPath2, note.path);
-    let content;
-    try {
-      content = await fs15.promises.readFile(absolutePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const headings = extractHeadings2(content);
-    for (const heading of headings) {
-      if (regex.test(heading.text)) {
-        results.push({
-          path: note.path,
-          heading: heading.text,
-          level: heading.level,
-          line: heading.line
-        });
-      }
-    }
-  }
-  return results;
-}
-
-// src/tools/read/primitives.ts
 import { getEntityByName as getEntityByName4 } from "@velvetmonkey/vault-core";
 function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig2 = () => ({}), getStateDb3 = () => null) {
   server2.registerTool(
@@ -17771,14 +18055,40 @@ async function executeMutation(options, operation) {
     if (existsError) {
       return { success: false, result: existsError, filesWritten: [] };
     }
-    const { content, frontmatter, lineEnding, contentHash: contentHash2 } = await readVaultFile(vaultPath2, notePath);
+    let { content, frontmatter, lineEnding, contentHash: contentHash2 } = await readVaultFile(vaultPath2, notePath);
     let sectionBoundary;
     if (section) {
       const sectionResult = await ensureSectionExists(content, section, notePath, vaultPath2);
       if ("error" in sectionResult) {
-        return { success: false, result: sectionResult.error, filesWritten: [] };
+        if (options.autoCreateSection) {
+          const sectionName = section.replace(/^#+\s*/, "").trim();
+          const headings = extractHeadings3(content);
+          let level = 1;
+          if (headings.length > 0) {
+            const topLevel = Math.min(...headings.map((h) => h.level));
+            const topHeadings = headings.filter((h) => h.level === topLevel);
+            level = topHeadings.length === 1 ? topLevel + 1 : topLevel;
+          }
+          const hashes = "#".repeat(level);
+          const newSection = `
+${hashes} ${sectionName}
+- 
+`;
+          content = content.trimEnd() + "\n" + newSection;
+          await writeVaultFile(vaultPath2, notePath, content, frontmatter, lineEnding, contentHash2);
+          ({ content, frontmatter, lineEnding, contentHash: contentHash2 } = await readVaultFile(vaultPath2, notePath));
+          const retryResult = await ensureSectionExists(content, section, notePath, vaultPath2);
+          if ("error" in retryResult) {
+            return { success: false, result: retryResult.error, filesWritten: [] };
+          }
+          sectionBoundary = retryResult.boundary;
+          console.error(`[Flywheel] Auto-created section "${sectionName}" (${hashes}) in ${notePath}`);
+        } else {
+          return { success: false, result: sectionResult.error, filesWritten: [] };
+        }
+      } else {
+        sectionBoundary = sectionResult.boundary;
       }
-      sectionBoundary = sectionResult.boundary;
     }
     const ctx = { content, frontmatter, lineEnding, sectionBoundary, vaultPath: vaultPath2, notePath };
     const opResult = await operation(ctx);
@@ -17837,7 +18147,8 @@ async function withVaultFile(options, operation) {
     section: options.section,
     actionDescription: options.actionDescription,
     scoping: options.scoping,
-    dryRun: options.dryRun
+    dryRun: options.dryRun,
+    autoCreateSection: options.autoCreateSection
   }, operation);
   if (!outcome.success || options.dryRun) {
     return formatMcpResult(outcome.result);
@@ -17989,21 +18300,44 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
   const templates = config.templates || {};
   const filename = path25.basename(notePath, ".md").toLowerCase();
   let templatePath;
+  let periodicType;
   const dailyPattern = /^\d{4}-\d{2}-\d{2}/;
   const weeklyPattern = /^\d{4}-W\d{2}/;
   const monthlyPattern = /^\d{4}-\d{2}$/;
   const quarterlyPattern = /^\d{4}-Q[1-4]$/;
   const yearlyPattern = /^\d{4}$/;
-  if (dailyPattern.test(filename) && templates.daily) {
+  if (dailyPattern.test(filename)) {
     templatePath = templates.daily;
-  } else if (weeklyPattern.test(filename) && templates.weekly) {
+    periodicType = "daily";
+  } else if (weeklyPattern.test(filename)) {
     templatePath = templates.weekly;
-  } else if (monthlyPattern.test(filename) && templates.monthly) {
+    periodicType = "weekly";
+  } else if (monthlyPattern.test(filename)) {
     templatePath = templates.monthly;
-  } else if (quarterlyPattern.test(filename) && templates.quarterly) {
+    periodicType = "monthly";
+  } else if (quarterlyPattern.test(filename)) {
     templatePath = templates.quarterly;
-  } else if (yearlyPattern.test(filename) && templates.yearly) {
+    periodicType = "quarterly";
+  } else if (yearlyPattern.test(filename)) {
     templatePath = templates.yearly;
+    periodicType = "yearly";
+  }
+  if (!templatePath && periodicType) {
+    const candidates = [
+      `templates/${periodicType}.md`,
+      `templates/${periodicType[0].toUpperCase() + periodicType.slice(1)}.md`,
+      `templates/${periodicType}-note.md`,
+      `templates/${periodicType[0].toUpperCase() + periodicType.slice(1)} Note.md`
+    ];
+    for (const candidate of candidates) {
+      try {
+        await fs23.access(path25.join(vaultPath2, candidate));
+        templatePath = candidate;
+        console.error(`[Flywheel] Template not in config but found at ${candidate} \u2014 using it`);
+        break;
+      } catch {
+      }
+    }
   }
   let templateContent;
   if (templatePath) {
@@ -18011,6 +18345,7 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       const absTemplatePath = path25.join(vaultPath2, templatePath);
       templateContent = await fs23.readFile(absTemplatePath, "utf-8");
     } catch {
+      console.error(`[Flywheel] Template at ${templatePath} not readable, using minimal fallback`);
       const title = path25.basename(notePath, ".md");
       templateContent = `---
 ---
@@ -18020,6 +18355,9 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
       templatePath = void 0;
     }
   } else {
+    if (periodicType) {
+      console.error(`[Flywheel] No ${periodicType} template found in config or vault \u2014 using minimal fallback`);
+    }
     const title = path25.basename(notePath, ".md");
     templateContent = `---
 ---
@@ -18104,7 +18442,8 @@ Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", con
           section,
           actionDescription: "add content",
           scoping: agent_id || session_id ? { agent_id, session_id } : void 0,
-          dryRun: dry_run
+          dryRun: dry_run,
+          autoCreateSection: noteCreated
         },
         async (ctx) => {
           const validationResult = runValidationPipeline(content, format, {
@@ -21256,6 +21595,7 @@ function registerWikilinkFeedbackTools(server2, getStateDb3) {
               isError: true
             };
           }
+          console.error(`[Flywheel] wikilink_feedback: stateDb path=${stateDb2.db.name}`);
           try {
             recordFeedback(stateDb2, entity, context || "", note_path || "", correct);
           } catch (e) {
@@ -21266,6 +21606,8 @@ function registerWikilinkFeedbackTools(server2, getStateDb3) {
               isError: true
             };
           }
+          const rowCount = stateDb2.db.prepare("SELECT COUNT(*) as cnt FROM wikilink_feedback").get().cnt;
+          console.error(`[Flywheel] wikilink_feedback: after insert, total rows=${rowCount}, db=${stateDb2.db.name}`);
           if (!correct && note_path && !skip_status_update) {
             stateDb2.db.prepare(
               `UPDATE wikilink_applications SET status = 'removed' WHERE entity = ? AND note_path = ? COLLATE NOCASE`
@@ -21282,7 +21624,8 @@ function registerWikilinkFeedbackTools(server2, getStateDb3) {
               correct,
               suppression_updated: suppressionUpdated
             },
-            total_suppressed: getSuppressedCount(stateDb2)
+            total_suppressed: getSuppressedCount(stateDb2),
+            total_feedback_rows: rowCount
           };
           break;
         }
@@ -24692,23 +25035,48 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
       } catch {
       }
     }
-    const merged = [];
+    const mergedResults = [];
+    const mergedEntities = [];
+    const mergedMemories = [];
     const vaultsSearched = [];
     let query;
     for (const { vault, data } of perVault) {
       vaultsSearched.push(vault);
       if (data.query) query = data.query;
       if (data.error || data.building) continue;
-      const items = data.results || data.notes || data.entities || [];
+      const items = data.results || data.notes || [];
       for (const item of items) {
-        merged.push({ vault, ...item });
+        mergedResults.push({ vault, ...item });
+      }
+      if (Array.isArray(data.entities)) {
+        for (const item of data.entities) {
+          mergedEntities.push({ vault, ...item });
+        }
+      }
+      if (Array.isArray(data.memories)) {
+        for (const item of data.memories) {
+          mergedMemories.push({ vault, ...item });
+        }
       }
     }
-    if (merged.some((r) => r.rrf_score != null)) {
-      merged.sort((a, b) => (b.rrf_score ?? 0) - (a.rrf_score ?? 0));
+    if (mergedResults.some((r) => r.rrf_score != null)) {
+      mergedResults.sort((a, b) => (b.rrf_score ?? 0) - (a.rrf_score ?? 0));
     }
+    const seenEntities = /* @__PURE__ */ new Set();
+    const dedupedEntities = mergedEntities.filter((e) => {
+      const key = (e.name || "").toLowerCase();
+      if (seenEntities.has(key)) return false;
+      seenEntities.add(key);
+      return true;
+    });
+    const seenMemories = /* @__PURE__ */ new Set();
+    const dedupedMemories = mergedMemories.filter((m) => {
+      if (seenMemories.has(m.key)) return false;
+      seenMemories.add(m.key);
+      return true;
+    });
     const limit = args[0]?.limit ?? 10;
-    const truncated = merged.slice(0, limit);
+    const truncated = mergedResults.slice(0, limit);
     return {
       content: [{
         type: "text",
@@ -24716,9 +25084,11 @@ function applyToolGating(targetServer, categories, getDb4, registry, getVaultPat
           method: "cross_vault",
           query,
           vaults_searched: vaultsSearched,
-          total_results: merged.length,
+          total_results: mergedResults.length,
           returned: truncated.length,
-          results: truncated
+          results: truncated,
+          ...dedupedEntities.length > 0 ? { entities: dedupedEntities.slice(0, limit) } : {},
+          ...dedupedMemories.length > 0 ? { memories: dedupedMemories.slice(0, limit) } : {}
         }, null, 2)
       }]
     };
@@ -24950,7 +25320,10 @@ async function initializeVault(name, vaultPathArg) {
     indexState: "building",
     indexError: null,
     lastCooccurrenceRebuildAt: 0,
-    lastEdgeWeightRebuildAt: 0
+    lastEdgeWeightRebuildAt: 0,
+    lastEntityScanAt: 0,
+    lastHubScoreRebuildAt: 0,
+    lastIndexCacheSaveAt: 0
   };
   try {
     ctx.stateDb = openStateDb(vaultPathArg);