context-vault 3.4.5 → 3.5.1

package/src/status.ts

@@ -148,6 +148,20 @@ export function gatherVaultStatus(ctx: LocalCtx, opts: Record<string, unknown> =
     errors.push(`Archived count failed: ${(e as Error).message}`);
   }
 
+  let indexingStats: { indexed: number; unindexed: number; total: number; byKind: Array<{ kind: string; indexed: number; total: number }> } | null = null;
+  try {
+    const totalRow = db.prepare('SELECT COUNT(*) as c FROM vault').get() as { c: number } | undefined;
+    const indexedRow = db.prepare('SELECT COUNT(*) as c FROM vault WHERE indexed = 1').get() as { c: number } | undefined;
+    const total = totalRow?.c ?? 0;
+    const indexed = indexedRow?.c ?? 0;
+    const byKind = db.prepare(
+      'SELECT kind, COUNT(*) as total, SUM(CASE WHEN indexed = 1 THEN 1 ELSE 0 END) as indexed FROM vault GROUP BY kind'
+    ).all() as Array<{ kind: string; total: number; indexed: number }>;
+    indexingStats = { indexed, unindexed: total - indexed, total, byKind };
+  } catch (e) {
+    errors.push(`Indexing stats failed: ${(e as Error).message}`);
+  }
+
   let staleKnowledge: unknown[] = [];
   try {
     const stalenessKinds = Object.entries(KIND_STALENESS_DAYS);
@@ -168,6 +182,25 @@ export function gatherVaultStatus(ctx: LocalCtx, opts: Record<string, unknown> =
     errors.push(`Stale knowledge check failed: ${(e as Error).message}`);
   }
 
+  let recallStats: { totalRecalls: number; entriesRecalled: number; avgRecallCount: number; maxRecallCount: number; topRecalled: Array<{ title: string; kind: string; recall_count: number; recall_sessions: number }> } | null = null;
+  try {
+    const totals = db.prepare(
+      `SELECT SUM(recall_count) as total_recalls, COUNT(CASE WHEN recall_count > 0 THEN 1 END) as entries_recalled, AVG(CASE WHEN recall_count > 0 THEN recall_count END) as avg_recall, MAX(recall_count) as max_recall FROM vault`
+    ).get() as any;
+    const topRecalled = db.prepare(
+      `SELECT title, kind, recall_count, recall_sessions FROM vault WHERE recall_count > 0 ORDER BY recall_count DESC LIMIT 5`
+    ).all() as any[];
+    recallStats = {
+      totalRecalls: totals?.total_recalls ?? 0,
+      entriesRecalled: totals?.entries_recalled ?? 0,
+      avgRecallCount: Math.round((totals?.avg_recall ?? 0) * 10) / 10,
+      maxRecallCount: totals?.max_recall ?? 0,
+      topRecalled,
+    };
+  } catch (e) {
+    errors.push(`Recall stats failed: ${(e as Error).message}`);
+  }
+
   return {
     fileCount,
     subdirs,
@@ -185,6 +218,8 @@ export function gatherVaultStatus(ctx: LocalCtx, opts: Record<string, unknown> =
     autoCapturedFeedbackCount,
     archivedCount,
     staleKnowledge,
+    indexingStats,
+    recallStats,
     resolvedFrom: config.resolvedFrom,
     errors,
   };

package/src/tools/context-status.ts

@@ -55,13 +55,31 @@ export function handler(_args: Record<string, any>, ctx: LocalCtx): ToolResult {
       lines.push(`| **Expired** | ${status.expiredCount} pending prune |`);
     }
 
+    // Selective indexing stats
+    if (status.indexingStats) {
+      const ix = status.indexingStats;
+      const pct = ix.total > 0 ? Math.round((ix.indexed / ix.total) * 100) : 100;
+      lines.push(`| **Indexed entries** | ${ix.indexed}/${ix.total} (${pct}%) |`);
+    }
+
     // Indexed kinds as compact table
-    lines.push(``, `### Indexed`);
+    lines.push(``, `### Entries by Kind`);
     if (status.kindCounts.length) {
-      lines.push('| Kind | Count |');
-      lines.push('|---|---|');
-      for (const { kind, c } of status.kindCounts) {
-        lines.push(`| ${kindIcon(kind)} \`${kind}\` | ${c} |`);
+      if (status.indexingStats?.byKind?.length) {
+        lines.push('| Kind | Total | Indexed |');
+        lines.push('|---|---|---|');
+        const byKindMap = new Map(status.indexingStats.byKind.map((k: any) => [k.kind, k]));
+        for (const { kind, c } of status.kindCounts) {
+          const kStats = byKindMap.get(kind) as { indexed?: number } | undefined;
+          const idxCount = kStats?.indexed ?? c;
+          lines.push(`| ${kindIcon(kind)} \`${kind}\` | ${c} | ${idxCount} |`);
+        }
+      } else {
+        lines.push('| Kind | Count |');
+        lines.push('|---|---|');
+        for (const { kind, c } of status.kindCounts) {
+          lines.push(`| ${kindIcon(kind)} \`${kind}\` | ${c} |`);
+        }
       }
     } else {
       lines.push(`_(empty vault)_`);
@@ -79,6 +97,23 @@ export function handler(_args: Record<string, any>, ctx: LocalCtx): ToolResult {
       for (const { name, count } of status.subdirs) lines.push(`- \`${name}/\` ${count} files`);
     }
 
+    if (status.recallStats && status.recallStats.totalRecalls > 0) {
+      const rs = status.recallStats;
+      lines.push(``, `### Recall Frequency`);
+      lines.push(`| Metric | Value |`);
+      lines.push(`|---|---|`);
+      lines.push(`| **Total recalls** | ${rs.totalRecalls} |`);
+      lines.push(`| **Entries recalled** | ${rs.entriesRecalled} |`);
+      lines.push(`| **Avg recalls/entry** | ${rs.avgRecallCount} |`);
+      lines.push(`| **Max recalls** | ${rs.maxRecallCount} |`);
+      if (rs.topRecalled?.length) {
+        lines.push(``, `**Top recalled:**`);
+        for (const t of rs.topRecalled) {
+          lines.push(`- "${t.title || '(untitled)'}" (\`${t.kind}\`): ${t.recall_count} recalls, ${t.recall_sessions} sessions`);
+        }
+      }
+    }
+
     if (status.stalePaths) {
       lines.push(``);
       lines.push(`### ⚠ Stale Paths`);

package/src/tools/get-context.ts

@@ -526,6 +526,7 @@ export async function handler(
     if (!include_superseded) {
       clauses.push('superseded_by IS NULL');
     }
+    clauses.push('indexed = 1');
     const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
     params.push(fetchLimit);
     let rows;

package/src/tools/list-context.ts

@@ -18,10 +18,11 @@ export const inputSchema = {
   until: z.string().optional().describe('ISO date, return entries created before this'),
   limit: z.number().optional().describe('Max results to return (default 20, max 100)'),
   offset: z.number().optional().describe('Skip first N results for pagination'),
+  include_unindexed: z.boolean().optional().describe('If true, include entries that are stored but not indexed for search. Default: false.'),
 };
 
 export async function handler(
-  { kind, category, tags, since, until, limit, offset }: Record<string, any>,
+  { kind, category, tags, since, until, limit, offset, include_unindexed }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed, reindexFailed }: SharedCtx
 ): Promise<ToolResult> {
@@ -63,6 +64,9 @@ export async function handler(
     params.push(until);
   }
   clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
+  if (!include_unindexed) {
+    clauses.push('indexed = 1');
+  }
 
   const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
   const effectiveLimit = Math.min(limit || 20, 100);
@@ -81,7 +85,7 @@ export async function handler(
     params.push(fetchLimit, effectiveOffset);
     rows = ctx.db
       .prepare(
-        `SELECT id, title, kind, category, tags, created_at, updated_at, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+        `SELECT id, title, kind, category, tags, created_at, updated_at, indexed, recall_count, SUBSTR(body, 1, 120) as preview FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
       )
       .all(...params) as any[];
   } catch (e) {
@@ -124,15 +128,26 @@ export async function handler(
       `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`
     );
   }
-  lines.push('| | Title | Kind | Tags | Date | ID |');
-  lines.push('|---|---|---|---|---|---|');
+  if (include_unindexed) {
+    lines.push('| | Title | Kind | Tags | Recalls | Idx | Date | ID |');
+    lines.push('|---|---|---|---|---|---|---|---|');
+  } else {
+    lines.push('| | Title | Kind | Tags | Recalls | Date | ID |');
+    lines.push('|---|---|---|---|---|---|---|');
+  }
   for (const r of filtered) {
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(', ') : '';
     const date = fmtDate(r.updated_at && r.updated_at !== r.created_at ? r.updated_at : r.created_at);
     const icon = kindIcon(r.kind);
     const title = (r.title || '(untitled)').replace(/\|/g, '\\|');
-    lines.push(`| ${icon} | **${title}** | \`${r.kind}\` | ${tagStr} | ${date} | \`${r.id}\` |`);
+    const recalls = r.recall_count ?? 0;
+    if (include_unindexed) {
+      const idxStr = r.indexed ? 'Y' : 'N';
+      lines.push(`| ${icon} | **${title}** | \`${r.kind}\` | ${tagStr} | ${recalls} | ${idxStr} | ${date} | \`${r.id}\` |`);
+    } else {
+      lines.push(`| ${icon} | **${title}** | \`${r.kind}\` | ${tagStr} | ${recalls} | ${date} | \`${r.id}\` |`);
+    }
   }
 
   if (effectiveOffset + effectiveLimit < total) {

package/src/tools/save-context.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { resolve, basename, join } from 'node:path';
+import { homedir } from 'node:os';
 import { captureAndIndex, updateEntryFile } from '@context-vault/core/capture';
 import { indexEntry } from '@context-vault/core/index';
 import { categoryFor, defaultTierFor } from '@context-vault/core/categories';
-import { normalizeKind } from '@context-vault/core/files';
+import { normalizeKind, kindToPath } from '@context-vault/core/files';
 import { parseContextParam } from '@context-vault/core/context';
+import { shouldIndex } from '@context-vault/core/indexing';
 import { ok, err, errWithHint, ensureVaultExists, ensureValidKind, kindIcon } from '../helpers.js';
 import { maybeShowFeedbackPrompt } from '../telemetry.js';
 import { validateRelatedTo } from '../linking.js';
@@ -23,6 +27,34 @@ const DEFAULT_SIMILARITY_THRESHOLD = 0.85;
 const SKIP_THRESHOLD = 0.95;
 const UPDATE_THRESHOLD = 0.85;
 
+function isDualWriteEnabled(config: { dataDir: string }): boolean {
+  try {
+    const configPath = join(config.dataDir, 'config.json');
+    if (!existsSync(configPath)) return true;
+    const fc = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (fc.dualWrite && fc.dualWrite.enabled === false) return false;
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+function dualWriteLocal(entryFilePath: string, kind: string): void {
+  const cwd = process.cwd();
+  const home = homedir();
+  if (!cwd || cwd === '/' || cwd === home) return;
+
+  try {
+    const content = readFileSync(entryFilePath, 'utf-8');
+    const localDir = resolve(cwd, '.context', kindToPath(kind));
+    mkdirSync(localDir, { recursive: true });
+    const filename = basename(entryFilePath);
+    writeFileSync(join(localDir, filename), content);
+  } catch (e) {
+    console.warn(`[context-vault] Dual-write to .context/ failed: ${(e as Error).message}`);
+  }
+}
+
 async function findSimilar(
   ctx: LocalCtx,
   embedding: any,
@@ -316,6 +348,12 @@ export const inputSchema = {
     .describe(
       'Encoding context for contextual reinstatement. Captures the situation when this entry was created, enabling context-aware retrieval boosting. Pass a structured object (e.g. { project: "myapp", arc: "auth-rewrite", task: "implementing JWT" }) or a free-text string describing the current context.'
     ),
+  indexed: z
+    .boolean()
+    .optional()
+    .describe(
+      'Whether to index this entry for search (generate embeddings + FTS). Default: auto-determined by indexing config. Set to false to store file + metadata only, skipping embedding generation. Set to true to force indexing regardless of config rules.'
+    ),
 };
 
 export async function handler(
@@ -338,6 +376,7 @@ export async function handler(
     tier,
     conflict_resolution,
     encoding_context,
+    indexed,
   }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed }: SharedCtx
@@ -447,6 +486,10 @@ export async function handler(
     } else if (entry.related_to === null && ctx.stmts.updateRelatedTo) {
       ctx.stmts.updateRelatedTo.run(null, entry.id);
     }
+    if (isDualWriteEnabled(config) && entry.filePath) {
+      dualWriteLocal(entry.filePath, entry.kind);
+    }
+
     const relPath = entry.filePath
       ? entry.filePath.replace(config.vaultDir + '/', '')
       : entry.filePath;
@@ -548,7 +591,17 @@ export async function handler(
 
   const effectiveTier = tier ?? defaultTierFor(normalizedKind);
 
-  const embeddingToReuse = category === 'knowledge' ? queryEmbedding : null;
+  const effectiveIndexed = shouldIndex(
+    {
+      kind: normalizedKind,
+      category,
+      bodyLength: body?.length ?? 0,
+      explicitIndexed: indexed,
+    },
+    config.indexing
+  );
+
+  const embeddingToReuse = category === 'knowledge' && effectiveIndexed ? queryEmbedding : null;
 
   let entry;
   try {
@@ -567,8 +620,8 @@ export async function handler(
         supersedes,
         related_to,
         source_files,
-
         tier: effectiveTier,
+        indexed: effectiveIndexed,
       },
       embeddingToReuse
     );
@@ -581,7 +634,7 @@ export async function handler(
   }
 
   // Store context embedding in vault_ctx_vec for contextual reinstatement
-  if (parsedCtx?.text && entry) {
+  if (parsedCtx?.text && entry && effectiveIndexed) {
     try {
       const ctxEmbedding = await ctx.embed(parsedCtx.text);
       if (ctxEmbedding) {
@@ -598,6 +651,10 @@ export async function handler(
     }
   }
 
+  if (isDualWriteEnabled(config) && entry.filePath) {
+    dualWriteLocal(entry.filePath, normalizedKind);
+  }
+
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);
   }
@@ -612,6 +669,12 @@ export async function handler(
     `\`${normalizedKind}\` · **${effectiveTier}**${tags?.length ? ` · ${tags.join(', ')}` : ''}`,
     `\`${entry.id}\` → ${relPath}`,
   ];
+  if (!effectiveIndexed) {
+    parts.push(
+      '',
+      '_Note: this entry is stored but not indexed (no embeddings/FTS). It will not appear in search results. Use `include_unindexed: true` in list_context to browse unindexed entries._'
+    );
+  }
   if (effectiveTier === 'ephemeral') {
     parts.push(
       '',

package/src/tools/session-start.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { execSync } from 'node:child_process';
-import { readdirSync } from 'node:fs';
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import { ok, err, ensureVaultExists, kindIcon, fmtDate } from '../helpers.js';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
@@ -10,6 +12,115 @@ const MAX_BODY_PER_ENTRY = 400;
 const PRIORITY_KINDS = ['decision', 'insight', 'pattern'];
 const SESSION_SUMMARY_KIND = 'session';
 
+interface AutoMemoryEntry {
+  file: string;
+  name: string;
+  description: string;
+  type: string;
+  body: string;
+}
+
+interface AutoMemoryResult {
+  detected: boolean;
+  path: string | null;
+  entries: AutoMemoryEntry[];
+  linesUsed: number;
+}
+
+/**
+ * Detect the Claude Code auto-memory directory for the current project.
+ * Convention: ~/.claude/projects/-<cwd-with-slashes-replaced-by-dashes>/memory/
+ */
+function detectAutoMemoryPath(): string | null {
+  try {
+    const cwd = process.cwd();
+    // Claude Code project key: absolute path with / replaced by -, leading - kept
+    const projectKey = cwd.replace(/\//g, '-');
+    const memoryDir = join(homedir(), '.claude', 'projects', projectKey, 'memory');
+    const memoryIndex = join(memoryDir, 'MEMORY.md');
+    if (existsSync(memoryIndex)) return memoryDir;
+  } catch {}
+  return null;
+}
+
+/**
+ * Parse YAML-ish frontmatter from a memory file.
+ * Returns { name, description, type } and the body after frontmatter.
+ */
+function parseMemoryFile(content: string): { name: string; description: string; type: string; body: string } {
+  const result = { name: '', description: '', type: '', body: content };
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!fmMatch) return result;
+
+  const frontmatter = fmMatch[1];
+  result.body = fmMatch[2].trim();
+
+  for (const line of frontmatter.split('\n')) {
+    const kv = line.match(/^(\w+)\s*:\s*(.+)$/);
+    if (!kv) continue;
+    const [, key, val] = kv;
+    if (key === 'name') result.name = val.trim();
+    else if (key === 'description') result.description = val.trim();
+    else if (key === 'type') result.type = val.trim();
+  }
+  return result;
+}
+
+/**
+ * Read and parse all auto-memory entries from a memory directory.
+ */
+function readAutoMemory(memoryDir: string): AutoMemoryResult {
+  const indexPath = join(memoryDir, 'MEMORY.md');
+  let linesUsed = 0;
+
+  try {
+    const indexContent = readFileSync(indexPath, 'utf-8');
+    linesUsed = indexContent.split('\n').length;
+  } catch {
+    return { detected: true, path: memoryDir, entries: [], linesUsed: 0 };
+  }
+
+  const entries: AutoMemoryEntry[] = [];
+
+  try {
+    const files = readdirSync(memoryDir).filter(
+      (f) => f.endsWith('.md') && f !== 'MEMORY.md'
+    );
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(memoryDir, file), 'utf-8');
+        const parsed = parseMemoryFile(content);
+        entries.push({
+          file,
+          name: parsed.name || file.replace('.md', ''),
+          description: parsed.description,
+          type: parsed.type,
+          body: parsed.body,
+        });
+      } catch {}
+    }
+  } catch {}
+
+  return { detected: true, path: memoryDir, entries, linesUsed };
+}
+
+/**
+ * Build a search context string from auto-memory entries.
+ * Used to boost vault retrieval relevance.
+ */
+function buildAutoMemoryContext(entries: AutoMemoryEntry[]): string {
+  if (entries.length === 0) return '';
+  const parts = entries
+    .map((e) => {
+      const desc = e.description ? `: ${e.description}` : '';
+      // Include a snippet of the body for richer context
+      const bodySnippet = e.body ? ` -- ${e.body.slice(0, 200)}` : '';
+      return `${e.name}${desc}${bodySnippet}`;
+    });
+  return parts.join('. ');
+}
+
 export const name = 'session_start';
 
 export const description =
@@ -123,13 +234,23 @@ export async function handler(
 
   const sinceDate = new Date(Date.now() - RECENT_DAYS * 86400000).toISOString();
 
+  // Auto-detect Claude Code auto-memory
+  const autoMemoryPath = detectAutoMemoryPath();
+  const autoMemory: AutoMemoryResult = autoMemoryPath
+    ? readAutoMemory(autoMemoryPath)
+    : { detected: false, path: null, entries: [], linesUsed: 0 };
+  const autoMemoryContext = buildAutoMemoryContext(autoMemory.entries);
+
   const sections = [];
   let tokensUsed = 0;
 
-  sections.push(`# Session Brief${effectiveProject ? ` — ${effectiveProject}` : ''}`);
+  sections.push(`# Session Brief${effectiveProject ? ` -- ${effectiveProject}` : ''}`);
   const bucketsLabel = buckets?.length ? ` | buckets: ${buckets.join(', ')}` : '';
+  const autoMemoryLabel = autoMemory.detected
+    ? ` | auto-memory: ${autoMemory.entries.length} entries detected, used as search context`
+    : '';
   sections.push(
-    `_Generated ${new Date().toISOString().slice(0, 10)} | budget: ${tokenBudget} tokens${bucketsLabel}_\n`
+    `_Generated ${new Date().toISOString().slice(0, 10)} | budget: ${tokenBudget} tokens${bucketsLabel}${autoMemoryLabel}_\n`
   );
   tokensUsed += estimateTokens(sections.join('\n'));
 
@@ -145,12 +266,13 @@ export async function handler(
     }
   }
 
+  // When auto-memory context is available, boost decisions query with FTS
   const decisions = queryByKinds(
     ctx,
     PRIORITY_KINDS,
     sinceDate,
-
-    effectiveTags
+    effectiveTags,
+    autoMemoryContext
   );
   if (decisions.length > 0) {
     const header = '## Active Decisions, Insights & Patterns\n';
@@ -222,6 +344,11 @@ export async function handler(
       decisions: decisions.length,
       recent: deduped.length,
     },
+    auto_memory: {
+      detected: autoMemory.detected,
+      entries: autoMemory.entries.length,
+      lines_used: autoMemory.linesUsed,
+    },
   };
   return result;
 }
@@ -254,7 +381,8 @@ function queryByKinds(
   ctx: LocalCtx,
   kinds: string[],
   since: string,
-  effectiveTags: string[]
+  effectiveTags: string[],
+  autoMemoryContext = ''
 ): any[] {
   const kindPlaceholders = kinds.map(() => '?').join(',');
   const clauses = [`kind IN (${kindPlaceholders})`];
@@ -269,20 +397,105 @@ function queryByKinds(
   clauses.push('superseded_by IS NULL');
 
   const where = `WHERE ${clauses.join(' AND ')}`;
-  const rows = ctx.db
+  let rows = ctx.db
     .prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT 50`)
-    .all(...params);
+    .all(...params) as any[];
 
   if (effectiveTags.length) {
     const tagged = rows.filter((r: any) => {
       const tags = r.tags ? JSON.parse(r.tags) : [];
       return effectiveTags.some((t: string) => tags.includes(t));
     });
-    if (tagged.length > 0) return tagged;
+    if (tagged.length > 0) rows = tagged;
+  }
+
+  // When auto-memory context is available, boost results by FTS relevance
+  // to surface vault entries that match what the user's auto-memory says they care about
+  if (autoMemoryContext && rows.length > 1) {
+    rows = boostByAutoMemory(ctx, rows, autoMemoryContext);
   }
+
   return rows;
 }
 
+/**
+ * Re-rank vault entries by FTS relevance to auto-memory context.
+ * Entries matching auto-memory topics float to the top while preserving
+ * all original entries (non-matching ones keep their original order at the end).
+ */
+function boostByAutoMemory(ctx: LocalCtx, rows: any[], context: string): any[] {
+  // Extract meaningful keywords from auto-memory context for FTS
+  const keywords = extractKeywords(context);
+  if (keywords.length === 0) return rows;
+
+  // Build FTS query from auto-memory keywords
+  const ftsTerms = keywords.slice(0, 10).map((k) => `"${k}"`).join(' OR ');
+  const rowIds = new Set(rows.map((r: any) => r.id));
+
+  try {
+    const ftsRows = ctx.db
+      .prepare(
+        `SELECT e.id, rank FROM vault_fts f JOIN vault e ON f.rowid = e.rowid WHERE vault_fts MATCH ? ORDER BY rank LIMIT 50`
+      )
+      .all(ftsTerms) as { id: string; rank: number }[];
+
+    // Build a boost map: entries matching auto-memory context get priority
+    const boostMap = new Map<string, number>();
+    for (const fr of ftsRows) {
+      if (rowIds.has(fr.id)) {
+        boostMap.set(fr.id, fr.rank);
+      }
+    }
+
+    if (boostMap.size === 0) return rows;
+
+    // Sort: boosted entries first (by FTS rank), then unboosted in original order
+    const boosted = rows.filter((r: any) => boostMap.has(r.id));
+    const unboosted = rows.filter((r: any) => !boostMap.has(r.id));
+    boosted.sort((a: any, b: any) => (boostMap.get(a.id) ?? 0) - (boostMap.get(b.id) ?? 0));
+    return [...boosted, ...unboosted];
+  } catch {
+    // FTS errors are non-fatal; return original order
+    return rows;
+  }
+}
+
+/**
+ * Extract meaningful keywords from auto-memory context text.
+ * Filters out common stop words and short tokens.
+ */
+function extractKeywords(text: string): string[] {
+  const stopWords = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'shall', 'can', 'need', 'must', 'ought',
+    'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'for', 'with',
+    'from', 'into', 'during', 'before', 'after', 'above', 'below',
+    'to', 'of', 'in', 'on', 'at', 'by', 'about', 'between', 'through',
+    'this', 'that', 'these', 'those', 'it', 'its', 'they', 'them',
+    'their', 'we', 'our', 'you', 'your', 'he', 'she', 'him', 'her',
+    'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other',
+    'some', 'such', 'no', 'only', 'own', 'same', 'than', 'too', 'very',
+    'just', 'also', 'now', 'then', 'here', 'there', 'when', 'where',
+    'how', 'what', 'which', 'who', 'whom', 'why', 'if', 'because',
+    'as', 'until', 'while', 'use', 'using', 'used',
+  ]);
+
+  const words = text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, ' ')
+    .split(/\s+/)
+    .filter((w) => w.length >= 3 && !stopWords.has(w));
+
+  // Deduplicate while preserving order
+  const seen = new Set<string>();
+  return words.filter((w) => {
+    if (seen.has(w)) return false;
+    seen.add(w);
+    return true;
+  });
+}
+
 function queryRecent(ctx: LocalCtx, since: string, effectiveTags: string[]): any[] {
   const clauses = ['created_at >= ?'];
   const params = [since];