context-vault 3.1.7 → 3.2.0

package/src/tools/{get-context.js → get-context.ts}

@@ -9,6 +9,7 @@ import { resolveTemporalParams } from '../temporal.js';
 import { collectLinkedEntries } from '../linking.js';
 import { ok, err, errWithHint } from '../helpers.js';
 import { isEmbedAvailable } from '@context-vault/core/embed';
+import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 const STALE_DUPLICATE_DAYS = 7;
 const DEFAULT_PIVOT_COUNT = 2;
@@ -21,7 +22,14 @@ const BRIEF_SCORE_BOOST = 0.05;
  * Truncate a body string to ~SKELETON_BODY_CHARS, breaking at sentence or
  * word boundary. Returns the truncated string with "..." appended.
  */
-export function skeletonBody(body) {
+function truncateBody(body: string | null | undefined, limit: number): string {
+  if (!body) return '';
+  if (limit === 0) return body;
+  if (body.length <= limit) return body;
+  return body.slice(0, limit) + '...';
+}
+
+export function skeletonBody(body: string | null | undefined): string {
   if (!body) return '';
   if (body.length <= SKELETON_BODY_CHARS) return body;
   const slice = body.slice(0, SKELETON_BODY_CHARS);
@@ -50,10 +58,13 @@ export function skeletonBody(body) {
  * rows already fetched from the DB.
  *
  * @param {Array} entries - Result rows (as returned by hybridSearch / filter-only mode)
- * @param {import('../types.js').BaseCtx} _ctx - Unused for now; reserved for future DB look-ups
+ * @param {import('@context-vault/core/types').BaseCtx} _ctx
  * @returns {Array<{entry_a_id: string, entry_b_id: string, reason: string, recommendation: string}>}
  */
-export function detectConflicts(entries, _ctx) {
+export function detectConflicts(
+  entries: any[],
+  _ctx: any
+): Array<{ entry_a_id: string; entry_b_id: string; reason: string; recommendation: string }> {
   const conflicts = [];
   const idSet = new Set(entries.map((e) => e.id));
 
@@ -90,14 +101,14 @@ export function detectConflicts(entries, _ctx) {
       if (!tagsA.length || !tagsB.length) continue;
 
       const tagsSetA = new Set(tagsA);
-      const sharedTag = tagsB.some((t) => tagsSetA.has(t));
+      const sharedTag = tagsB.some((t: any) => tagsSetA.has(t));
       if (!sharedTag) continue;
 
       const dateA = new Date(a.updated_at || a.created_at);
       const dateB = new Date(b.updated_at || b.created_at);
       if (isNaN(dateA.getTime()) || isNaN(dateB.getTime())) continue;
 
-      const diffDays = Math.abs(dateA - dateB) / 86400000;
+      const diffDays = Math.abs(dateA.getTime() - dateB.getTime()) / 86400000;
       if (diffDays <= STALE_DUPLICATE_DAYS) continue;
 
       const [older, newer] = dateA < dateB ? [a, b] : [b, a];
@@ -129,11 +140,15 @@ export function detectConflicts(entries, _ctx) {
  * @param {{ tagThreshold?: number, maxAgeDays?: number }} opts - Configurable thresholds
  * @returns {Array<{tag: string, entry_count: number, last_snapshot_age_days: number|null}>}
  */
-export function detectConsolidationHints(entries, db, opts = {}) {
+export function detectConsolidationHints(
+  entries: any[],
+  db: any,
+  opts: { tagThreshold?: number; maxAgeDays?: number } = {}
+): Array<{ tag: string; entry_count: number; last_snapshot_age_days: number | null }> {
   const tagThreshold = opts.tagThreshold ?? CONSOLIDATION_TAG_THRESHOLD;
   const maxAgeDays = opts.maxAgeDays ?? CONSOLIDATION_SNAPSHOT_MAX_AGE_DAYS;
 
-  const candidateTags = new Set();
+  const candidateTags = new Set<string>();
   for (const entry of entries) {
     if (entry.kind === 'brief') continue;
     const entryTags = entry.tags ? JSON.parse(entry.tags) : [];
@@ -148,15 +163,11 @@ export function detectConsolidationHints(entries, db, opts = {}) {
   for (const tag of candidateTags) {
     let vaultCount = 0;
     try {
-      // When userId is defined (hosted mode), scope to that user.
-      // When userId is undefined (local mode), no user scoping — column may not exist.
-      const userClause = '';
-      const countParams = false ? [`%"${tag}"%`] : [`%"${tag}"%`];
       const countRow = db
         .prepare(
-          `SELECT COUNT(*) as c FROM vault WHERE kind != 'brief' AND tags LIKE ?${userClause} AND (expires_at IS NULL OR expires_at > datetime('now')) AND superseded_by IS NULL`
+          `SELECT COUNT(*) as c FROM vault WHERE kind != 'brief' AND tags LIKE ? AND (expires_at IS NULL OR expires_at > datetime('now')) AND superseded_by IS NULL`
         )
-        .get(...countParams);
+        .get(`%"${tag}"%`);
       vaultCount = countRow?.c ?? 0;
     } catch {
       continue;
@@ -166,13 +177,11 @@ export function detectConsolidationHints(entries, db, opts = {}) {
 
     let lastSnapshotAgeDays = null;
     try {
-      const userClause = '';
-      const params = false ? [`%"${tag}"%`] : [`%"${tag}"%`];
       const recentBrief = db
         .prepare(
-          `SELECT created_at FROM vault WHERE kind = 'brief' AND tags LIKE ?${userClause} ORDER BY created_at DESC LIMIT 1`
+          `SELECT created_at FROM vault WHERE kind = 'brief' AND tags LIKE ? ORDER BY created_at DESC LIMIT 1`
         )
-        .get(...params);
+        .get(`%"${tag}"%`);
 
       if (recentBrief) {
         lastSnapshotAgeDays = Math.round(
@@ -202,7 +211,7 @@ export function detectConsolidationHints(entries, db, opts = {}) {
  * @param {object} entry - DB row with source_files JSON column
  * @returns {{ stale: boolean, stale_reason: string } | null}
  */
-function checkStaleness(entry) {
+function checkStaleness(entry: any): { stale: boolean; stale_reason: string } | null {
   if (!entry.source_files) return null;
   let sourceFiles;
   try {
@@ -323,13 +332,22 @@ export const inputSchema = {
     .describe(
       'If true, follow related_to links from result entries and include linked entries (forward links) and backlinks (entries that reference the results). Enables bidirectional graph traversal.'
     ),
+  body_limit: z
+    .number()
+    .min(0)
+    .max(10000)
+    .optional()
+    .describe(
+      'Max characters of body to return per entry (default 300). Set to 0 for no limit. Does not affect skeleton entries.'
+    ),
+  strict: z
+    .boolean()
+    .optional()
+    .describe(
+      'When true with identity_key, return a clear "not found" instead of falling through to semantic search on miss. Default: false.'
+    ),
 };
 
-/**
- * @param {object} args
- * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
- * @param {import('../types.js').ToolShared} shared
- */
 export async function handler(
   {
     query,
@@ -349,10 +367,12 @@ export async function handler(
     include_events,
     scope,
     follow_links,
-  },
-  ctx,
-  { ensureIndexed, reindexFailed }
-) {
+    body_limit,
+    strict,
+  }: Record<string, any>,
+  ctx: LocalCtx,
+  { ensureIndexed, reindexFailed }: SharedCtx
+): Promise<ToolResult> {
   const { config } = ctx;
 
   // Resolve natural-language temporal shortcuts → ISO date strings
@@ -375,7 +395,7 @@ export async function handler(
   const scopedCategory = !category && effectiveScope === 'events' ? 'event' : category;
   const shouldExcludeEvents = hasQuery && effectiveScope === 'hot' && !scopedCategory;
   // Expand buckets to bucket: prefixed tags and merge with explicit tags
-  const bucketTags = buckets?.length ? buckets.map((b) => `bucket:${b}`) : [];
+  const bucketTags = buckets?.length ? buckets.map((b: string) => `bucket:${b}`) : [];
   const effectiveTags = [...(tags ?? []), ...bucketTags];
   const hasFilters =
     kind || scopedCategory || effectiveTags.length || since || until || identity_key;
@@ -391,7 +411,7 @@ export async function handler(
   // Gap 1: Entity exact-match by identity_key
   if (identity_key) {
     if (!kindFilter) return err('identity_key requires kind to be specified', 'INVALID_INPUT');
-    const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key);
+    const match = ctx.stmts.getByIdentityKey.get(kindFilter, identity_key) as any;
     if (match) {
       const entryTags = match.tags ? JSON.parse(match.tags) : [];
       const tagStr = entryTags.length ? entryTags.join(', ') : 'none';
@@ -403,9 +423,13 @@ export async function handler(
         `## Entity Match (exact)\n`,
         `### ${match.title || '(untitled)'} [${match.kind}/${match.category}]`,
         `1.000 · ${tagStr} · ${relPath} · id: \`${match.id}\``,
-        match.body?.slice(0, 300) + (match.body?.length > 300 ? '...' : ''),
+        truncateBody(match.body, body_limit ?? 300),
       ];
       return ok(lines.join('\n'));
+    } else if (strict) {
+      return ok(
+        `## Entity Match (exact)\n\nNo entry found for identity_key: \`${identity_key}\` (kind: ${kindFilter}).\n\nUse strict: false (default) to fall through to semantic search.`
+      );
     }
     // Fall through to semantic search as fallback
   }
@@ -428,7 +452,7 @@ export async function handler(
     ? Math.min(effectiveLimit * 10, MAX_FETCH_LIMIT)
     : effectiveLimit;
 
-  let filtered;
+  let filtered: any[];
   if (hasQuery) {
     // Hybrid search mode
     const sorted = await hybridSearch(ctx, query, {
@@ -439,8 +463,8 @@ export async function handler(
       until: effectiveUntil,
       limit: fetchLimit,
       decayDays: config.eventDecayDays || 30,
-
       includeSuperseeded: include_superseded ?? false,
+      includeEphemeral: include_ephemeral ?? false,
     });
 
     // Post-filter by tags if provided, then apply requested limit
@@ -474,6 +498,9 @@ export async function handler(
       clauses.push('created_at <= ?');
       params.push(effectiveUntil);
     }
+    if (!include_ephemeral) {
+      clauses.push("tier != 'ephemeral'");
+    }
     clauses.push("(expires_at IS NULL OR expires_at > datetime('now'))");
     if (!include_superseded) {
       clauses.push('superseded_by IS NULL');
@@ -487,7 +514,7 @@ export async function handler(
         .all(...params);
     } catch (e) {
       return errWithHint(
-        e.message,
+        e instanceof Error ? e.message : String(e),
         'DB_ERROR',
         'context-vault get_context DB_ERROR. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.'
       );
@@ -496,9 +523,9 @@ export async function handler(
     // Post-filter by tags if provided, then apply requested limit
     filtered = effectiveTags.length
       ? rows
-          .filter((r) => {
+          .filter((r: any) => {
             const entryTags = r.tags ? JSON.parse(r.tags) : [];
-            return effectiveTags.some((t) => entryTags.includes(t));
+            return effectiveTags.some((t: string) => entryTags.includes(t));
           })
           .slice(0, effectiveLimit)
       : rows;
@@ -512,16 +539,11 @@ export async function handler(
   for (const r of filtered) {
     if (r.kind === 'brief') r.score = (r.score || 0) + BRIEF_SCORE_BOOST;
   }
-  filtered.sort((a, b) => b.score - a.score);
-
-  // Tier filter: exclude ephemeral entries by default (NULL tier treated as working)
-  if (!include_ephemeral) {
-    filtered = filtered.filter((r) => r.tier !== 'ephemeral');
-  }
+  filtered.sort((a: any, b: any) => b.score - a.score);
 
   // Event category filter: exclude events from semantic search by default
   if (shouldExcludeEvents) {
-    filtered = filtered.filter((r) => r.category !== 'event');
+    filtered = filtered.filter((r: any) => r.category !== 'event');
   }
 
   if (!filtered.length) {
@@ -538,18 +560,6 @@ export async function handler(
     );
   }
 
-  // Decrypt encrypted entries if ctx.decrypt is available
-  if (ctx.decrypt) {
-    for (const r of filtered) {
-      if (r.body_encrypted) {
-        const decrypted = await ctx.decrypt(r);
-        r.body = decrypted.body;
-        if (decrypted.title) r.title = decrypted.title;
-        if (decrypted.meta) r.meta = JSON.stringify(decrypted.meta);
-      }
-    }
-  }
-
   // Token-budgeted packing
   let tokensBudget = null;
   let tokensUsed = null;
@@ -625,7 +635,7 @@ export async function handler(
     if (isSkeleton) {
       lines.push(skeletonBody(r.body));
     } else {
-      lines.push(r.body?.slice(0, 300) + (r.body?.length > 300 ? '...' : ''));
+      lines.push(truncateBody(r.body, body_limit ?? 300));
     }
     lines.push('');
   }
@@ -645,10 +655,10 @@ export async function handler(
 
   // Graph traversal: follow related_to links bidirectionally
   if (follow_links) {
-    const { forward, backward } = collectLinkedEntries(ctx.db, filtered);
-    const allLinked = [...forward, ...backward];
+    const { forward, backward } = collectLinkedEntries(ctx.db, filtered as any);
+    const allLinked: any[] = [...(forward as any[]), ...(backward as any[])];
     const seen = new Set();
-    const uniqueLinked = allLinked.filter((e) => {
+    const uniqueLinked = allLinked.filter((e: any) => {
       if (seen.has(e.id)) return false;
       seen.add(e.id);
       return true;
@@ -657,7 +667,7 @@ 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) => f.id === r.id) ? '→ forward' : '← backlink';
+        const direction = forward.some((f: any) => f.id === r.id) ? '→ forward' : '← backlink';
         const entryTags = r.tags ? JSON.parse(r.tags) : [];
         const tagStr = entryTags.length ? entryTags.join(', ') : 'none';
         const relPath =
@@ -666,7 +676,7 @@ export async function handler(
             : r.file_path || 'n/a';
         lines.push(`### ${r.title || '(untitled)'} [${r.kind}/${r.category}] ${direction}`);
         lines.push(`${tagStr} · ${relPath} · id: \`${r.id}\``);
-        lines.push(r.body?.slice(0, 200) + (r.body?.length > 200 ? '...' : ''));
+        lines.push(truncateBody(r.body, body_limit ?? 300));
         lines.push('');
       }
     } else {
@@ -696,8 +706,8 @@ export async function handler(
     }
   }
 
-  const result = ok(lines.join('\n'));
-  const meta = {};
+  const result: ToolResult = ok(lines.join('\n'));
+  const meta: Record<string, unknown> = {};
   meta.scope = effectiveScope;
   if (tokensBudget != null) {
     meta.tokens_used = tokensUsed;

package/src/tools/{ingest-project.js → ingest-project.ts}

@@ -4,6 +4,7 @@ import { execSync } from 'node:child_process';
 import { join, basename } from 'node:path';
 import { captureAndIndex } from '@context-vault/core/capture';
 import { ok, err, ensureVaultExists } from '../helpers.js';
+import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 export const name = 'ingest_project';
 
@@ -19,7 +20,7 @@ export const inputSchema = {
   pillar: z.string().optional().describe('Parent pillar/domain name — creates a bucket:pillar tag'),
 };
 
-function safeRead(filePath) {
+function safeRead(filePath: string): string | null {
   try {
     return readFileSync(filePath, 'utf-8');
   } catch {
@@ -27,7 +28,7 @@ function safeRead(filePath) {
   }
 }
 
-function safeExec(cmd, cwd) {
+function safeExec(cmd: string, cwd: string): string | null {
   try {
     return execSync(cmd, {
       cwd,
@@ -39,7 +40,7 @@ function safeExec(cmd, cwd) {
   }
 }
 
-function detectTechStack(projectPath, pkgJson) {
+function detectTechStack(projectPath: string, pkgJson: any): string[] {
   const stack = [];
 
   if (
@@ -78,7 +79,7 @@ function detectTechStack(projectPath, pkgJson) {
   return [...new Set(stack)];
 }
 
-function extractReadmeDescription(projectPath) {
+function extractReadmeDescription(projectPath: string): string | null {
   const raw = safeRead(join(projectPath, 'README.md')) || safeRead(join(projectPath, 'readme.md'));
   if (!raw) return null;
   for (const line of raw.split('\n')) {
@@ -97,7 +98,15 @@ function buildProjectBody({
   lastCommit,
   projectPath,
   hasClaudeMd,
-}) {
+}: {
+  projectName: string;
+  description: string | null;
+  techStack: string[];
+  repoUrl: string | null;
+  lastCommit: string | null;
+  projectPath: string;
+  hasClaudeMd: boolean;
+}): string {
   const lines = [];
   lines.push(`## ${projectName}`);
   if (description) lines.push('', description);
@@ -110,12 +119,11 @@ function buildProjectBody({
   return lines.join('\n');
 }
 
-/**
- * @param {object} args
- * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
- * @param {import('../types.js').ToolShared} shared
- */
-export async function handler({ path: projectPath, tags, pillar }, ctx, { ensureIndexed }) {
+export async function handler(
+  { path: projectPath, tags, pillar }: Record<string, any>,
+  ctx: LocalCtx,
+  { ensureIndexed }: SharedCtx
+): Promise<ToolResult> {
   const { config } = ctx;
 
   const vaultErr = ensureVaultExists(config);

package/src/tools/{ingest-url.js → ingest-url.ts}

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { captureAndIndex } from '@context-vault/core/capture';
 import { ok, err, ensureVaultExists } from '../helpers.js';
 import { MAX_KIND_LENGTH, MAX_TAG_LENGTH, MAX_TAGS_COUNT } from '@context-vault/core/constants';
+import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 const MAX_URL_LENGTH = 2048;
 
@@ -16,12 +17,11 @@ export const inputSchema = {
   tags: z.array(z.string()).optional().describe('Tags for the entry'),
 };
 
-/**
- * @param {object} args
- * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
- * @param {import('../types.js').ToolShared} shared
- */
-export async function handler({ url: targetUrl, kind, tags }, ctx, { ensureIndexed }) {
+export async function handler(
+  { url: targetUrl, kind, tags }: Record<string, any>,
+  ctx: LocalCtx,
+  { ensureIndexed }: SharedCtx
+): Promise<ToolResult> {
   const { config } = ctx;
 
   const vaultErr = ensureVaultExists(config);
@@ -49,7 +49,7 @@ export async function handler({ url: targetUrl, kind, tags }, ctx, { ensureIndex
   await ensureIndexed();
 
   try {
-    const { ingestUrl } = await import('../../capture/ingest-url.js');
+    const { ingestUrl } = await import('@context-vault/core/ingest-url');
     const entryData = await ingestUrl(targetUrl, { kind, tags });
     const entry = await captureAndIndex(ctx, { ...entryData });
     const relPath = entry.filePath
@@ -66,6 +66,9 @@ export async function handler({ url: targetUrl, kind, tags }, ctx, { ensureIndex
     parts.push('', '_Use this id to update or delete later._');
     return ok(parts.join('\n'));
   } catch (e) {
-    return err(`Failed to ingest URL: ${e.message}`, 'INGEST_FAILED');
+    return err(
+      `Failed to ingest URL: ${e instanceof Error ? e.message : String(e)}`,
+      'INGEST_FAILED'
+    );
   }
 }

package/src/tools/{list-buckets.js → list-buckets.ts}

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ok } from '../helpers.js';
+import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 export const name = 'list_buckets';
 
@@ -15,17 +16,13 @@ export const inputSchema = {
     ),
 };
 
-/**
- * @param {object} args
- * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
- * @param {import('../types.js').ToolShared} shared
- */
-export async function handler({ include_counts = true }, ctx, { ensureIndexed, reindexFailed }) {
+export async function handler(
+  { include_counts = true }: Record<string, any>,
+  ctx: LocalCtx,
+  { ensureIndexed, reindexFailed }: SharedCtx
+): Promise<ToolResult> {
   await ensureIndexed();
 
-  const userClause = '';
-  const userParams = [];
-
   const buckets = ctx.db
     .prepare(
       `SELECT id, title, identity_key, body, tags, meta, created_at, updated_at
@@ -33,10 +30,9 @@ export async function handler({ include_counts = true }, ctx, { ensureIndexed, r
        WHERE kind = 'bucket'
          AND (expires_at IS NULL OR expires_at > datetime('now'))
          AND superseded_by IS NULL
-         ${userClause}
        ORDER BY title ASC`
     )
-    .all(...userParams);
+    .all();
 
   if (!buckets.length) {
     return ok(
@@ -52,8 +48,8 @@ export async function handler({ include_counts = true }, ctx, { ensureIndexed, r
   }
   lines.push(`## Registered Buckets (${buckets.length})\n`);
 
-  for (const b of buckets) {
-    let meta = {};
+  for (const b of buckets as any[]) {
+    let meta: Record<string, any> = {};
     if (b.meta) {
       try {
         meta = typeof b.meta === 'string' ? JSON.parse(b.meta) : b.meta;
@@ -64,12 +60,12 @@ export async function handler({ include_counts = true }, ctx, { ensureIndexed, r
 
     const bucketTags = b.tags ? JSON.parse(b.tags) : [];
     const name = b.identity_key ? b.identity_key.replace(/^bucket:/, '') : b.title || b.id;
-    const parent = meta.parent || null;
+    const parent: string | null = meta.parent || null;
 
     let entryCount = null;
     if (include_counts && b.identity_key) {
       const countUserClause = '';
-      const countParams = [];
+      const countParams: any[] = [];
       const row = ctx.db
         .prepare(
           `SELECT COUNT(*) as c FROM vault

package/src/tools/{list-context.js → list-context.ts}

@@ -3,6 +3,7 @@ import { normalizeKind } from '@context-vault/core/files';
 import { categoryFor } from '@context-vault/core/categories';
 import { ok, err, errWithHint } from '../helpers.js';
 import { resolveTemporalParams } from '../temporal.js';
+import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 export const name = 'list_context';
 
@@ -19,16 +20,11 @@ export const inputSchema = {
   offset: z.number().optional().describe('Skip first N results for pagination'),
 };
 
-/**
- * @param {object} args
- * @param {import('../types.js').BaseCtx & Partial<import('../types.js').HostedCtxExtensions>} ctx
- * @param {import('../types.js').ToolShared} shared
- */
 export async function handler(
-  { kind, category, tags, since, until, limit, offset },
-  ctx,
-  { ensureIndexed, reindexFailed }
-) {
+  { kind, category, tags, since, until, limit, offset }: Record<string, any>,
+  ctx: LocalCtx,
+  { ensureIndexed, reindexFailed }: SharedCtx
+): Promise<ToolResult> {
   const { config } = ctx;
 
   await ensureIndexed();
@@ -76,19 +72,21 @@ export async function handler(
 
   const countParams = [...params];
   let total;
-  let rows;
+  let rows: any[];
   try {
-    total = ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...countParams).c;
+    total =
+      (ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...countParams) as any)?.c ??
+      0;
 
     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 ?`
       )
-      .all(...params);
+      .all(...params) as any[];
   } catch (e) {
     return errWithHint(
-      e.message,
+      e instanceof Error ? e.message : String(e),
       'DB_ERROR',
       'context-vault list_context DB_ERROR. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.'
     );
@@ -97,9 +95,9 @@ export async function handler(
   // Post-filter by tags if provided, then apply requested limit
   const filtered = tags?.length
     ? rows
-        .filter((r) => {
+        .filter((r: any) => {
           const entryTags = r.tags ? JSON.parse(r.tags) : [];
-          return tags.some((t) => entryTags.includes(t));
+          return tags.some((t: string) => entryTags.includes(t));
         })
         .slice(0, effectiveLimit)
     : rows;