@wei840222/qmd 2026.9.28 → 2026.9.30

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+### Changed
+
+- Dependency upgrades and runtime engine modernization: Updated Node.js engine target to `>=24.21.0` (LTS Krypton) and packageManager to `pnpm@12.6.0`. Upgraded dependencies and toolchain including `node-llama-cpp` to `3.22.1`, `zod` to `4.6.5`, `@modelcontextprotocol/server` to `2.1.0`, `picomatch` to `4.0.7`, `yaml` to `2.9.1`, `tsx` to `4.23.15`, `oxlint` to `1.85.0`, `vitest` to `4.1.11` (patching security advisory GHSA-82fw-gwwq-j7x9), and refreshed patch/minor dependency overrides.
+
 ### Fixed
 
 - Metadata extraction error retry: `isDocumentMetadataCurrent` now requires an error-free extraction, allowing `qmd update` to automatically re-attempt extraction on documents that previously failed without requiring manual edits.
@@ -10,6 +14,7 @@
 
 ### Added
 
+- In-flight Singleflight Deduplication & In-Memory LRU Cache: Added granular in-memory `Map<string, Promise<T>>` query-level singleflight deduplication (`inflightExpansions` and `inflightEmbeddings`) and `LRUCache` fallbacks (`memoryLlmCache` and `memoryEmbeddingCache`, powered by `lru-cache`) in `expandQuery` and `embedQueriesForStore`. Features configurable TTL (`2 hours`), item bounds (1,000 for LLM responses, 2,000 for embeddings), and memory size bounds (50 MB for LLM text, 64 MB for float64 embedding vectors) with automatic byte size calculation. In `readOnly: true` environments (such as MCP stdio/HTTP servers) where SQLite write is disabled, query expansions and embeddings gracefully cache in memory. Concurrent requests seamlessly share in-flight promises across identical or partially overlapping query batches, and subsequent queries hit the memory cache, eliminating redundant remote LLM/Jev/embedding API calls and network latency.
 - TypeSafe Jev provider (`src/remote-jev.ts`) supporting System One-based candidate reranking via Noul judgments and query expansion intent classification via Choice and Noul gating. Passes query expansion context to Jev state for contextual intent classification.
 - Refactored `HybridLLM` into `Hybrid` (`src/hybrid.ts`) supporting 3-way provider fallback: `RemoteJev` → `RemoteLLM` → `LlamaCpp`.
 - Added `models.jev_api_key`, `models.jev_api_model`, and `models.jev_base_url` configuration options with `TYPESAFE_API_KEY`, `TYPESAFE_DEFAULT_MODEL`, and `TYPESAFE_BASE_URL` environment variable fallbacks.
@@ -18,7 +23,7 @@
 - Document file path and title metadata in candidate reranking: candidate documents for chat-based and remote rerankers now retain document file paths and titles, enabling rerankers to evaluate provenance and temporal references.
 - Relative temporal resolution in query expansion: `expandQuery` prompts now instruct models to calculate exact ISO dates from relative time expressions (e.g. "yesterday", "昨天", "today", "last week") against current local time for lexical and vector search.
 - Added file, title, and current local time to TypeSafe Jev candidate reranking and intent classification states, with temporal constraint guidance.
-- Search intent playbook and guidance for query expansion: Added `JEV_STRATEGY_PLAYBOOK` mapping Jev intent classifications (`code_search`, `concept_search`, `factual_lookup`, `broad_exploration`) to concrete lexical and vector search guidance passed to downstream expansion LLMs in dedicated `<search_intent>` XML blocks, keeping untrusted context separate.
+- Search intent playbook and guidance for query expansion: Added `JEV_STRATEGY_PLAYBOOK` mapping Jev intent classifications (`troubleshooting`, `how_to_guide`, `code_search`, `concept_search`, `factual_lookup`, `broad_exploration`) to concrete lexical and vector search guidance passed to downstream expansion LLMs in dedicated `<search_intent>` XML blocks, keeping untrusted context separate.
 
 ## [2026.9.25] - 2026-09-26
 

package/dist/cli/build-info.json

@@ -1,4 +1,4 @@
 {
-  "commit": "65f6a34",
-  "builtAt": "2026-09-27T15:15:31.166Z"
+  "commit": "6ac6043",
+  "builtAt": "2026-09-29T05:54:42.265Z"
 }

