context-vault 3.13.0 → 3.16.1

package/src/server.ts

@@ -3,10 +3,6 @@
 import { randomUUID } from 'node:crypto';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-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, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
@@ -31,240 +27,9 @@ import {
 } from '@context-vault/core/db';
 import { registerTools } from './register-tools.js';
 import { pruneExpired } from '@context-vault/core/index';
+import { startWatcher } from '@context-vault/core/watch';
 import { setSessionId } from '@context-vault/core/search';
 
-const DAEMON_PORT = 3377;
-const PID_PATH = join(homedir(), '.context-mcp', 'daemon.pid');
-
-async function tryAutoDaemon(): Promise<void> {
-  // Check if daemon is already running
-  if (existsSync(PID_PATH)) {
-    try {
-      const { pid, port } = JSON.parse(readFileSync(PID_PATH, 'utf-8'));
-      process.kill(pid, 0); // throws if dead
-      const res = await fetch(`http://localhost:${port}/health`);
-      if (res.ok) return; // daemon is healthy, nothing to do
-    } catch {
-      // stale PID file or unhealthy, continue to start daemon
-    }
-  }
-
-  const { spawn, execFileSync } = await import('node:child_process');
-
-  // Spawn daemon process
-  const serverPath = join(__dirname, 'server.js');
-  const child = spawn(process.execPath, [serverPath, '--http', '--port', String(DAEMON_PORT)], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env, NODE_OPTIONS: '--no-warnings=ExperimentalWarning' },
-  });
-  child.unref();
-
-  // Wait for daemon to be healthy
-  const deadline = Date.now() + 5000;
-  let healthy = false;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`http://localhost:${DAEMON_PORT}/health`);
-      if (res.ok) { healthy = true; break; }
-    } catch {}
-    await new Promise(r => setTimeout(r, 200));
-  }
-
-  if (!healthy) {
-    console.error('[context-vault] Auto-daemon failed to start, continuing in stdio mode');
-    return;
-  }
-
-  // Reconfigure Claude Code to use HTTP transport
-  const env = { ...process.env };
-  delete (env as Record<string, string | undefined>).CLAUDECODE;
-  try {
-    execFileSync('claude', ['mcp', 'remove', 'context-vault', '-s', 'user'], { stdio: 'pipe', env });
-  } catch {}
-  try {
-    execFileSync('claude', [
-      'mcp', 'add', '-s', 'user', '--transport', 'http',
-      'context-vault', `http://localhost:${DAEMON_PORT}/mcp`,
-    ], { stdio: 'pipe', env });
-    console.error(`[context-vault] Daemon started on port ${DAEMON_PORT}. New sessions will use shared HTTP mode.`);
-  } catch {
-    console.error('[context-vault] Daemon started but could not reconfigure Claude Code');
-  }
-}
-
-async function selfCheck(port: number): Promise<void> {
-  const { execFileSync } = await import('node:child_process');
-  const env = { ...process.env };
-  delete (env as Record<string, string | undefined>).CLAUDECODE;
-
-  // 1. Validate LaunchAgent plist on macOS (correct node/server paths)
-  if (process.platform === 'darwin') {
-    const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'com.context-vault.daemon.plist');
-    if (existsSync(plistPath)) {
-      try {
-        const plist = readFileSync(plistPath, 'utf-8');
-        const currentNode = process.execPath;
-        const currentServer = join(__dirname, 'server.js');
-        if (!plist.includes(currentNode) || !plist.includes(currentServer)) {
-          console.error('[context-vault] Self-heal: LaunchAgent has stale paths, rewriting...');
-          const vaultDirIdx = process.argv.indexOf('--vault-dir');
-          const vaultDir = vaultDirIdx !== -1 ? process.argv[vaultDirIdx + 1] : undefined;
-          const progArgs = [currentNode, currentServer, '--http', '--port', String(port)];
-          if (vaultDir) progArgs.push('--vault-dir', vaultDir);
-          const logPath = join(homedir(), '.context-mcp', 'daemon.log');
-          const newPlist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>com.context-vault.daemon</string>
-  <key>ProgramArguments</key>
-  <array>
-${progArgs.map(a => `    <string>${a}</string>`).join('\n')}
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key>
-    <false/>
-  </dict>
-  <key>StandardErrorPath</key>
-  <string>${logPath}</string>
-  <key>StandardOutPath</key>
-  <string>/dev/null</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>NODE_OPTIONS</key>
-    <string>--no-warnings=ExperimentalWarning</string>
-    <key>CONTEXT_VAULT_NO_DAEMON</key>
-    <string>1</string>
-  </dict>
-  <key>ThrottleInterval</key>
-  <integer>5</integer>
-</dict>
-</plist>`;
-          writeFileSync(plistPath, newPlist);
-          // Reload the agent so launchd picks up new paths
-          try { execFileSync('launchctl', ['unload', plistPath], { stdio: 'pipe' }); } catch {}
-          try { execFileSync('launchctl', ['load', '-w', plistPath], { stdio: 'pipe' }); } catch {}
-          console.error('[context-vault] Self-heal: LaunchAgent updated with current paths');
-        }
-      } catch (e) {
-        console.error(`[context-vault] LaunchAgent check failed: ${(e as Error).message}`);
-      }
-    }
-  }
-
-  // 2. Validate Claude Code MCP config points to this daemon
-  try {
-    const result = execFileSync('claude', ['mcp', 'list'], {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env,
-      timeout: 5000,
-    });
-    if (result.includes('context-vault') && !result.includes(`localhost:${port}`)) {
-      console.error('[context-vault] Self-heal: Claude Code not pointing to this daemon, reconfiguring...');
-      try { execFileSync('claude', ['mcp', 'remove', 'context-vault', '-s', 'user'], { stdio: 'pipe', env }); } catch {}
-      execFileSync('claude', [
-        'mcp', 'add', '-s', 'user', '--transport', 'http',
-        'context-vault', `http://localhost:${port}/mcp`,
-      ], { stdio: 'pipe', env });
-      console.error('[context-vault] Self-heal: Claude Code reconfigured');
-    }
-  } catch {
-    // claude CLI not available or check failed, skip
-  }
-}
-
-/**
- * Auto-update: check npm for a newer version. In daemon (HTTP) mode,
- * install the update and gracefully restart. In stdio mode, just log.
- */
-async function autoUpdate(isDaemon: boolean): Promise<string | null> {
-  const { execSync, spawn: spawnProc } = await import('node:child_process');
-  // Use a non-blocking npm check to avoid event loop stalls during reindex
-  const latest = await new Promise<string>((resolve, reject) => {
-    const child = spawnProc('npm', ['view', 'context-vault', 'version'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      timeout: 10000,
-    });
-    let out = '';
-    child.stdout?.on('data', (d: Buffer) => { out += d.toString(); });
-    child.on('close', (code: number | null) => {
-      if (code === 0 && out.trim()) resolve(out.trim());
-      else reject(new Error(`npm view failed (code ${code})`));
-    });
-    child.on('error', reject);
-  }).catch(() => null as string | null) as string;
-
-  if (!latest) return null; // offline or registry unreachable
-  if (latest === pkg.version) return latest;
-
-  console.error(`[context-vault] Update available: v${pkg.version} -> v${latest}`);
-
-  if (!isDaemon) {
-    console.error('[context-vault] Run: context-vault update');
-    return latest;
-  }
-
-  // Daemon mode: auto-install and restart
-  console.error(`[context-vault] Auto-updating to v${latest}...`);
-  try {
-    execSync('npm install -g context-vault@latest', {
-      encoding: 'utf-8',
-      timeout: 120000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    console.error(`[context-vault] Installed v${latest}. Restarting daemon...`);
-
-    // Find our own server.js path in the updated install
-    const newBin = execSync('which context-vault', {
-      encoding: 'utf-8',
-      timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-
-    // Resolve the actual package root from the binary
-    const { readlinkSync } = await import('node:fs');
-    const { resolve: resolvePath } = await import('node:path');
-    let binTarget = newBin;
-    try { binTarget = readlinkSync(newBin); } catch {}
-    const newPkgRoot = resolvePath(dirname(binTarget), '..');
-    const newServerJs = join(newPkgRoot, 'dist', 'server.js');
-
-    // Spawn the new version as a replacement daemon
-    const portIdx = process.argv.indexOf('--port');
-    const port = portIdx !== -1 ? process.argv[portIdx + 1] : '3377';
-    const args = [newServerJs, '--http', '--port', port];
-
-    // Pass through vault-dir if specified
-    const vaultIdx = process.argv.indexOf('--vault-dir');
-    if (vaultIdx !== -1 && process.argv[vaultIdx + 1]) {
-      args.push('--vault-dir', process.argv[vaultIdx + 1]);
-    }
-
-    const { spawn } = await import('node:child_process');
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      env: { ...process.env, NODE_OPTIONS: '--no-warnings=ExperimentalWarning', CONTEXT_VAULT_NO_DAEMON: '1' },
-    });
-    child.unref();
-
-    // Give the new process a moment to bind the port, then exit
-    await new Promise(r => setTimeout(r, 2000));
-    console.error(`[context-vault] New daemon spawned (PID ${child.pid}). Old daemon exiting.`);
-    process.exit(0);
-  } catch (e) {
-    console.error(`[context-vault] Auto-update failed: ${(e as Error).message}`);
-    console.error('[context-vault] Run manually: context-vault update');
-  }
-  return latest;
-}
-
 async function main(): Promise<void> {
   let phase = 'CONFIG';
   let db: import('node:sqlite').DatabaseSync | undefined;
@@ -375,6 +140,24 @@ async function main(): Promise<void> {
       );
     }
 
+    if (config.watch?.enabled === true && config.vaultDirExists) {
+      try {
+        const vaultWatcher = startWatcher(ctx, {
+          vaultDir: config.watch?.path || config.vaultDir,
+          debounceMs: config.watch?.debounceMs ?? 500,
+          indexingConfig: config.indexing,
+          dataDir: config.dataDir,
+          onError: (err) => console.error(`[context-vault] Watcher: ${err.message}`),
+        });
+        // Expose markSelfWrite on ctx so save_context can suppress re-indexing
+        (ctx as any).markSelfWrite = vaultWatcher.markSelfWrite;
+        process.on('exit', () => vaultWatcher.close());
+        console.error('[context-vault] Filesystem watcher active (opt-in via config)');
+      } catch (err) {
+        console.error(`[context-vault] Watcher skipped: ${(err as Error).message}`);
+      }
+    }
+
     phase = 'SERVER';
 
     const CONFIG_CACHE_TTL_MS = 30_000;
@@ -407,15 +190,13 @@ async function main(): Promise<void> {
       return s;
     }
 
-    const server = createServer();
-
     function closeDb(): void {
       try {
         if ((db as any).inTransaction) {
           console.error('[context-vault] Rolling back active transaction...');
           db!.exec('ROLLBACK');
         }
-        (db as any).pragma('wal_checkpoint(TRUNCATE)');
+        db!.exec('PRAGMA wal_checkpoint(TRUNCATE)');
         db!.close();
         console.error('[context-vault] Database closed cleanly.');
       } catch (shutdownErr) {
@@ -426,7 +207,6 @@ async function main(): Promise<void> {
 
     function shutdown(signal: string): void {
       console.error(`[context-vault] Received ${signal}, shutting down...`);
-      try { unlinkSync(join(homedir(), '.context-mcp', 'daemon.pid')); } catch {}
 
       if (ctx.activeOps.count > 0) {
         console.error(
@@ -462,196 +242,16 @@ async function main(): Promise<void> {
         const capMb = Math.round(MAX_RSS_BYTES / 1024 / 1024);
         console.error(`[context-vault] WATCHDOG: RSS ${rssMb}MB exceeds ${capMb}MB limit. Shutting down to protect system resources.`);
         console.error(`[context-vault] Adjust limit with CONTEXT_VAULT_MAX_RSS_MB env var, or run 'context-vault reindex' manually.`);
-        try { unlinkSync(PID_PATH); } catch {}
         process.exit(137);
       }
     }, 5_000);
     rssWatchdog.unref();
 
     phase = 'CONNECTED';
-    let latestKnownVersion: string | null = null;
-
-    const useHttp = process.argv.includes('--http');
-
-    if (useHttp) {
-      const portIdx = process.argv.indexOf('--port');
-      const port = portIdx !== -1 && process.argv[portIdx + 1]
-        ? parseInt(process.argv[portIdx + 1], 10)
-        : 3377;
-
-      const app = createMcpExpressApp();
-      const transports: Record<string, StreamableHTTPServerTransport> = {};
-
-      app.get('/health', (_req: IncomingMessage, res: ServerResponse) => {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          ok: true,
-          version: pkg.version,
-          latestVersion: latestKnownVersion,
-          updateAvailable: latestKnownVersion ? latestKnownVersion !== pkg.version : null,
-          pid: process.pid,
-          uptime: process.uptime(),
-          sessions: Object.keys(transports).length,
-        }));
-      });
-
-      function createTransport(): StreamableHTTPServerTransport {
-        const transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => randomUUID(),
-          onsessioninitialized: (sid: string) => {
-            transports[sid] = transport;
-          },
-        });
-        transport.onclose = () => {
-          const sid = transport.sessionId;
-          if (sid && transports[sid]) {
-            delete transports[sid];
-          }
-        };
-        return transport;
-      }
-
-      app.post('/mcp', async (req: IncomingMessage & { body?: unknown }, res: ServerResponse) => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined;
-        try {
-          let transport: StreamableHTTPServerTransport;
-          if (sessionId && transports[sessionId]) {
-            transport = transports[sessionId];
-          } else if (isInitializeRequest((req as any).body)) {
-            // Allow (re-)initialization with or without a stale session ID.
-            // Covers: first connect, reconnect after daemon restart.
-            transport = createTransport();
-            const sessionServer = createServer();
-            await sessionServer.connect(transport);
-            await transport.handleRequest(req, res, (req as any).body);
-            return;
-          } else if (sessionId) {
-            // Stale session (e.g., daemon restarted). Claude Code's MCP client
-            // does not auto-reinitialize on 404, so we recover transparently:
-            // create a new transport reusing the stale session ID, force it into
-            // initialized state, and handle the request as if nothing happened.
-            console.error(`[context-vault] Recovering stale session ${sessionId.slice(0, 8)}...`);
-
-            transport = new StreamableHTTPServerTransport({
-              sessionIdGenerator: () => sessionId,
-              onsessioninitialized: (sid: string) => {
-                transports[sid] = transport;
-              },
-            });
-            transport.onclose = () => {
-              if (transports[sessionId]) delete transports[sessionId];
-            };
-
-            const sessionServer = createServer();
-            await sessionServer.connect(transport);
-
-            // Force transport into initialized state, bypassing the initialize
-            // handshake. The inner WebStandardStreamableHTTPServerTransport holds
-            // the _initialized flag and sessionId.
-            const inner = (transport as any)._webStandardTransport;
-            inner._initialized = true;
-            inner.sessionId = sessionId;
-            transports[sessionId] = transport;
-
-            // Fall through to handleRequest below
-          } else {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-              jsonrpc: '2.0',
-              error: { code: -32000, message: 'Bad Request: No valid session ID' },
-              id: null,
-            }));
-            return;
-          }
-          await transport.handleRequest(req, res, (req as any).body);
-        } catch (error) {
-          console.error('[context-vault] HTTP error:', error);
-          if (!res.headersSent) {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-              jsonrpc: '2.0',
-              error: { code: -32603, message: 'Internal server error' },
-              id: null,
-            }));
-          }
-        }
-      });
-
-      app.get('/mcp', async (req: IncomingMessage, res: ServerResponse) => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined;
-        if (!sessionId || !transports[sessionId]) {
-          res.writeHead(404);
-          res.end('Session not found');
-          return;
-        }
-        await transports[sessionId].handleRequest(req, res);
-      });
-
-      app.delete('/mcp', async (req: IncomingMessage, res: ServerResponse) => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined;
-        if (!sessionId || !transports[sessionId]) {
-          res.writeHead(404);
-          res.end('Session not found');
-          return;
-        }
-        await transports[sessionId].handleRequest(req, res);
-      });
-
-      app.listen(port, () => {
-        console.error(`[context-vault] Serving on http://localhost:${port}/mcp`);
-        const pidDir = join(homedir(), '.context-mcp');
-        mkdirSync(pidDir, { recursive: true });
-        writeFileSync(join(pidDir, 'daemon.pid'), JSON.stringify({ pid: process.pid, port }));
-
-        // Self-healing: validate and repair infrastructure on startup
-        selfCheck(port).catch(() => {});
-
-        // Periodic health monitor: validate DB, vault, and PID file every 5 minutes
-        setInterval(() => {
-          try {
-            // Verify DB is accessible
-            ctx.db.exec('SELECT 1');
-            // Verify PID file is correct
-            const pidData = existsSync(PID_PATH)
-              ? JSON.parse(readFileSync(PID_PATH, 'utf-8'))
-              : null;
-            if (!pidData || pidData.pid !== process.pid || pidData.port !== port) {
-              writeFileSync(PID_PATH, JSON.stringify({ pid: process.pid, port }));
-              console.error('[context-vault] Self-heal: repaired stale PID file');
-            }
-            // Verify vault directory
-            if (!existsSync(ctx.config.vaultDir)) {
-              console.error(`[context-vault] Warning: vault directory missing: ${ctx.config.vaultDir}`);
-            }
-          } catch (e) {
-            console.error(`[context-vault] Health check failed: ${(e as Error).message}`);
-          }
-        }, 5 * 60 * 1000);
-      });
-    } else {
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
-
-      // Auto-daemonize: if no daemon is running, spawn one in the background
-      // and reconfigure Claude Code to use HTTP. Next session onwards, all
-      // sessions share the single daemon process. This session stays on stdio.
-      if (!process.env.CONTEXT_VAULT_NO_DAEMON) {
-        setTimeout(() => tryAutoDaemon().catch(() => {}), 2000);
-      }
-    }
 
