context-vault 3.4.4 → 3.5.0

package/src/helpers.ts

@@ -58,4 +58,29 @@ export function ensureValidKind(kind: string): ToolResult | null {
   return null;
 }
 
+const KIND_ICONS: Record<string, string> = {
+  insight: '◆',
+  decision: '◇',
+  pattern: '◈',
+  reference: '▸',
+  event: '○',
+  session: '◎',
+  brief: '▪',
+  bucket: '▫',
+  contact: '●',
+  project: '■',
+  tool: '▹',
+  source: '►',
+  feedback: '◉',
+};
+
+export function kindIcon(kind: string): string {
+  return KIND_ICONS[kind] || '·';
+}
+
+export function fmtDate(date: string | null | undefined): string {
+  if (!date) return '';
+  return date.split('T')[0];
+}
+
 export { pkg };

package/src/server.ts

@@ -7,9 +7,9 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -31,6 +31,7 @@ import {
 } from '@context-vault/core/db';
 import { registerTools } from './register-tools.js';
 import { pruneExpired } from '@context-vault/core/index';
+import { setSessionId } from '@context-vault/core/search';
 
 const DAEMON_PORT = 3377;
 const PID_PATH = join(homedir(), '.context-mcp', 'daemon.pid');
@@ -312,6 +313,29 @@ async function main(): Promise<void> {
 
     config.vaultDirExists = existsSync(config.vaultDir);
 
+    // Validate vaultDir sanity
+    const osTmp = tmpdir();
+    const isTempPath = config.vaultDir.startsWith(osTmp) ||
+      config.vaultDir.startsWith('/tmp/') ||
+      config.vaultDir.startsWith('/var/folders/');
+    if (isTempPath) {
+      console.error(`[context-vault] WARNING: vaultDir points to a temp directory: ${config.vaultDir}`);
+      console.error(`[context-vault] This is likely from a test run that overwrote ~/.context-mcp/config.json`);
+      console.error(`[context-vault] Fix: run 'context-vault reconnect' or 'context-vault setup'`);
+    }
+
+    if (config.vaultDirExists) {
+      try {
+        const entries = readdirSync(config.vaultDir);
+        const hasMdFiles = entries.some(f => f.endsWith('.md'));
+        const hasMarker = entries.includes('.context-mcp');
+        if (!hasMdFiles && hasMarker) {
+          console.error(`[context-vault] WARNING: vaultDir has no markdown files but has a marker file`);
+          console.error(`[context-vault] The vault may be misconfigured. Run 'context-vault reconnect'`);
+        }
+      } catch {}
+    }
+
     console.error(`[context-vault] Vault: ${config.vaultDir}`);
     console.error(`[context-vault] Database: ${config.dbPath}`);
     console.error(`[context-vault] Dev dir: ${config.devDir}`);
@@ -336,6 +360,8 @@ async function main(): Promise<void> {
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
 
+    setSessionId(randomUUID());
+
     try {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {

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

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { gatherVaultStatus, computeGrowthWarnings } from '../status.js';
 import { errorLogPath, errorLogCount } from '../error-log.js';
-import { ok, err } from '../helpers.js';
+import { ok, err, kindIcon } from '../helpers.js';
 import type { LocalCtx, ToolResult } from '../types.js';
 
 function relativeTime(ts: number): string {
@@ -30,53 +30,88 @@ export function handler(_args: Record<string, any>, ctx: LocalCtx): ToolResult {
     const hasIssues = status.stalePaths || (status.embeddingStatus?.missing ?? 0) > 0;
     const healthIcon = hasIssues ? '⚠' : '✓';
 
+    const schemaVersion = (ctx.db.prepare('PRAGMA user_version').get() as any)?.user_version ?? 'unknown';
+    const embedPct = status.embeddingStatus
+      ? (status.embeddingStatus.total > 0 ? Math.round((status.embeddingStatus.indexed / status.embeddingStatus.total) * 100) : 100)
+      : null;
+    const embedStr = status.embeddingStatus
+      ? `${status.embeddingStatus.indexed}/${status.embeddingStatus.total} (${embedPct}%)`
+      : 'n/a';
+    const modelStr = status.embedModelAvailable === false ? '⚠ unavailable' : status.embedModelAvailable === true ? '✓ loaded' : 'unknown';
+
     const lines = [
-      `## ${healthIcon} Vault Status (connected)`,
+      `## ${healthIcon} Vault Dashboard`,
       ``,
-      `Vault:     ${config.vaultDir} (${config.vaultDirExists ? status.fileCount + ' files' : 'missing'})`,
-      `Database:  ${config.dbPath} (${status.dbSize})`,
-      `Dev dir:   ${config.devDir}`,
-      `Data dir:  ${config.dataDir}`,
-      `Config:    ${config.configPath}`,
-      `Resolved via: ${status.resolvedFrom}`,
-      `Schema:    v9 (updated_at, superseded_by)`,
+      `| | |`,
+      `|---|---|`,
+      `| **Vault** | ${config.vaultDir} (${config.vaultDirExists ? status.fileCount + ' files' : '⚠ missing'}) |`,
+      `| **Database** | ${config.dbPath} (${status.dbSize}) |`,
+      `| **Schema** | v${schemaVersion} |`,
+      `| **Embeddings** | ${embedStr} |`,
+      `| **Model** | ${modelStr} |`,
+      `| **Event decay** | ${config.eventDecayDays} days |`,
     ];
-
-    if (status.embeddingStatus) {
-      const { indexed, total, missing } = status.embeddingStatus;
-      const pct = total > 0 ? Math.round((indexed / total) * 100) : 100;
-      lines.push(`Embeddings: ${indexed}/${total} (${pct}%)`);
-    }
-    if (status.embedModelAvailable === false) {
-      lines.push(`Embed model: unavailable (semantic search disabled, FTS still works)`);
-    } else if (status.embedModelAvailable === true) {
-      lines.push(`Embed model: loaded`);
-    }
-    lines.push(`Decay:     ${config.eventDecayDays} days (event recency window)`);
     if (status.expiredCount > 0) {
-      lines.push(
-        `Expired:   ${status.expiredCount} entries pending prune (run \`context-vault prune\` to remove now)`
-      );
+      lines.push(`| **Expired** | ${status.expiredCount} pending prune |`);
     }
 
-    lines.push(``, `### Indexed`);
+    // 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(``, `### Entries by Kind`);
     if (status.kindCounts.length) {
-      for (const { kind, c } of status.kindCounts) lines.push(`- ${c} ${kind}s`);
+      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)`);
+      lines.push(`_(empty vault)_`);
     }
 
     if (status.categoryCounts.length) {
       lines.push(``);
       lines.push(`### Categories`);
-      for (const { category, c } of status.categoryCounts) lines.push(`- ${category}: ${c}`);
+      for (const { category, c } of status.categoryCounts) lines.push(`- **${category}**: ${c}`);
     }
 
     if (status.subdirs.length) {
       lines.push(``);
-      lines.push(`### Disk Directories`);
-      for (const { name, count } of status.subdirs) lines.push(`- ${name}/: ${count} files`);
+      lines.push(`### Disk`);
+      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) {

package/src/tools/get-context.ts

@@ -8,7 +8,7 @@ import { normalizeKind } from '@context-vault/core/files';
 import { parseContextParam } from '@context-vault/core/context';
 import { resolveTemporalParams } from '../temporal.js';
 import { collectLinkedEntries } from '../linking.js';
-import { ok, err, errWithHint } from '../helpers.js';
+import { ok, err, errWithHint, kindIcon, fmtDate } from '../helpers.js';
 import { isEmbedAvailable } from '@context-vault/core/embed';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
@@ -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;
@@ -633,23 +634,24 @@ export async function handler(
     const r = filtered[i];
     const isSkeleton = i >= effectivePivot;
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
-    const tagStr = entryTags.length ? entryTags.join(', ') : 'none';
-    const relPath =
-      r.file_path && config.vaultDir
-        ? r.file_path.replace(config.vaultDir + '/', '')
-        : r.file_path || 'n/a';
-    const skeletonLabel = isSkeleton ? ' ⊘ skeleton' : '';
+    const tagStr = entryTags.length ? entryTags.join(', ') : '';
+    const icon = kindIcon(r.kind);
+    const skeletonLabel = isSkeleton ? ' `skeleton`' : '';
+    const tierLabel = r.tier ? `**${r.tier}**` : '';
+    const dateStr = r.updated_at && r.updated_at !== r.created_at
+      ? `${fmtDate(r.created_at)} (upd ${fmtDate(r.updated_at)})`
+      : fmtDate(r.created_at);
     lines.push(
-      `### [${i + 1}/${filtered.length}] ${r.title || '(untitled)'} [${r.kind}/${r.category}]${skeletonLabel}`
-    );
-    const dateStr =
-      r.updated_at && r.updated_at !== r.created_at
-        ? `${r.created_at} (updated ${r.updated_at})`
-        : r.created_at || '';
-    const tierStr = r.tier ? ` · tier: ${r.tier}` : '';
-    lines.push(
-      `${r.score.toFixed(3)} · ${tagStr} · ${relPath} · ${dateStr} · skeleton: ${isSkeleton}${tierStr} · id: \`${r.id}\``
+      `### ${icon} ${r.title || '(untitled)'}${skeletonLabel}`
     );
+    const meta = [
+      `\`${r.score.toFixed(2)}\``,
+      `\`${r.kind}\``,
+      tierLabel,
+      tagStr,
+      dateStr,
+    ].filter(Boolean).join(' · ');
+    lines.push(`${meta}  \nid: \`${r.id}\``);
     const stalenessResult = checkStaleness(r);
     if (stalenessResult) {
       r.stale = true;
@@ -691,15 +693,13 @@ export async function handler(
     if (uniqueLinked.length > 0) {
       lines.push(`## Linked Entries (${uniqueLinked.length} via related_to)\n`);
       for (const r of uniqueLinked) {
-        const direction = forward.some((f: any) => f.id === r.id) ? '→ forward' : '← backlink';
+        const direction = forward.some((f: any) => f.id === r.id) ? '→' : '←';
         const entryTags = r.tags ? JSON.parse(r.tags) : [];
-        const tagStr = entryTags.length ? entryTags.join(', ') : 'none';
-        const relPath =
-          r.file_path && config.vaultDir
-            ? r.file_path.replace(config.vaultDir + '/', '')
-            : r.file_path || 'n/a';
-        lines.push(`### ${r.title || '(untitled)'} [${r.kind}/${r.category}] ${direction}`);
-        lines.push(`${tagStr} · ${relPath} · id: \`${r.id}\``);
+        const tagStr = entryTags.length ? entryTags.join(', ') : '';
+        const icon = kindIcon(r.kind);
+        lines.push(`### ${icon} ${r.title || '(untitled)'} ${direction}`);
+        const meta = [`\`${r.kind}\``, tagStr].filter(Boolean).join(' · ');
+        lines.push(`${meta}  \nid: \`${r.id}\``);
         lines.push(truncateBody(r.body, body_limit ?? 300));
         lines.push('');
       }

package/src/tools/list-context.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { normalizeKind } from '@context-vault/core/files';
 import { categoryFor } from '@context-vault/core/categories';
-import { ok, err, errWithHint } from '../helpers.js';
+import { ok, err, errWithHint, kindIcon, fmtDate } from '../helpers.js';
 import { resolveTemporalParams } from '../temporal.js';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
@@ -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,18 +128,26 @@ export async function handler(
       `> ℹ Event search limited to last ${days} days. Use \`since\` parameter for older results.\n`
     );
   }
+  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(', ') : 'none';
-    const dateStr =
-      r.updated_at && r.updated_at !== r.created_at
-        ? `${r.created_at} (updated ${r.updated_at})`
-        : r.created_at;
-    lines.push(
-      `- **${r.title || '(untitled)'}** [${r.kind}/${r.category}] — ${tagStr} — ${dateStr} — \`${r.id}\``
-    );
-    if (r.preview)
-      lines.push(`  ${r.preview.replace(/\n+/g, ' ').trim()}${r.preview.length >= 120 ? '…' : ''}`);
+    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, '\\|');
+    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,10 +1,14 @@
 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 { ok, err, errWithHint, ensureVaultExists, ensureValidKind } from '../helpers.js';
+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';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.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,
@@ -82,13 +114,13 @@ async function findSimilar(
 }
 
 function formatSimilarWarning(similar: any[]): string {
-  const lines = ['', '⚠ Similar entries already exist:'];
+  const lines = ['', '### ⚠ Similar entries'];
   for (const e of similar) {
-    const score = e.score.toFixed(2);
-    const title = e.title ? `"${e.title}"` : '(no title)';
-    lines.push(`  - ${title} (${score}) — id: ${e.id}`);
+    const score = (e.score * 100).toFixed(0);
+    const title = e.title ? `**${e.title}**` : '(no title)';
+    lines.push(`- ${title} \`${score}%\` · \`${e.id}\``);
   }
-  lines.push('  Consider using `id: <existing>` in save_context to update instead.');
+  lines.push('_Use `id` param to update instead of creating a duplicate._');
   return lines.join('\n');
 }
 
@@ -142,13 +174,12 @@ export function buildConflictCandidates(similarEntries: any[]): any[] {
 }
 
 function formatConflictSuggestions(candidates: any[]): string {
-  const lines = ['', '── Conflict Resolution Suggestions ──'];
+  const lines = ['', '### Conflict Resolution'];
   for (const c of candidates) {
-    const titleDisplay = c.title ? `"${c.title}"` : '(no title)';
-    lines.push(
-      `  [${c.suggested_action}] ${titleDisplay} (${(c.score * 100).toFixed(0)}%) — id: ${c.id}`
-    );
-    lines.push(`    ${c.reasoning_context}`);
+    const titleDisplay = c.title ? `**${c.title}**` : '(no title)';
+    const actionIcon = c.suggested_action === 'SKIP' ? '⊘' : c.suggested_action === 'UPDATE' ? '↻' : '＋';
+    lines.push(`${actionIcon} **${c.suggested_action}** ${titleDisplay} \`${(c.score * 100).toFixed(0)}%\` · \`${c.id}\``);
+    lines.push(`  ${c.reasoning_context}`);
   }
   return lines.join('\n');
 }
@@ -317,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(
@@ -339,6 +376,7 @@ export async function handler(
     tier,
     conflict_resolution,
     encoding_context,
+    indexed,
   }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed }: SharedCtx
@@ -448,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;
@@ -549,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 {
@@ -568,8 +620,8 @@ export async function handler(
         supersedes,
         related_to,
         source_files,
-
         tier: effectiveTier,
+        indexed: effectiveIndexed,
       },
       embeddingToReuse
     );
@@ -582,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) {
@@ -599,6 +651,10 @@ export async function handler(
     }
   }
 
+  if (isDualWriteEnabled(config) && entry.filePath) {
+    dualWriteLocal(entry.filePath, normalizedKind);
+  }
+
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);
   }
@@ -606,11 +662,25 @@ export async function handler(
   const relPath = entry.filePath
     ? entry.filePath.replace(config.vaultDir + '/', '')
     : entry.filePath;
-  const parts = [`✓ Saved ${normalizedKind} → ${relPath}`, `  id: ${entry.id}`];
-  if (title) parts.push(`  title: ${title}`);
-  if (tags?.length) parts.push(`  tags: ${tags.join(', ')}`);
-  parts.push(`  tier: ${effectiveTier}`);
-  parts.push('', '_Use this id to update or delete later._');
+  const icon = kindIcon(normalizedKind);
+  const parts = [
+    `## ✓ Saved`,
+    `${icon} **${title || '(untitled)'}**`,
+    `\`${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(
+      '',
+      '_Note: ephemeral entries are excluded from default search. Use `include_ephemeral: true` in get_context to find them._'
+    );
+  }
   const hasBucketTag = (tags || []).some(
     (t: any) => typeof t === 'string' && t.startsWith('bucket:')
   );
@@ -624,18 +694,25 @@ export async function handler(
     (t: any) => typeof t === 'string' && t.startsWith('bucket:')
   );
   for (const bt of bucketTags) {
-    const bucketUserClause = '';
-    const bucketParams = false ? [bt] : [bt];
     const exists = ctx.db
       .prepare(
-        `SELECT 1 FROM vault WHERE kind = 'bucket' AND identity_key = ? ${bucketUserClause} LIMIT 1`
+        `SELECT 1 FROM vault WHERE kind = 'bucket' AND identity_key = ? LIMIT 1`
       )
-      .get(...bucketParams);
+      .get(bt);
     if (!exists) {
-      parts.push(
-        ``,
-        `_Note: bucket '${bt}' is not registered. Use save_context(kind: "bucket", identity_key: "${bt}") to register it._`
-      );
+      // Auto-register the bucket silently
+      const bucketName = bt.replace(/^bucket:/, '');
+      try {
+        await captureAndIndex(ctx, {
+          kind: 'bucket',
+          title: bucketName,
+          body: `Bucket for project: ${bucketName}`,
+          tags: [bt],
+          identity_key: bt,
+        });
+      } catch {
+        // Non-fatal: bucket registration failure should not block the save
+      }
     }
   }
   if (similarEntries.length) {