package/dist/remote-jev.js

@@ -3,6 +3,18 @@ import { getFormattedLocalTime } from "./remote-llm.js";
 export const DEFAULT_JEV_TIMEOUT_MS = 30000;
 export const DEFAULT_JEV_RERANK_BATCH_SIZE = 40;
 export const JEV_STRATEGY_PLAYBOOK = {
+    troubleshooting: {
+        label: "Troubleshooting & Bug Fix",
+        objective: "Diagnosing errors, exceptions, stack traces, failure modes, or broken states.",
+        lexGuidance: "Prioritize exact error codes, exception class names, HTTP statuses, and failed syscall/function identifiers. Exclude generic noise like 'why', 'error', 'issue'.",
+        vecGuidance: "Formulate concrete diagnostic or remediation questions (e.g., 'how to resolve <error> caused by <reason>').",
+    },
+    how_to_guide: {
+        label: "How-To & Procedural Guide",
+        objective: "Looking for step-by-step setup guides, workflows, recipes, installation, or migration steps.",
+        lexGuidance: "Include tool/command names, CLI flags, configuration filenames, and workflow action verbs without extra filler words.",
+        vecGuidance: "Formulate procedural task questions (e.g., 'step-by-step guide to configure or implement <task>').",
+    },
     code_search: {
         label: "Code Search",
         objective: "Looking for specific code, functions, APIs, syntax, or implementations.",
@@ -74,8 +86,10 @@ export class RemoteJev {
             model: this.model,
             questions: {
                 strategy: choice("What type of search is the user performing given the query and optional context?", {
+                    troubleshooting: "Diagnosing errors, exceptions, stack traces, or broken behavior",
+                    how_to_guide: "Step-by-step instructions, installation, configuration, or migration workflows",
                     code_search: "Looking for specific code, functions, APIs, or implementations",
-                    concept_search: "Looking for explanations, concepts, or documentation",
+                    concept_search: "Looking for explanations, concepts, architecture, or documentation",
                     factual_lookup: "Looking for specific facts, configurations, or settings",
                     broad_exploration: "Exploring a topic broadly without a specific target",
                 }),

package/dist/store.d.ts

@@ -18,6 +18,16 @@ import type { LLM } from "./llm.js";
 import { LlamaCpp, formatQueryForEmbedding, formatDocForEmbedding, type ILLMSession } from "./llm.js";
 import type { NamedCollection, Collection, CollectionConfig } from "./collections.js";
 import type { IndexDiagnostics } from "./diagnostics.js";
+import { LRUCache } from "lru-cache";
+export { LRUCache, LRUCache as LruCache } from "lru-cache";
+export declare const DEFAULT_MEMORY_CACHE_TTL_MS: number;
+export declare const DEFAULT_MEMORY_LLM_CACHE_MAX_ITEMS = 1000;
+export declare const DEFAULT_MEMORY_LLM_CACHE_MAX_BYTES: number;
+export declare const DEFAULT_MEMORY_EMBED_CACHE_MAX_ITEMS = 2000;
+export declare const DEFAULT_MEMORY_EMBED_CACHE_MAX_BYTES: number;
+export declare const memoryLlmCache: LRUCache<string, string, unknown>;
+export declare const memoryEmbeddingCache: LRUCache<string, number[], unknown>;
+export declare function resetInflightState(): void;
 import { type DocumentMetadata } from "./metadata.js";
 import { type MetadataFilter } from "./metadata-filter.js";
 export declare const DEFAULT_EMBED_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
@@ -48,6 +58,10 @@ export declare const CHUNK_WINDOW_TOKENS = 200;
 export declare const CHUNK_WINDOW_CHARS: number;
 export declare function canonicalEmbeddingBuildMaterial(providerIdentity: string, strategy: EmbedOptions["chunkStrategy"]): string;
 export declare function getEmbeddingFingerprint(model?: string): string;
+export declare function embedQueriesForStore(store: Store, queries: string[]): Promise<{
+    model: string;
+    embeddings: number[][];
+}>;
 /**
  * A potential break point in the document with a base score indicating quality.
  */
@@ -655,10 +669,21 @@ export type CacheKeyBody = {
 export declare function getCacheKey(url: string, body: CacheKeyBody): string;
 export declare function getCachedResult(db: Database, cacheKey: string): string | null;
 export declare function setCachedResult(db: Database, cacheKey: string, result: string): void;
+/**
+ * Clear cached LLM API responses and query embeddings.
+ *
+ * Note: memoryLlmCache, memoryEmbeddingCache, and in-flight deduplication maps
+ * are process-level singletons shared across collections/stores to maximize
+ * deduplication when different collections are queried concurrently with the
+ * same input. Calling clearCache() here flushes this process-wide in-memory
+ * cache as well.
+ */
 export declare function clearCache(db: Database): void;
 /**
  * Delete cached LLM API responses.
  * Returns the number of cached responses deleted.
+ *
+ * Note: Also flushes the process-wide memoryLlmCache.
  */
 export declare function deleteLLMCache(db: Database): number;
 /**

package/dist/store.js

@@ -17,6 +17,7 @@ import { abandonEmbeddingBuild, beginEmbeddingBuild, completeEmbeddingBuild, cre
 import picomatch from "picomatch";
 import { createHash, randomUUID } from "crypto";
 import { readFileSync, realpathSync, statSync, mkdirSync } from "node:fs";
+import { Buffer } from "node:buffer";
 // Note: node:path resolve is not imported — we export our own cross-platform resolve()
 import fastGlob from "fast-glob";
 import { qmdHomedir } from "./paths.js";
@@ -24,7 +25,38 @@ import { cleanupExpiredCjkIndexBuilds, getCjkAnalyzerFingerprint, getCjkLexicalI
 import { analyzeCjkSync, containsCjk } from "./search/cjk-analyzer.js";
 import { ExpansionPolicyError, parseExpansionDirective, resolveExpansionPolicy, containsRelativeTemporalTerms, } from "./search/query-expansion.js";
 import { LlamaCpp, getDefaultLlamaCpp, formatQueryForEmbedding, formatDocForEmbedding, withLLMSessionForLlm, DEFAULT_EMBED_MODEL_URI, DEFAULT_RERANK_MODEL_URI, DEFAULT_GENERATE_MODEL_URI, } from "./llm.js";
+import { LRUCache } from "lru-cache";
+export { LRUCache, LRUCache as LruCache } from "lru-cache";
+export const DEFAULT_MEMORY_CACHE_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+export const DEFAULT_MEMORY_LLM_CACHE_MAX_ITEMS = 1000;
+export const DEFAULT_MEMORY_LLM_CACHE_MAX_BYTES = 50 * 1024 * 1024; // 50 MB
+export const DEFAULT_MEMORY_EMBED_CACHE_MAX_ITEMS = 2000;
+export const DEFAULT_MEMORY_EMBED_CACHE_MAX_BYTES = 64 * 1024 * 1024; // 64 MB
+let cacheGeneration = 0;
 const readOnlyDatabases = new WeakSet();
+const inflightEmbeddings = new Map();
+const inflightExpansions = new Map();
+export const memoryLlmCache = new LRUCache({
+    max: DEFAULT_MEMORY_LLM_CACHE_MAX_ITEMS,
+    maxSize: DEFAULT_MEMORY_LLM_CACHE_MAX_BYTES,
+    sizeCalculation: (value) => Math.max(1, Buffer.byteLength(value, "utf8")),
+    ttl: DEFAULT_MEMORY_CACHE_TTL_MS,
+    updateAgeOnGet: true,
+});
+export const memoryEmbeddingCache = new LRUCache({
+    max: DEFAULT_MEMORY_EMBED_CACHE_MAX_ITEMS,
+    maxSize: DEFAULT_MEMORY_EMBED_CACHE_MAX_BYTES,
+    sizeCalculation: (vector) => Math.max(1, vector.length * 8),
+    ttl: DEFAULT_MEMORY_CACHE_TTL_MS,
+    updateAgeOnGet: true,
+});
+export function resetInflightState() {
+    cacheGeneration++;
+    inflightEmbeddings.clear();
+    inflightExpansions.clear();
+    memoryLlmCache.clear();
+    memoryEmbeddingCache.clear();
+}
 import { METADATA_EXTRACTION_VERSION } from "./metadata.js";
 import { compileMetadataFilter } from "./metadata-filter.js";
 import { initializeMetadataSchema, syncDocumentMetadata, countDocumentsPendingMetadata, getMetadataByFilepath, parseMetadataJson, } from "./metadata-store.js";
@@ -167,7 +199,70 @@ function authorizeEmbeddingProviderRequest(provider, authorize, purpose, context
     }
     authorize(purpose, context);
 }
-async function embedQueriesForStore(store, queries) {
+async function embedQueriesWithSingleflight(modelId, queries, fetchBatch) {
+    const currentGeneration = cacheGeneration;
+    const missingQueries = Array.from(new Set(queries.filter(q => memoryEmbeddingCache.get(`${modelId}:${q}`) === undefined &&
+        !inflightEmbeddings.has(`${modelId}:${q}`))));
+    if (missingQueries.length > 0) {
+        const resolvers = new Map();
+        const promises = new Map();
+        for (const q of missingQueries) {
+            const inflightKey = `${modelId}:${q}`;
+            const promise = new Promise((resolve, reject) => {
+                resolvers.set(inflightKey, { resolve, reject });
+            });
+            promises.set(inflightKey, promise);
+            inflightEmbeddings.set(inflightKey, promise);
+        }
+        (async () => {
+            try {
+                const resultEmbeddings = await fetchBatch(missingQueries);
+                const isCurrentGen = currentGeneration === cacheGeneration;
+                for (let i = 0; i < missingQueries.length; i++) {
+                    const q = missingQueries[i];
+                    const key = `${modelId}:${q}`;
+                    const vec = resultEmbeddings[i];
+                    if (!vec) {
+                        throw new Error(`Embedding missing for query "${q}"`);
+                    }
+                    if (isCurrentGen && inflightEmbeddings.get(key) === promises.get(key)) {
+                        memoryEmbeddingCache.set(key, vec);
+                    }
+                    resolvers.get(key)?.resolve(vec);
+                }
+            }
+            catch (err) {
+                for (const q of missingQueries) {
+                    resolvers.get(`${modelId}:${q}`)?.reject(err);
+                }
+            }
+            finally {
+                for (const q of missingQueries) {
+                    const key = `${modelId}:${q}`;
+                    if (inflightEmbeddings.get(key) === promises.get(key)) {
+                        inflightEmbeddings.delete(key);
+                    }
+                }
+            }
+        })();
+    }
+    return Promise.all(queries.map(async (q) => {
+        const cached = memoryEmbeddingCache.get(`${modelId}:${q}`);
+        if (cached)
+            return [...cached];
+        const inflight = inflightEmbeddings.get(`${modelId}:${q}`);
+        if (inflight) {
+            const vec = await inflight;
+            return [...vec];
+        }
+        throw new Error(`Embedding missing for query "${q}"`);
+    }));
+}
+export async function embedQueriesForStore(store, queries) {
+    if (queries.length === 0) {
+        const model = store.embeddingProvider?.model ?? getLlm(store).embedModelName;
+        return { model, embeddings: [] };
+    }
     const provider = store.embeddingProvider;
     if (provider) {
         const identity = resolveReadyProviderEmbeddingIdentity(store.db, provider);
@@ -175,59 +270,61 @@ async function embedQueriesForStore(store, queries) {
             throw new EmbeddingIdentityStateError("IDENTITY_MISMATCH", "Query embedding requires a matching published embedding identity.");
         }
         authorizeEmbeddingProviderRequest(provider, store.authorizeRemoteRequest, "query-embedding", { identity });
-        const formatted = queries.map(query => provider.formatQuery(query));
-        try {
-            const vectors = await provider.embedBatch(formatted, {
-                purpose: "query-embedding",
-                kind: "query",
-                identityFingerprint: identity.fingerprint,
-            });
-            return {
-                model: provider.model,
-                embeddings: vectors.map(vector => vector.vector),
-            };
-        }
-        catch (batchError) {
-            if (formatted.length <= 1)
-                throw batchError;
-            const embeddings = [];
-            for (const query of formatted) {
-                const vector = await provider.embed(query, {
+        const modelId = `provider:${identity.fingerprint}`;
+        const embeddings = await embedQueriesWithSingleflight(modelId, queries, async (missing) => {
+            const formatted = missing.map(query => provider.formatQuery(query));
+            try {
+                const vectors = await provider.embedBatch(formatted, {
                     purpose: "query-embedding",
                     kind: "query",
                     identityFingerprint: identity.fingerprint,
                 });
-                embeddings.push(vector.vector);
+                return vectors.map(vector => vector.vector);
             }
-            return {
-                model: provider.model,
-                embeddings,
-            };
-        }
-    }
-    const llm = getLlm(store);
-    const model = llm.embedModelName;
-    const formatted = queries.map(query => formatQueryForEmbedding(query, model));
-    try {
-        const results = await llm.embedBatch(formatted);
-        return {
-            model,
-            embeddings: results.map(result => result?.embedding ?? []),
-        };
-    }
-    catch (batchError) {
-        if (formatted.length <= 1)
-            throw batchError;
-        const embeddings = [];
-        for (const query of formatted) {
-            const result = await llm.embed(query);
-            embeddings.push(result?.embedding ?? []);
-        }
+            catch (batchError) {
+                if (formatted.length <= 1)
+                    throw batchError;
+                const fallbackVectors = [];
+                for (let i = 0; i < formatted.length; i++) {
+                    const vector = await provider.embed(formatted[i], {
+                        purpose: "query-embedding",
+                        kind: "query",
+                        identityFingerprint: identity.fingerprint,
+                    });
+                    fallbackVectors.push(vector.vector);
+                }
+                return fallbackVectors;
+            }
+        });
         return {
-            model,
+            model: provider.model,
             embeddings,
         };
     }
+    const llm = getLlm(store);
+    const model = llm.embedModelName;
+    const modelId = `llm:${model}`;
+    const embeddings = await embedQueriesWithSingleflight(modelId, queries, async (missing) => {
+        const formatted = missing.map(query => formatQueryForEmbedding(query, model));
+        try {
+            const results = await llm.embedBatch(formatted);
+            return results.map(result => result?.embedding ?? []);
+        }
+        catch (batchError) {
+            if (formatted.length <= 1)
+                throw batchError;
+            const fallbackVectors = [];
+            for (let i = 0; i < formatted.length; i++) {
+                const result = await llm.embed(formatted[i]);
+                fallbackVectors.push(result?.embedding ?? []);
+            }
+            return fallbackVectors;
+        }
+    });
+    return {
+        model,
+        embeddings,
+    };
 }
 function createBorrowedEmbeddingSession(provider, maxDurationMs, getBuildLease, authorize, getIdentity) {
     const signal = AbortSignal.timeout(maxDurationMs);
@@ -2982,10 +3079,23 @@ export function getCacheKey(url, body) {
     return hash.digest("hex");
 }
 export function getCachedResult(db, cacheKey) {
-    const row = db.prepare(`SELECT result FROM llm_cache WHERE hash = ?`).get(cacheKey);
-    return row?.result ?? null;
+    const inMemory = memoryLlmCache.get(cacheKey);
+    if (inMemory !== undefined)
+        return inMemory;
+    try {
+        const row = db.prepare(`SELECT result FROM llm_cache WHERE hash = ?`).get(cacheKey);
+        if (row?.result) {
+            memoryLlmCache.set(cacheKey, row.result);
+            return row.result;
+        }
+    }
+    catch {
+        // llm_cache table may not exist yet in uninitialized/read-only in-memory databases
+    }
+    return null;
 }
 export function setCachedResult(db, cacheKey, result) {
+    memoryLlmCache.set(cacheKey, result);
     if (readOnlyDatabases.has(db))
         return;
     const now = new Date().toISOString();
@@ -2994,8 +3104,24 @@ export function setCachedResult(db, cacheKey, result) {
         db.exec(`DELETE FROM llm_cache WHERE hash NOT IN (SELECT hash FROM llm_cache ORDER BY created_at DESC LIMIT 1000)`);
     }
 }
+/**
+ * Clear cached LLM API responses and query embeddings.
+ *
+ * Note: memoryLlmCache, memoryEmbeddingCache, and in-flight deduplication maps
+ * are process-level singletons shared across collections/stores to maximize
+ * deduplication when different collections are queried concurrently with the
+ * same input. Calling clearCache() here flushes this process-wide in-memory
+ * cache as well.
+ */
 export function clearCache(db) {
-    db.exec(`DELETE FROM llm_cache`);
+    if (!readOnlyDatabases.has(db)) {
+        db.exec(`DELETE FROM llm_cache`);
+    }
+    cacheGeneration++;
+    inflightExpansions.clear();
+    inflightEmbeddings.clear();
+    memoryLlmCache.clear();
+    memoryEmbeddingCache.clear();
 }
 // =============================================================================
 // Cleanup and maintenance operations
@@ -3003,8 +3129,14 @@ export function clearCache(db) {
 /**
  * Delete cached LLM API responses.
  * Returns the number of cached responses deleted.
+ *
+ * Note: Also flushes the process-wide memoryLlmCache.
  */
 export function deleteLLMCache(db) {
+    cacheGeneration++;
+    memoryLlmCache.clear();
+    if (readOnlyDatabases.has(db))
+        return 0;
     const result = db.prepare(`DELETE FROM llm_cache`).run();
     return Number(result.changes);
 }
@@ -4880,25 +5012,43 @@ export async function expandQuery(query, model = DEFAULT_QUERY_MODEL, db, expans
             // Old cache format (pre-typed, newline-separated text) — re-expand
         }
     }
-    const llm = llmOverride ?? getDefaultLlamaCpp();
-    // Note: LlamaCpp uses hardcoded model, model parameter is ignored
-    const results = await llm.expandQuery(query, {
-        context: expansionContext,
-        includeLexical,
-        includeHyde,
-    });
-    // Map Queryable[] → ExpandedQuery[] (same shape, decoupled from llm.ts internals).
-    // Filter out entries that duplicate the original query text.
-    const expanded = results
-        .filter(r => r.text !== query)
-        .map(r => ({ type: r.type, query: r.text }));
+    const currentGeneration = cacheGeneration;
+    let inflight = inflightExpansions.get(cacheKey);
+    if (!inflight) {
+        inflight = (async () => {
+            try {
+                const llm = llmOverride ?? getDefaultLlamaCpp();
+                // Note: LlamaCpp uses hardcoded model, model parameter is ignored
+                const results = await llm.expandQuery(query, {
+                    context: expansionContext,
+                    includeLexical,
+                    includeHyde,
+                });
+                // Map Queryable[] → ExpandedQuery[] (same shape, decoupled from llm.ts internals).
+                // Filter out entries that duplicate the original query text.
+                const expanded = results
+                    .filter(r => r.text !== query)
+                    .map(r => ({ type: r.type, query: r.text }));
+                if (expanded.length > 0 &&
+                    currentGeneration === cacheGeneration &&
+                    inflightExpansions.get(cacheKey) === inflight) {
+                    setCachedResult(db, cacheKey, JSON.stringify(expanded));
+                }
+                return expanded;
+            }
+            finally {
+                if (inflightExpansions.get(cacheKey) === inflight) {
+                    inflightExpansions.delete(cacheKey);
+                }
+            }
+        })();
+        inflightExpansions.set(cacheKey, inflight);
+    }
+    const expanded = await inflight;
     if (options?.requireResult && expanded.length === 0) {
         throw new QueryExpansionNoResultError();
     }
-    if (expanded.length > 0) {
-        setCachedResult(db, cacheKey, JSON.stringify(expanded));
-    }
-    return expanded;
+    return expanded.map(e => ({ ...e }));
 }
 /**
  * Delete the cached expansion for a query. hybridQuery() calls this when an
@@ -4913,7 +5063,11 @@ export function deleteExpansionCacheEntry(db, query, model = DEFAULT_QUERY_MODEL
         ...(options?.includeHyde === false && { noHyde: true }),
         ...(options?.includeLexical === false && { noLex: true }),
     });
-    db.prepare(`DELETE FROM llm_cache WHERE hash = ?`).run(cacheKey);
+    inflightExpansions.delete(cacheKey);
+    memoryLlmCache.delete(cacheKey);
+    if (!readOnlyDatabases.has(db)) {
+        db.prepare(`DELETE FROM llm_cache WHERE hash = ?`).run(cacheKey);
+    }
 }
 // =============================================================================
 // Reranking

package/package.json

@@ -1,8 +1,30 @@
 {
   "name": "@wei840222/qmd",
-  "version": "2026.9.28",
-  "packageManager": "pnpm@11.15.1",
+  "version": "2026.9.30",
   "description": "Query Markup Documents - On-device hybrid search for markdown files with BM25, vector search, and LLM reranking",
+  "author": "Wan, Jiun Wei <wei840222@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "markdown",
+    "search",
+    "fts",
+    "full-text-search",
+    "vector",
+    "semantic-search",
+    "sqlite",
+    "bm25",
+    "embeddings",
+    "rag",
+    "mcp",
+    "reranking",
+    "knowledge-base",
+    "local-ai",
+    "llm"
+  ],
+  "engines": {
+    "node": ">=24.21.0"
+  },
+  "packageManager": "pnpm@12.6.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -64,20 +86,21 @@
     "url": "https://github.com/wei840222/qmd/issues"
   },
   "dependencies": {
-    "@modelcontextprotocol/server": "2.0.0",
+    "@modelcontextprotocol/server": "2.1.0",
     "@node-rs/jieba": "2.0.3",
     "@typesafe-ai/sdk": "^0.6.0",
     "fast-glob": "3.3.3",
-    "node-llama-cpp": "3.20.0",
-    "picomatch": "4.0.5",
+    "lru-cache": "^11.5.3",
+    "node-llama-cpp": "3.22.1",
+    "picomatch": "4.0.7",
     "sqlite-vec": "0.1.9",
     "tree-sitter-go": "0.25.0",
     "tree-sitter-python": "0.25.0",
     "tree-sitter-rust": "0.24.0",
     "tree-sitter-typescript": "0.23.2",
     "web-tree-sitter": "0.26.12",
-    "yaml": "2.9.0",
-    "zod": "4.2.1"
+    "yaml": "2.9.1",
+    "zod": "4.6.5"
   },
   "optionalDependencies": {
     "sqlite-vec-darwin-arm64": "0.1.9",
@@ -87,50 +110,28 @@
     "sqlite-vec-windows-x64": "0.1.9"
   },
   "devDependencies": {
-    "@oxlint/plugins": "1.78.0",
-    "oxlint": "1.78.0",
-    "tsx": "4.23.12",
-    "vitest": "3.2.7"
+    "@oxlint/plugins": "1.85.0",
+    "oxlint": "1.85.0",
+    "tsx": "4.23.15",
+    "vitest": "4.1.11"
   },
   "overrides": {
-    "@hono/node-server": "2.0.10",
-    "ajv": "8.18.0",
-    "esbuild": "0.28.1",
+    "@hono/node-server": "2.1.2",
+    "ajv": "8.20.0",
+    "esbuild": "0.28.2",
     "fast-uri": "3.1.5",
-    "hono": "4.12.34",
-    "ip-address": "10.3.1",
+    "hono": "4.13.10",
+    "ip-address": "10.7.2",
     "nanoid": "3.3.18",
-    "path-to-regexp": "8.4.0",
-    "postcss": "8.5.23",
-    "qs": "6.15.3",
-    "rollup": "4.59.0",
+    "path-to-regexp": "8.4.2",
+    "postcss": "8.5.28",
+    "qs": "6.16.0",
+    "rollup": "4.63.5",
     "simple-git": "3.36.0",
-    "tar": "7.5.21",
+    "tar": "7.5.22",
     "vite": "7.3.5"
   },
   "peerDependencies": {
     "typescript": "^5.9.3 || ^6.0.0-0"
-  },
-  "engines": {
-    "node": ">=22.16.0"
-  },
-  "keywords": [
-    "markdown",
-    "search",
-    "fts",
-    "full-text-search",
-    "vector",
-    "semantic-search",
-    "sqlite",
-    "bm25",
-    "embeddings",
-    "rag",
-    "mcp",
-    "reranking",
-    "knowledge-base",
-    "local-ai",
-    "llm"
-  ],
-  "author": "Wan, Jiun Wei <wei840222@gmail.com>",
-  "license": "MIT"
+  }
 }