-    // Auto-update check (and apply for daemon mode)
-    const updateCheck = async () => {
-      const result = await autoUpdate(useHttp);
-      if (result) latestKnownVersion = result;
-    };
-    setTimeout(() => updateCheck().catch((e) => {
-      console.error(`[context-vault] Update check failed: ${(e as Error).message}`);
-    }), 5000);
-    // Re-check daily for long-running daemons
-    if (useHttp) {
-      setInterval(() => updateCheck().catch(() => {}), 24 * 60 * 60 * 1000);
-    }
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
   } catch (rawErr) {
     const err = rawErr as Error;
     const dataDir = config?.dataDir || join(homedir(), '.context-mcp');

package/src/status.ts

@@ -162,6 +162,21 @@ export function gatherVaultStatus(ctx: LocalCtx, opts: Record<string, unknown> =
     errors.push(`Indexing stats failed: ${(e as Error).message}`);
   }
 
+  let ftsRowCount: number | null = null;
+  try {
+    ftsRowCount = (db.prepare('SELECT COUNT(*) as c FROM vault_fts').get() as { c: number } | undefined)?.c ?? 0;
+  } catch (e) {
+    errors.push(`FTS row count failed: ${(e as Error).message}`);
+  }
+
+  let coRetrievalPairCount = 0;
+  try {
+    coRetrievalPairCount =
+      (db.prepare('SELECT COUNT(*) as c FROM co_retrievals').get() as { c: number } | undefined)?.c ?? 0;
+  } catch (e) {
+    errors.push(`Co-retrieval count failed: ${(e as Error).message}`);
+  }
+
   let staleKnowledge: unknown[] = [];
   try {
     const stalenessKinds = Object.entries(KIND_STALENESS_DAYS);
@@ -219,6 +234,8 @@ export function gatherVaultStatus(ctx: LocalCtx, opts: Record<string, unknown> =
     archivedCount,
     staleKnowledge,
     indexingStats,
+    ftsRowCount,
+    coRetrievalPairCount,
     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 { gatherRecallSummary } from '../stats/recall.js';
-import { errorLogPath, errorLogCount } from '../error-log.js';
+import { errorLogPath, errorLogCount, embedRelatedLogTail } from '../error-log.js';
 import { getAutoMemory } from '../auto-memory.js';
 import { ok, err, kindIcon } from '../helpers.js';
 import type { LocalCtx, ToolResult } from '../types.js';
@@ -104,6 +104,12 @@ export function handler(_args: Record<string, any>, ctx: LocalCtx): ToolResult {
       const pct = ix.total > 0 ? Math.round((ix.indexed / ix.total) * 100) : 100;
       lines.push(`| **Indexed entries** | ${ix.indexed}/${ix.total} (${pct}%) |`);
     }
+    if (status.ftsRowCount != null) {
+      lines.push(`| **Search index rows** | ${status.ftsRowCount.toLocaleString()} |`);
+    }
+    lines.push(
+      `| **Related entry pairs** | ${(status.coRetrievalPairCount ?? 0).toLocaleString()} |`
+    );
 
     // Indexed kinds as compact table
     lines.push(``, `### Entries by Kind`);
@@ -219,6 +225,29 @@ export function handler(_args: Record<string, any>, ctx: LocalCtx): ToolResult {
       lines.push(`Use save_context to refresh or add expires_at to retire stale entries.`);
     }
 
+    const embedLogHints = embedRelatedLogTail(config.dataDir);
+    if (embedLogHints.length > 0) {
+      lines.push(``, `### Embedding hints (error.log tail)`);
+      lines.push(`_Lines mentioning embeddings — see \`docs/large-vaults.md\` for triage._`);
+      for (const ln of embedLogHints) {
+        lines.push(`- ${ln.length > 240 ? ln.slice(0, 237) + '...' : ln}`);
+      }
+    }
+
+    const healthSnapshot = {
+      total_entries: status.embeddingStatus?.total ?? null,
+      searchable: status.embeddingStatus?.indexed ?? null,
+      pending_indexing: status.embeddingStatus?.missing ?? null,
+      search_index_rows: status.ftsRowCount ?? null,
+      related_pairs: status.coRetrievalPairCount ?? 0,
+      database_size_bytes: status.dbSizeBytes ?? null,
+      files_on_disk: status.fileCount,
+    };
+    lines.push(``, `### Vault Health Snapshot`);
+    lines.push('```json');
+    lines.push(JSON.stringify(healthSnapshot, null, 2));
+    lines.push('```');
+
     // Error log
     const logPath = errorLogPath(config.dataDir);
     const logCount = errorLogCount(config.dataDir);

package/src/tools/delete-context.ts

@@ -6,10 +6,10 @@ import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 export const name = 'delete_context';
 
 export const description =
-  'Delete an entry from your vault by its ULID id. Removes the file from disk and cleans up the search index.';
+  'Delete an entry from your vault by its ID. Removes the file from disk and cleans up the search index.';
 
 export const inputSchema = {
-  id: z.string().describe('The entry ULID to delete'),
+  id: z.string().describe('The entry ID to delete'),
 };
 
 export async function handler(
@@ -27,12 +27,17 @@ export async function handler(
     // Delete DB record first — if this fails, the file stays and no orphan is created
     const rowidResult = ctx.stmts.getRowid.get(id);
     if (rowidResult?.rowid) {
-      try {
-        ctx.deleteVec(Number(rowidResult.rowid));
-      } catch {}
+      try { ctx.deleteVec(Number(rowidResult.rowid)); } catch {}
+      try { ctx.deleteCtxVec(Number(rowidResult.rowid)); } catch {}
     }
     ctx.stmts.deleteEntry.run(id);
 
+    // Clean up access_log and co_retrievals references
+    try { ctx.db.prepare(`DELETE FROM access_log WHERE entry_id = ?`).run(id); } catch {}
+    try {
+      ctx.db.prepare(`DELETE FROM co_retrievals WHERE entry_a = ? OR entry_b = ?`).run(id, id);
+    } catch {}
+
     // Delete file from disk after successful DB delete
     let fileWarning = null;
     if (entry.file_path) {

package/src/tools/get-context.ts

@@ -324,7 +324,7 @@ export const inputSchema = {
     .number()
     .optional()
     .describe(
-      'Skeleton mode: top pivot_count entries by relevance are returned with full body. Remaining entries are returned as skeletons (title + tags + first ~100 chars of body). Default: 2. Set to 0 to skeleton all results, or a high number to disable.'
+      'Number of top results to return with full body text. Lower-ranked results are returned as summaries (title + tags + first ~100 chars). Default: 2. Set to 0 to summarize all results, or a high number to return all with full body.'
     ),
   include_ephemeral: z
     .boolean()
@@ -503,6 +503,7 @@ export async function handler(
       includeSuperseeded: include_superseded ?? false,
       includeEphemeral: include_ephemeral ?? false,
       contextEmbedding,
+      trackMeta: { query, sessionGoal: typeof context === 'string' ? context : context ? JSON.stringify(context) : undefined },
     });
 
     // Post-filter by tags if provided, then apply requested limit
@@ -724,7 +725,7 @@ export async function handler(
     const entryTags = r.tags ? JSON.parse(r.tags) : [];
     const tagStr = entryTags.length ? entryTags.join(', ') : '';
     const icon = kindIcon(r.kind);
-    const skeletonLabel = isSkeleton ? ' `skeleton`' : '';
+    const skeletonLabel = isSkeleton ? ' `[summary]`' : '';
     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)})`