context-vault 2.17.0 → 3.0.1

package/{node_modules/@context-vault/core/src/server/tools.js → src/register-tools.js}

@@ -1,14 +1,20 @@
-import { reindex } from "../index/index.js";
-import { captureAndIndex } from "../capture/index.js";
+import { reindex } from "@context-vault/core/index";
+import { captureAndIndex } from "@context-vault/core/capture";
 import { err } from "./helpers.js";
-import { sendTelemetryEvent } from "../core/telemetry.js";
-import pkg from "../../package.json" with { type: "json" };
+import { sendTelemetryEvent } from "./telemetry.js";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"),
+);
 
 import * as getContext from "./tools/get-context.js";
 import * as saveContext from "./tools/save-context.js";
 import * as listContext from "./tools/list-context.js";
 import * as deleteContext from "./tools/delete-context.js";
-import * as submitFeedback from "./tools/submit-feedback.js";
 import * as ingestUrl from "./tools/ingest-url.js";
 import * as contextStatus from "./tools/context-status.js";
 import * as clearContext from "./tools/clear-context.js";
@@ -22,7 +28,6 @@ const toolModules = [
   saveContext,
   listContext,
   deleteContext,
-  submitFeedback,
   ingestUrl,
   ingestProject,
   contextStatus,
@@ -35,8 +40,6 @@ const toolModules = [
 const TOOL_TIMEOUT_MS = 60_000;
 
 export function registerTools(server, ctx) {
-  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
-
   function tracked(handler, toolName) {
     return async (...args) => {
       if (ctx.activeOps) ctx.activeOps.count++;
@@ -57,8 +60,6 @@ export function registerTools(server, ctx) {
         return result;
       } catch (e) {
         if (e.message === "TOOL_TIMEOUT") {
-          // Suppress any late rejection from the still-running handler to
-          // prevent unhandled promise rejection warnings in the host process.
           handlerPromise?.catch(() => {});
           if (ctx.toolStats) {
             ctx.toolStats.errors++;
@@ -107,7 +108,7 @@ export function registerTools(server, ctx) {
               auto: true,
             },
           });
-        } catch {} // never block on feedback capture
+        } catch {}
         throw e;
       } finally {
         clearTimeout(timer);
@@ -116,8 +117,7 @@ export function registerTools(server, ctx) {
     };
   }
 
-  // In hosted mode, skip reindex — DB is always in sync via writeEntry→indexEntry
-  let reindexDone = userId !== undefined ? true : false;
+  let reindexDone = false;
   let reindexPromise = null;
   let reindexAttempts = 0;
   let reindexFailed = false;
@@ -126,7 +126,6 @@ export function registerTools(server, ctx) {
   async function ensureIndexed() {
     if (reindexDone) return;
     if (reindexPromise) return reindexPromise;
-    // Assign promise synchronously to prevent concurrent calls from both entering reindex()
     const promise = reindex(ctx, { fullSync: true })
       .then((stats) => {
         reindexDone = true;
@@ -149,7 +148,7 @@ export function registerTools(server, ctx) {
           reindexDone = true;
           reindexFailed = true;
         } else {
-          reindexPromise = null; // Allow retry on next tool call
+          reindexPromise = null;
         }
       });
     reindexPromise = promise;

package/src/{server/index.js → server.js}

@@ -18,24 +18,19 @@ const pkg = JSON.parse(
   readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"),
 );
 
-import { resolveConfig } from "@context-vault/core/core/config";
-import { appendErrorLog } from "@context-vault/core/core/error-log";
-import {
-  sendTelemetryEvent,
-  maybeShowTelemetryNotice,
-} from "@context-vault/core/core/telemetry";
-import { embed } from "@context-vault/core/index/embed";
+import { resolveConfig } from "@context-vault/core/config";
+import { appendErrorLog } from "./error-log.js";
+import { sendTelemetryEvent, maybeShowTelemetryNotice } from "./telemetry.js";
+import { embed } from "@context-vault/core/embed";
 import {
   initDatabase,
   NativeModuleError,
   prepareStatements,
   insertVec,
   deleteVec,
-} from "@context-vault/core/index/db";
-import { registerTools } from "@context-vault/core/server/tools";
-import { pruneExpired } from "@context-vault/core/index/index";
-
-// ─── Phased Startup ─────────────────────────────────────────────────────────
+} from "@context-vault/core/db";
+import { registerTools } from "./register-tools.js";
+import { pruneExpired } from "@context-vault/core/index";
 
 async function main() {
   let phase = "CONFIG";
@@ -43,16 +38,13 @@ async function main() {
   let config;
 
   try {
-    // ── Phase: CONFIG ────────────────────────────────────────────────────────
     config = resolveConfig();
 
-    // ── Phase: DIRS ──────────────────────────────────────────────────────────
     phase = "DIRS";
     mkdirSync(config.dataDir, { recursive: true });
     mkdirSync(config.vaultDir, { recursive: true });
     maybeShowTelemetryNotice(config.dataDir);
 
-    // Verify vault directory is writable (catch permission issues early)
     try {
       const probe = join(config.vaultDir, ".write-probe");
       writeFileSync(probe, "");
@@ -68,7 +60,6 @@ async function main() {
       process.exit(1);
     }
 
-    // Write .context-mcp marker (non-fatal)
     try {
       const markerPath = join(config.vaultDir, ".context-mcp");
       const markerData = existsSync(markerPath)
@@ -93,7 +84,6 @@ async function main() {
 
     config.vaultDirExists = existsSync(config.vaultDir);
 
-    // Startup diagnostics
     console.error(`[context-vault] Vault: ${config.vaultDir}`);
     console.error(`[context-vault] Database: ${config.dbPath}`);
     console.error(`[context-vault] Dev dir: ${config.devDir}`);
@@ -101,7 +91,6 @@ async function main() {
       console.error(`[context-vault] WARNING: Vault directory not found!`);
     }
 
-    // ── Phase: DB ────────────────────────────────────────────────────────────
     phase = "DB";
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
@@ -117,7 +106,6 @@ async function main() {
       toolStats: { ok: 0, errors: 0, lastError: null },
     };
 
-    // ── Phase: PRUNE ─────────────────────────────────────────────────────────
     try {
       const pruned = await pruneExpired(ctx);
       if (pruned > 0) {
@@ -131,16 +119,12 @@ async function main() {
       );
     }
 
-    // ── Phase: SERVER ────────────────────────────────────────────────────────
     phase = "SERVER";
     const server = new McpServer(
       { name: "context-vault", version: pkg.version },
       { capabilities: { tools: {} } },
     );
 
-    // Hot-reload config.json on every tool call (Option C from #144).
-    // resolveConfig() re-reads the small file each time — negligible I/O
-    // compared to DB queries and embedding operations that follow.
     let lastVaultDir = config.vaultDir;
     Object.defineProperty(ctx, "config", {
       get() {
@@ -159,7 +143,6 @@ async function main() {
 
     registerTools(server, ctx);
 
-    // ── Graceful Shutdown ────────────────────────────────────────────────────
     function closeDb() {
       try {
         if (db.inTransaction) {
@@ -188,7 +171,6 @@ async function main() {
             closeDb();
           }
         }, 100);
-        // Force shutdown after 5 seconds even if ops are still running
         setTimeout(() => {
           clearInterval(check);
           console.error(
@@ -203,12 +185,10 @@ async function main() {
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
 
-    // ── Phase: CONNECTED ─────────────────────────────────────────────────────
     phase = "CONNECTED";
     const transport = new StdioServerTransport();
     await server.connect(transport);
 
-    // ── Non-blocking Update Check ────────────────────────────────────────────
     setTimeout(() => {
       import("node:child_process")
         .then(({ execSync }) => {
@@ -250,7 +230,6 @@ async function main() {
     });
 
     if (err instanceof NativeModuleError) {
-      // Boxed diagnostic for native module mismatch
       console.error("");
       console.error(
         "╔══════════════════════════════════════════════════════════════╗",
@@ -268,7 +247,7 @@ async function main() {
       console.error(`  Node.js version: ${process.version}`);
       console.error(`  Error log:       ${join(dataDir, "error.log")}`);
       console.error("");
-      process.exit(78); // EX_CONFIG
+      process.exit(78);
     }
 
     console.error(
@@ -284,12 +263,6 @@ async function main() {
   }
 }
 
-// ─── Top-level Safety Net ────────────────────────────────────────────────────
-// Catch any errors that escape the main() try/catch (e.g. thrown in MCP
-// transport callbacks or in unrelated async chains).  Claude Code surfaces
-// stderr when a server exits unexpectedly, so every message written here will
-// be visible to the user.
-
 process.on("uncaughtException", (err) => {
   const dataDir = join(homedir(), ".context-mcp");
   const logEntry = {

package/src/status.js

@@ -0,0 +1,235 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { walkDir } from "@context-vault/core/files";
+import { isEmbedAvailable } from "@context-vault/core/embed";
+import { KIND_STALENESS_DAYS } from "@context-vault/core/categories";
+
+function countArchivedEntries(vaultDir) {
+  const archRoot = join(vaultDir, "_archive");
+  if (!existsSync(archRoot)) return 0;
+  try {
+    return walkDir(archRoot).length;
+  } catch {
+    return 0;
+  }
+}
+
+export function gatherVaultStatus(ctx, opts = {}) {
+  const { db, config } = ctx;
+  const errors = [];
+
+  let fileCount = 0;
+  const subdirs = [];
+  try {
+    if (existsSync(config.vaultDir)) {
+      for (const d of readdirSync(config.vaultDir, { withFileTypes: true })) {
+        if (d.isDirectory()) {
+          const dir = join(config.vaultDir, d.name);
+          const count = walkDir(dir).length;
+          fileCount += count;
+          if (count > 0) subdirs.push({ name: d.name, count });
+        }
+      }
+    }
+  } catch (e) {
+    errors.push(`File scan failed: ${e.message}`);
+  }
+
+  let kindCounts = [];
+  try {
+    kindCounts = db
+      .prepare(`SELECT kind, COUNT(*) as c FROM vault GROUP BY kind`)
+      .all();
+  } catch (e) {
+    errors.push(`Kind count query failed: ${e.message}`);
+  }
+
+  let categoryCounts = [];
+  try {
+    categoryCounts = db
+      .prepare(`SELECT category, COUNT(*) as c FROM vault GROUP BY category`)
+      .all();
+  } catch (e) {
+    errors.push(`Category count query failed: ${e.message}`);
+  }
+
+  let dbSize = "n/a";
+  let dbSizeBytes = 0;
+  try {
+    if (existsSync(config.dbPath)) {
+      dbSizeBytes = statSync(config.dbPath).size;
+      dbSize =
+        dbSizeBytes > 1024 * 1024
+          ? `${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB`
+          : `${(dbSizeBytes / 1024).toFixed(1)}KB`;
+    }
+  } catch (e) {
+    errors.push(`DB size check failed: ${e.message}`);
+  }
+
+  let stalePaths = false;
+  let staleCount = 0;
+  try {
+    const result = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE file_path NOT LIKE ? || '%'`)
+      .get(config.vaultDir);
+    staleCount = result.c;
+    stalePaths = staleCount > 0;
+  } catch (e) {
+    errors.push(`Stale path check failed: ${e.message}`);
+  }
+
+  let expiredCount = 0;
+  try {
+    expiredCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE expires_at IS NOT NULL AND expires_at <= datetime('now')`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Expired count failed: ${e.message}`);
+  }
+
+  let eventCount = 0;
+  try {
+    eventCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE category = 'event'`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Event count failed: ${e.message}`);
+  }
+
+  let eventsWithoutTtlCount = 0;
+  try {
+    eventsWithoutTtlCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE category = 'event' AND expires_at IS NULL`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Events without TTL count failed: ${e.message}`);
+  }
+
+  let embeddingStatus = null;
+  try {
+    const total = db.prepare(`SELECT COUNT(*) as c FROM vault`).get().c;
+    const indexed = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE rowid IN (SELECT rowid FROM vault_vec)`)
+      .get().c;
+    embeddingStatus = { indexed, total, missing: total - indexed };
+  } catch (e) {
+    errors.push(`Embedding status check failed: ${e.message}`);
+  }
+
+  const embedModelAvailable = isEmbedAvailable();
+
+  let autoCapturedFeedbackCount = 0;
+  try {
+    autoCapturedFeedbackCount = db
+      .prepare(`SELECT COUNT(*) as c FROM vault WHERE kind = 'feedback' AND tags LIKE '%"auto-captured"%'`)
+      .get().c;
+  } catch (e) {
+    errors.push(`Auto-captured feedback count failed: ${e.message}`);
+  }
+
+  let archivedCount = 0;
+  try {
+    archivedCount = countArchivedEntries(config.vaultDir);
+  } catch (e) {
+    errors.push(`Archived count failed: ${e.message}`);
+  }
+
+  let staleKnowledge = [];
+  try {
+    const stalenessKinds = Object.entries(KIND_STALENESS_DAYS);
+    if (stalenessKinds.length > 0) {
+      const kindClauses = stalenessKinds
+        .map(
+          ([kind, days]) =>
+            `(kind = '${kind}' AND COALESCE(updated_at, created_at) <= datetime('now', '-${days} days'))`,
+        )
+        .join(" OR ");
+      staleKnowledge = db
+        .prepare(
+          `SELECT kind, title, COALESCE(updated_at, created_at) as last_updated FROM vault WHERE category = 'knowledge' AND (${kindClauses}) AND (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY last_updated ASC LIMIT 10`,
+        )
+        .all();
+    }
+  } catch (e) {
+    errors.push(`Stale knowledge check failed: ${e.message}`);
+  }
+
+  return {
+    fileCount,
+    subdirs,
+    kindCounts,
+    categoryCounts,
+    dbSize,
+    dbSizeBytes,
+    stalePaths,
+    staleCount,
+    expiredCount,
+    eventCount,
+    eventsWithoutTtlCount,
+    embeddingStatus,
+    embedModelAvailable,
+    autoCapturedFeedbackCount,
+    archivedCount,
+    staleKnowledge,
+    resolvedFrom: config.resolvedFrom,
+    errors,
+  };
+}
+
+export function computeGrowthWarnings(status, thresholds) {
+  if (!thresholds)
+    return { warnings: [], hasCritical: false, hasWarnings: false, actions: [], kindBreakdown: [] };
+
+  const t = thresholds;
+  const warnings = [];
+  const actions = [];
+
+  const total = status.embeddingStatus?.total ?? 0;
+  const { eventCount = 0, eventsWithoutTtlCount = 0, expiredCount = 0, dbSizeBytes = 0 } = status;
+
+  let totalExceeded = false;
+
+  if (t.totalEntries?.critical != null && total >= t.totalEntries.critical) {
+    totalExceeded = true;
+    warnings.push({ level: "critical", message: `Total entries: ${total.toLocaleString()} (exceeds critical limit of ${t.totalEntries.critical.toLocaleString()})` });
+  } else if (t.totalEntries?.warn != null && total >= t.totalEntries.warn) {
+    totalExceeded = true;
+    warnings.push({ level: "warn", message: `Total entries: ${total.toLocaleString()} (exceeds recommended ${t.totalEntries.warn.toLocaleString()})` });
+  }
+
+  if (t.eventEntries?.critical != null && eventCount >= t.eventEntries.critical) {
+    warnings.push({ level: "critical", message: `Event entries: ${eventCount.toLocaleString()} (exceeds critical limit of ${t.eventEntries.critical.toLocaleString()})` });
+  } else if (t.eventEntries?.warn != null && eventCount >= t.eventEntries.warn) {
+    const ttlNote = eventsWithoutTtlCount > 0 ? ` (${eventsWithoutTtlCount.toLocaleString()} without TTL)` : "";
+    warnings.push({ level: "warn", message: `Event entries: ${eventCount.toLocaleString()}${ttlNote} (exceeds recommended ${t.eventEntries.warn.toLocaleString()})` });
+  }
+
+  if (t.vaultSizeBytes?.critical != null && dbSizeBytes >= t.vaultSizeBytes.critical) {
+    warnings.push({ level: "critical", message: `Database size: ${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB (exceeds critical limit of ${(t.vaultSizeBytes.critical / 1024 / 1024).toFixed(0)}MB)` });
+  } else if (t.vaultSizeBytes?.warn != null && dbSizeBytes >= t.vaultSizeBytes.warn) {
+    warnings.push({ level: "warn", message: `Database size: ${(dbSizeBytes / 1024 / 1024).toFixed(1)}MB (exceeds recommended ${(t.vaultSizeBytes.warn / 1024 / 1024).toFixed(0)}MB)` });
+  }
+
+  if (t.eventsWithoutTtl?.warn != null && eventsWithoutTtlCount >= t.eventsWithoutTtl.warn) {
+    warnings.push({ level: "warn", message: `Event entries without expires_at: ${eventsWithoutTtlCount.toLocaleString()} (exceeds recommended ${t.eventsWithoutTtl.warn.toLocaleString()})` });
+  }
+
+  const hasCritical = warnings.some((w) => w.level === "critical");
+
+  if (expiredCount > 0) {
+    actions.push(`Run \`context-vault prune\` to remove ${expiredCount} expired event entr${expiredCount === 1 ? "y" : "ies"}`);
+  }
+  if (eventsWithoutTtlCount > 0 && (eventCount >= (t.eventEntries?.warn ?? Infinity) || eventsWithoutTtlCount >= (t.eventsWithoutTtl?.warn ?? Infinity))) {
+    actions.push("Add `expires_at` to event/session entries to enable automatic cleanup");
+  }
+  if (total >= (t.totalEntries?.warn ?? Infinity)) {
+    actions.push("Run `context-vault archive` to move old ephemeral/event entries to _archive/");
+  }
+
+  const kindBreakdown = totalExceeded && status.kindCounts?.length
+    ? [...status.kindCounts].sort((a, b) => b.c - a.c).map(({ kind, c }) => ({ kind, count: c, pct: Math.round((c / total) * 100) }))
+    : [];
+
+  return { warnings, hasCritical, hasWarnings: warnings.length > 0, actions, kindBreakdown };
+}

package/{node_modules/@context-vault/core/src/core → src}/telemetry.js

@@ -1,23 +1,22 @@
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { API_URL, MARKETING_URL, GITHUB_ISSUES_URL } from "../constants.js";
+import { API_URL, MARKETING_URL, GITHUB_ISSUES_URL } from "@context-vault/core/constants";
+import type { VaultConfig } from "@context-vault/core/types";
 
 const TELEMETRY_ENDPOINT = `${API_URL}/telemetry`;
 const NOTICE_MARKER = ".telemetry-notice-shown";
 const FEEDBACK_PROMPT_MARKER = ".feedback-prompt-shown";
 
-export function isTelemetryEnabled(config) {
+export function isTelemetryEnabled(config: VaultConfig | undefined): boolean {
   const envVal = process.env.CONTEXT_VAULT_TELEMETRY;
   if (envVal !== undefined) return envVal === "1" || envVal === "true";
   return config?.telemetry === true;
 }
 
-/**
- * Fire-and-forget telemetry event. Never throws, never blocks.
- * Payload contains only: event, code, tool, cv_version, node_version, platform, arch, ts.
- * No message text, stack traces, vault content, file paths, or user identifiers.
- */
-export function sendTelemetryEvent(config, payload) {
+export function sendTelemetryEvent(
+  config: VaultConfig | undefined,
+  payload: { event: string; code?: string | null; tool?: string | null; cv_version: string },
+): void {
   if (!isTelemetryEnabled(config)) return;
 
   const event = {
@@ -39,11 +38,7 @@ export function sendTelemetryEvent(config, payload) {
   }).catch(() => {});
 }
 
-/**
- * Print the one-time telemetry notice to stderr.
- * Uses a marker file in dataDir to ensure it's only shown once.
- */
-export function maybeShowTelemetryNotice(dataDir) {
+export function maybeShowTelemetryNotice(dataDir: string): void {
   try {
     const markerPath = join(dataDir, NOTICE_MARKER);
     if (existsSync(markerPath)) return;
@@ -65,12 +60,7 @@ export function maybeShowTelemetryNotice(dataDir) {
   }
 }
 
-/**
- * Print a one-time feedback prompt after the user's first successful save.
- * Uses a marker file in dataDir to ensure it's only shown once.
- * Never throws, never blocks.
- */
-export function maybeShowFeedbackPrompt(dataDir) {
+export function maybeShowFeedbackPrompt(dataDir: string): void {
   try {
     const markerPath = join(dataDir, FEEDBACK_PROMPT_MARKER);
     if (existsSync(markerPath)) return;

package/src/temporal.js

@@ -0,0 +1,97 @@
+const SHORTCUT_RE = /^last[_ ](\d+)[_ ](day|days|week|weeks|month|months)$/i;
+
+function startOfToday(now: Date): Date {
+  const d = new Date(now);
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+}
+
+export function resolveTemporalShortcut(
+  role: "since" | "until",
+  value: string,
+  now: Date = new Date(),
+): string {
+  if (!value || typeof value !== "string") return value;
+  const trimmed = value.trim().toLowerCase().replace(/\s+/g, "_");
+
+  if (trimmed === "today") {
+    const start = startOfToday(now);
+    if (role === "until") {
+      const end = new Date(start);
+      end.setUTCDate(end.getUTCDate() + 1);
+      return end.toISOString();
+    }
+    return start.toISOString();
+  }
+
+  if (trimmed === "yesterday") {
+    const todayStart = startOfToday(now);
+    const yesterdayStart = new Date(todayStart);
+    yesterdayStart.setUTCDate(yesterdayStart.getUTCDate() - 1);
+    if (role === "since") return yesterdayStart.toISOString();
+    return todayStart.toISOString();
+  }
+
+  if (trimmed === "this_week") {
+    const todayStart = startOfToday(now);
+    const dayOfWeek = todayStart.getUTCDay();
+    const daysFromMonday = (dayOfWeek + 6) % 7;
+    const monday = new Date(todayStart);
+    monday.setUTCDate(monday.getUTCDate() - daysFromMonday);
+    if (role === "since") return monday.toISOString();
+    const endOfToday = new Date(todayStart);
+    endOfToday.setUTCDate(endOfToday.getUTCDate() + 1);
+    return endOfToday.toISOString();
+  }
+
+  if (trimmed === "this_month") {
+    const d = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+    if (role === "since") return d.toISOString();
+    const endOfMonth = new Date(
+      Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1),
+    );
+    return endOfMonth.toISOString();
+  }
+
+  const m = SHORTCUT_RE.exec(trimmed);
+  if (m) {
+    const n = parseInt(m[1], 10);
+    const unit = m[2].replace(/s$/, "");
+    let ms: number;
+    if (unit === "day") ms = n * 86400000;
+    else if (unit === "week") ms = n * 7 * 86400000;
+    else ms = n * 30 * 86400000;
+    const target = new Date(now.getTime() - ms);
+    target.setUTCHours(0, 0, 0, 0);
+    return target.toISOString();
+  }
+
+  return value;
+}
+
+export function resolveTemporalParams(
+  params: { since?: string; until?: string },
+  now: Date = new Date(),
+): { since: string | undefined; until: string | undefined } {
+  let { since, until } = params;
+
+  if (
+    since?.trim().toLowerCase() === "yesterday" &&
+    (until === undefined || until === null)
+  ) {
+    since = resolveTemporalShortcut("since", since, now);
+    until = resolveTemporalShortcut("until", "yesterday", now);
+    return { since, until };
+  }
+
+  return {
+    since:
+      since !== undefined
+        ? resolveTemporalShortcut("since", since, now)
+        : since,
+    until:
+      until !== undefined
+        ? resolveTemporalShortcut("until", until, now)
+        : until,
+  };
+}

package/{node_modules/@context-vault/core/src/server → src}/tools/context-status.js

@@ -1,5 +1,5 @@
-import { gatherVaultStatus, computeGrowthWarnings } from "../../core/status.js";
-import { errorLogPath, errorLogCount } from "../../core/error-log.js";
+import { gatherVaultStatus, computeGrowthWarnings } from "../status.js";
+import { errorLogPath, errorLogCount } from "../error-log.js";
 import { ok } from "../helpers.js";
 
 function relativeTime(ts) {
@@ -24,9 +24,8 @@ export const inputSchema = {};
  */
 export function handler(_args, ctx) {
   const { config } = ctx;
-  const userId = ctx.userId !== undefined ? ctx.userId : undefined;
 
-  const status = gatherVaultStatus(ctx, { userId });
+  const status = gatherVaultStatus(ctx);
 
   const hasIssues = status.stalePaths || status.embeddingStatus?.missing > 0;
   const healthIcon = hasIssues ? "⚠" : "✓";