@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/memory_backend.js

@@ -10,28 +10,32 @@
 // - local_hashvec: FNV-1a hash-based dense vectors
 // - local_embeddings: N-gram feature hashing with TF-IDF
 // - bitnet_embeddings: Uses BitNet worker /embed endpoint (falls back to local_embeddings)
-import * as fsPromises from "node:fs/promises";
-import { buildMemoryIndex, memoryIndexPath, rankMemoryIndex } from "./memory_index.js";
-import { buildHashvecIndexFull, loadHashvecIndexFromPersistDir, rankHashvecIndex, updateHashvecIndexIncremental, persistHashvecIndex, memoryHashvecIndexPath, } from "./memory_index_hashvec.js";
-import { buildEmbeddingsIndexFull, loadEmbeddingsIndexFromPersistDir, rankEmbeddingsIndex, updateEmbeddingsIndexIncremental, persistEmbeddingsIndex, memoryEmbeddingsIndexPath, } from "./memory_index_embeddings.js";
-import { embedTexts, isWorkerHealthy } from "../../../bitnet-worker/embed_client.js";
+// - local_lancedb: Embeddings + LanceDB manifest (relation/cluster metadata)
+import * as fsPromises from 'node:fs/promises';
+import { buildMemoryIndex, memoryIndexPath, rankMemoryIndex, } from './memory_index.js';
+import { buildHashvecIndexFull, loadHashvecIndexFromPersistDir, rankHashvecIndex, updateHashvecIndexIncremental, persistHashvecIndex, memoryHashvecIndexPath, } from './memory_index_hashvec.js';
+import { buildEmbeddingsIndexFull, loadEmbeddingsIndexFromPersistDir, rankEmbeddingsIndex, updateEmbeddingsIndexIncremental, persistEmbeddingsIndex, memoryEmbeddingsIndexPath, } from './memory_index_embeddings.js';
+import { buildLanceDbManifest, persistLanceDbManifest, memoryLanceManifestPath, } from './memory_index_lancedb.js';
+import { embedTexts, isWorkerHealthy } from '../../../bitnet-worker/embed_client.js';
 export function getMemoryBackendId() {
     // Future-proof: allow an env override, but keep deterministic default.
-    const raw = (process.env.VIBE_MEMORY_BACKEND ?? "").trim().toLowerCase();
-    if (raw === "local_tfidf")
-        return "local_tfidf";
-    if (raw === "local_hashvec")
-        return "local_hashvec";
-    if (raw === "local_embeddings")
-        return "local_embeddings";
-    if (raw === "bitnet_embeddings" || raw === "bitnet")
-        return "bitnet_embeddings";
-    return "local_tfidf";
+    const raw = (process.env.VIBE_MEMORY_BACKEND ?? '').trim().toLowerCase();
+    if (raw === 'local_tfidf')
+        return 'local_tfidf';
+    if (raw === 'local_hashvec')
+        return 'local_hashvec';
+    if (raw === 'local_embeddings')
+        return 'local_embeddings';
+    if (raw === 'bitnet_embeddings' || raw === 'bitnet')
+        return 'bitnet_embeddings';
+    if (raw === 'local_lancedb' || raw === 'lancedb')
+        return 'local_lancedb';
+    return 'local_tfidf';
 }
 export async function buildAndPersistMemoryIndex(args) {
-    let backend = getMemoryBackendId();
+    const backend = getMemoryBackendId();
     // BitNet embeddings: try to use worker, fall back to local_embeddings if unavailable
-    if (backend === "bitnet_embeddings") {
+    if (backend === 'bitnet_embeddings') {
         const workerAvailable = await isWorkerHealthy();
         if (!workerAvailable) {
             // Fall back to local_embeddings
@@ -42,9 +46,9 @@ export async function buildAndPersistMemoryIndex(args) {
             });
             await persistEmbeddingsIndex(args.persistDir, index);
             return {
-                backend: "bitnet_embeddings",
+                backend: 'bitnet_embeddings',
                 index,
-                issues: ["bitnet_worker_unavailable_using_local_fallback", ...issues],
+                issues: ['bitnet_worker_unavailable_using_local_fallback', ...issues],
             };
         }
         // Use BitNet worker for embeddings
@@ -56,7 +60,7 @@ export async function buildAndPersistMemoryIndex(args) {
         });
         // Replace vectors with BitNet-generated ones (if chunks exist)
         if (index.chunks.length > 0) {
-            const texts = index.chunks.map((c) => c.text.slice(0, 1000)); // Limit text length
+            const texts = index.chunks.map(c => c.text.slice(0, 1000)); // Limit text length
             const embedResult = await embedTexts({ texts, batchSize: 16 });
             if (embedResult && embedResult.embeddings.length === index.chunks.length) {
                 for (let i = 0; i < index.chunks.length; i++) {
@@ -72,13 +76,13 @@ export async function buildAndPersistMemoryIndex(args) {
                 issues.push(`bitnet_embeddings_generated_${embedResult.model}`);
             }
             else {
-                issues.push("bitnet_embed_failed_using_local_vectors");
+                issues.push('bitnet_embed_failed_using_local_vectors');
             }
         }
         await persistEmbeddingsIndex(args.persistDir, index);
         return { backend, index, issues };
     }
-    if (backend === "local_embeddings") {
+    if (backend === 'local_embeddings') {
         const { index, issues } = await buildEmbeddingsIndexFull({
             workspaceRoot: args.workspaceRoot,
             docsRoot: args.docsRoot,
@@ -87,7 +91,25 @@ export async function buildAndPersistMemoryIndex(args) {
         await persistEmbeddingsIndex(args.persistDir, index);
         return { backend, index, issues };
     }
-    if (backend === "local_hashvec") {
+    if (backend === 'local_lancedb') {
+        const { index, issues } = await buildEmbeddingsIndexFull({
+            workspaceRoot: args.workspaceRoot,
+            docsRoot: args.docsRoot,
+            docsFilesAbs: args.docsFilesAbs,
+        });
+        await persistEmbeddingsIndex(args.persistDir, index);
+        const lance = await buildLanceDbManifest({
+            persistDir: args.persistDir,
+            index,
+        });
+        await persistLanceDbManifest(args.persistDir, lance.manifest);
+        return {
+            backend: 'local_lancedb',
+            index,
+            issues: [...issues, ...lance.issues],
+        };
+    }
+    if (backend === 'local_hashvec') {
         const { index, issues } = await buildHashvecIndexFull({
             workspaceRoot: args.workspaceRoot,
             docsRoot: args.docsRoot,
@@ -101,34 +123,39 @@ export async function buildAndPersistMemoryIndex(args) {
         docsRoot: args.docsRoot,
         docsFilesAbs: args.docsFilesAbs,
     });
-    await fsPromises.writeFile(memoryIndexPath(args.persistDir), JSON.stringify(index, null, 2) + "\n", "utf-8");
+    await fsPromises.writeFile(memoryIndexPath(args.persistDir), JSON.stringify(index, null, 2) + '\n', 'utf-8');
     return { backend, index, issues };
 }
 export async function loadMemoryIndexFromPersistDir(persistDir) {
     const preferred = getMemoryBackendId();
     // Prefer the selected backend, but allow fallback to any available index file.
     // BitNet embeddings uses the same file format as local_embeddings
-    if (preferred === "local_embeddings" || preferred === "bitnet_embeddings") {
+    if (preferred === 'local_embeddings' || preferred === 'bitnet_embeddings') {
+        const emb = await loadEmbeddingsIndexFromPersistDir(persistDir);
+        if (emb)
+            return emb;
+    }
+    if (preferred === 'local_lancedb') {
         const emb = await loadEmbeddingsIndexFromPersistDir(persistDir);
         if (emb)
             return emb;
     }
-    if (preferred === "local_hashvec") {
+    if (preferred === 'local_hashvec') {
         const hv = await loadHashvecIndexFromPersistDir(persistDir);
         if (hv)
             return hv;
     }
     const p = memoryIndexPath(persistDir);
     try {
-        const raw = await fsPromises.readFile(p, "utf-8");
+        const raw = await fsPromises.readFile(p, 'utf-8');
         const j = JSON.parse(raw);
-        if (j.schema_version !== "memory.index.v1")
+        if (j.schema_version !== 'memory.index.v1')
             return null;
-        if (j.backend !== "local_tfidf")
+        if (j.backend !== 'local_tfidf')
             return null;
         if (!Array.isArray(j.chunks))
             return null;
-        if (!j.idf || typeof j.idf !== "object")
+        if (!j.idf || typeof j.idf !== 'object')
             return null;
         return j;
     }
@@ -142,10 +169,10 @@ export async function loadMemoryIndexFromPersistDir(persistDir) {
     return await loadEmbeddingsIndexFromPersistDir(persistDir);
 }
 export function queryMemoryIndex(args) {
-    if (args.index.schema_version === "memory.embeddings.index.v1") {
+    if (args.index.schema_version === 'memory.embeddings.index.v1') {
         return rankEmbeddingsIndex({ index: args.index, query: args.query, topK: args.topK });
     }
-    if (args.index.schema_version === "memory.hashvec.index.v1") {
+    if (args.index.schema_version === 'memory.hashvec.index.v1') {
         return rankHashvecIndex({ index: args.index, query: args.query, topK: args.topK });
     }
     return rankMemoryIndex({ index: args.index, query: args.query, topK: args.topK });
@@ -155,12 +182,13 @@ export function getIndexFilePaths(persistDir) {
         tfidf: memoryIndexPath(persistDir),
         hashvec: memoryHashvecIndexPath(persistDir),
         embeddings: memoryEmbeddingsIndexPath(persistDir),
+        lancedb: memoryLanceManifestPath(persistDir),
     };
 }
 export async function updateHashvecIndexBestEffort(args) {
     const existing = await loadHashvecIndexFromPersistDir(args.persistDir);
     if (!existing)
-        return { index: null, issues: ["hashvec_index_missing"] };
+        return { index: null, issues: ['hashvec_index_missing'] };
     const res = await updateHashvecIndexIncremental({
         workspaceRoot: args.workspaceRoot,
         docsRoot: args.docsRoot,
@@ -174,7 +202,7 @@ export async function updateHashvecIndexBestEffort(args) {
 export async function updateEmbeddingsIndexBestEffort(args) {
     const existing = await loadEmbeddingsIndexFromPersistDir(args.persistDir);
     if (!existing)
-        return { index: null, issues: ["embeddings_index_missing"] };
+        return { index: null, issues: ['embeddings_index_missing'] };
     const res = await updateEmbeddingsIndexIncremental({
         workspaceRoot: args.workspaceRoot,
         docsRoot: args.docsRoot,

package/build/mcp/tools/vibe_pm/memory_index_lancedb.d.ts

@@ -0,0 +1,38 @@
+import type { EmbeddingsIndexFileV1 } from './memory_index_embeddings.js';
+export type LanceDbRelationKind = 'same_directory' | 'shared_heading';
+export type LanceDbRelation = {
+    from_file: string;
+    to_file: string;
+    kind: LanceDbRelationKind;
+    weight: number;
+};
+export type LanceDbCluster = {
+    cluster_id: string;
+    label: string;
+    file_count: number;
+    files: string[];
+};
+export type LanceDbMemoryManifestV1 = {
+    schema_version: 'memory.lancedb.v1';
+    backend: 'local_lancedb';
+    built_at: string;
+    chunk_count: number;
+    source_index_schema: 'memory.embeddings.index.v1';
+    lancedb_available: boolean;
+    db_uri: string;
+    tables: {
+        chunks: string;
+        relations: string;
+    };
+    relations: LanceDbRelation[];
+    clusters: LanceDbCluster[];
+};
+export declare function memoryLanceManifestPath(persistDir: string): string;
+export declare function buildLanceDbManifest(args: {
+    persistDir: string;
+    index: EmbeddingsIndexFileV1;
+}): Promise<{
+    manifest: LanceDbMemoryManifestV1;
+    issues: string[];
+}>;
+export declare function persistLanceDbManifest(persistDir: string, manifest: LanceDbMemoryManifestV1): Promise<void>;

package/build/mcp/tools/vibe_pm/memory_index_lancedb.js

@@ -0,0 +1,125 @@
+// Optional LanceDB metadata manifest (local-first, fail-safe)
+//
+// This module does not require a hard runtime dependency on LanceDB.
+// It writes a manifest that captures relation mappings and clustering hints,
+// while the retrieval path keeps using the embeddings index as SSOT.
+import * as fsPromises from 'node:fs/promises';
+import * as path from 'node:path';
+export function memoryLanceManifestPath(persistDir) {
+    return path.join(persistDir, 'memory_index.lancedb.v1.json');
+}
+function relationKey(a, b, kind) {
+    return `${a}::${b}::${kind}`;
+}
+function normalizePair(a, b) {
+    return a < b ? { left: a, right: b } : { left: b, right: a };
+}
+function buildRelations(index) {
+    const relations = new Map();
+    const files = Object.keys(index.files);
+    const dirToFiles = new Map();
+    for (const file of files) {
+        const dir = path.posix.dirname(file.replaceAll('\\', '/'));
+        const list = dirToFiles.get(dir) ?? [];
+        list.push(file);
+        dirToFiles.set(dir, list);
+    }
+    for (const groupedFiles of dirToFiles.values()) {
+        if (groupedFiles.length < 2)
+            continue;
+        for (let i = 0; i < groupedFiles.length; i++) {
+            for (let j = i + 1; j < groupedFiles.length; j++) {
+                const { left, right } = normalizePair(groupedFiles[i], groupedFiles[j]);
+                const key = relationKey(left, right, 'same_directory');
+                relations.set(key, {
+                    from_file: left,
+                    to_file: right,
+                    kind: 'same_directory',
+                    weight: 0.35,
+                });
+            }
+        }
+    }
+    const headingToFiles = new Map();
+    for (const chunk of index.chunks) {
+        const heading = (chunk.heading ?? '').trim().toLowerCase();
+        if (!heading)
+            continue;
+        if (!headingToFiles.has(heading)) {
+            headingToFiles.set(heading, new Set());
+        }
+        headingToFiles.get(heading).add(chunk.file_rel);
+    }
+    for (const fileSet of headingToFiles.values()) {
+        const groupedFiles = Array.from(fileSet.values());
+        if (groupedFiles.length < 2)
+            continue;
+        for (let i = 0; i < groupedFiles.length; i++) {
+            for (let j = i + 1; j < groupedFiles.length; j++) {
+                const { left, right } = normalizePair(groupedFiles[i], groupedFiles[j]);
+                const key = relationKey(left, right, 'shared_heading');
+                const existing = relations.get(key);
+                if (!existing || existing.weight < 0.55) {
+                    relations.set(key, {
+                        from_file: left,
+                        to_file: right,
+                        kind: 'shared_heading',
+                        weight: 0.55,
+                    });
+                }
+            }
+        }
+    }
+    return Array.from(relations.values()).sort((a, b) => `${a.from_file}:${a.to_file}`.localeCompare(`${b.from_file}:${b.to_file}`));
+}
+function buildClusters(index) {
+    const bucket = new Map();
+    for (const file of Object.keys(index.files)) {
+        const normalized = file.replaceAll('\\', '/');
+        const top = normalized.split('/')[0] ?? 'root';
+        const list = bucket.get(top) ?? [];
+        list.push(normalized);
+        bucket.set(top, list);
+    }
+    return Array.from(bucket.entries())
+        .map(([label, files], idx) => ({
+        cluster_id: `cluster_${idx + 1}`,
+        label,
+        file_count: files.length,
+        files: files.sort(),
+    }))
+        .sort((a, b) => b.file_count - a.file_count || a.label.localeCompare(b.label));
+}
+async function detectLanceDbAvailability() {
+    try {
+        const lazyImport = new Function('m', 'return import(m)');
+        await lazyImport('@lancedb/lancedb');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildLanceDbManifest(args) {
+    const available = await detectLanceDbAvailability();
+    const issues = available ? [] : ['lancedb_module_not_installed_using_manifest_only'];
+    const manifest = {
+        schema_version: 'memory.lancedb.v1',
+        backend: 'local_lancedb',
+        built_at: new Date().toISOString(),
+        chunk_count: args.index.chunk_count,
+        source_index_schema: 'memory.embeddings.index.v1',
+        lancedb_available: available,
+        db_uri: path.join(args.persistDir, 'lancedb'),
+        tables: {
+            chunks: 'chunks',
+            relations: 'relations',
+        },
+        relations: buildRelations(args.index),
+        clusters: buildClusters(args.index),
+    };
+    return { manifest, issues };
+}
+export async function persistLanceDbManifest(persistDir, manifest) {
+    await fsPromises.writeFile(memoryLanceManifestPath(persistDir), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+}

package/build/mcp/tools/vibe_pm/memory_retrieve.d.ts

@@ -1,6 +1,6 @@
-import { type MemoryRetrieveOutputSSOT } from "../../generated/memory_retrieve_output.js";
-import type { MemoryRetrieveInput } from "../../generated/memory_retrieve_input.js";
-import { type RerankMode } from "./memory_rerank.js";
+import { type MemoryRetrieveOutputSSOT } from '../../generated/memory_retrieve_output.js';
+import type { MemoryRetrieveInput } from '../../generated/memory_retrieve_input.js';
+import { type RerankMode } from './memory_rerank.js';
 /**
  * Extended input with rerank options
  */

package/build/mcp/tools/vibe_pm/memory_retrieve.js

@@ -7,24 +7,24 @@
 // When a real KCE/Chroma pipeline is wired in, this tool should be upgraded to:
 // - query embedding + vector search (persist_dir) and return top-k chunks with citations,
 // while keeping the output contract stable.
-import * as fs from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as path from "node:path";
-import { MemoryRetrieveOutputSchema } from "../../generated/memory_retrieve_output.js";
-import { ensureDirSync, getVibeChromaCacheDir } from "../../paths.js";
-import { loadMemoryIndexFromPersistDir, queryMemoryIndex } from "./memory_backend.js";
-import { resolveEffectiveDocsRoot } from "./memory_docs_root.js";
-import { applyRerank } from "./memory_rerank.js";
+import * as fs from 'node:fs';
+import * as fsPromises from 'node:fs/promises';
+import * as path from 'node:path';
+import { MemoryRetrieveOutputSchema, } from '../../generated/memory_retrieve_output.js';
+import { ensureDirSync, getVibeChromaCacheDir } from '../../../kernel/paths.js';
+import { getMemoryBackendId, loadMemoryIndexFromPersistDir, queryMemoryIndex, } from './memory_backend.js';
+import { resolveEffectiveDocsRoot } from './memory_docs_root.js';
+import { applyRerank } from './memory_rerank.js';
 function isTruthyEnv(value) {
-    const v = (value ?? "").trim().toLowerCase();
-    return v === "1" || v === "true" || v === "yes" || v === "on";
+    const v = (value ?? '').trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
 }
 async function walkDocs(root) {
     const out = [];
     async function visit(dir) {
         const entries = await fsPromises.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
-            if (e.name === "node_modules" || e.name === ".git" || e.name === ".vibe" || e.name === "runs")
+            if (e.name === 'node_modules' || e.name === '.git' || e.name === '.vibe' || e.name === 'runs')
                 continue;
             const p = path.join(dir, e.name);
             if (e.isDirectory()) {
@@ -32,7 +32,7 @@ async function walkDocs(root) {
                 continue;
             }
             const lower = e.name.toLowerCase();
-            if (lower.endsWith(".md") || lower.endsWith(".mdx"))
+            if (lower.endsWith('.md') || lower.endsWith('.mdx'))
                 out.push(p);
         }
     }
@@ -42,12 +42,12 @@ async function walkDocs(root) {
 function tokenizeQuery(query) {
     const q = query
         .toLowerCase()
-        .replace(/[^\p{L}\p{N}_\s-]+/gu, " ")
+        .replace(/[^\p{L}\p{N}_\s-]+/gu, ' ')
         .split(/\s+/)
-        .map((s) => s.trim())
+        .map(s => s.trim())
         .filter(Boolean);
-    const stop = new Set(["the", "a", "an", "and", "or", "to", "of", "in", "on", "for", "with"]);
-    return q.filter((t) => t.length >= 2 && !stop.has(t));
+    const stop = new Set(['the', 'a', 'an', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with']);
+    return q.filter(t => t.length >= 2 && !stop.has(t));
 }
 function scoreDoc(contentLower, tokens) {
     let score = 0;
@@ -85,15 +85,18 @@ function buildSnippet(params) {
     return content.slice(start, end);
 }
 export async function memoryRetrieve(args) {
-    const docsResolved = resolveEffectiveDocsRoot({ workspaceRoot: args.workspaceRoot, inputDocsRoot: args.input.docs_root });
-    const requestedDocsRoot = (args.input.docs_root ?? "docs").trim();
-    const docsRoot = docsResolved.ok ? docsResolved.docsRoot : (requestedDocsRoot || "docs");
-    const query = String(args.input.query ?? "").trim();
+    const docsResolved = resolveEffectiveDocsRoot({
+        workspaceRoot: args.workspaceRoot,
+        inputDocsRoot: args.input.docs_root,
+    });
+    const requestedDocsRoot = (args.input.docs_root ?? 'docs').trim();
+    const docsRoot = docsResolved.ok ? docsResolved.docsRoot : requestedDocsRoot || 'docs';
+    const query = String(args.input.query ?? '').trim();
     const maxChars = args.input.max_chars ?? 6000;
     const offline = isTruthyEnv(process.env.VIBECODE_OFFLINE);
     const persistDir = getVibeChromaCacheDir(args.workspaceRoot);
     ensureDirSync(persistDir);
-    const persistOverrideIgnored = (args.input.persist_dir ?? "").trim() && (args.input.persist_dir ?? "").trim() !== persistDir;
+    const persistOverrideIgnored = (args.input.persist_dir ?? '').trim() && (args.input.persist_dir ?? '').trim() !== persistDir;
     const docsAbs = docsResolved.ok ? docsResolved.docsAbs : path.join(args.workspaceRoot, docsRoot);
     const docsExists = fs.existsSync(docsAbs) && fs.statSync(docsAbs).isDirectory();
     if (!docsExists) {
@@ -101,7 +104,7 @@ export async function memoryRetrieve(args) {
             query,
             docs_root: docsRoot,
             persist_dir: persistDir,
-            context_block: `NO_DOCS_ROOT: ${docsRoot}\n(회복) docs_root 경로를 확인한 뒤 문서 인덱스를 다시 준비해 주세요.${persistOverrideIgnored ? "\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)" : ""}${docsResolved.issues.length ? `\nNOTE: ${docsResolved.issues.join(", ")}` : ""}`,
+            context_block: `NO_DOCS_ROOT: ${docsRoot}\n(회복) docs_root 경로를 확인한 뒤 문서 인덱스를 다시 준비해 주세요.${persistOverrideIgnored ? '\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)' : ''}${docsResolved.issues.length ? `\nNOTE: ${docsResolved.issues.join(', ')}` : ''}`,
         });
     }
     const tokens = tokenizeQuery(query);
@@ -110,15 +113,15 @@ export async function memoryRetrieve(args) {
             query,
             docs_root: docsRoot,
             persist_dir: persistDir,
-            context_block: `EMPTY_QUERY: 유효한 검색 토큰이 없습니다.${persistOverrideIgnored ? "\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)" : ""}`,
+            context_block: `EMPTY_QUERY: 유효한 검색 토큰이 없습니다.${persistOverrideIgnored ? '\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)' : ''}`,
         });
     }
     // Prefer index-based retrieval if present.
     const index = await loadMemoryIndexFromPersistDir(persistDir);
     if (index) {
         // Determine if reranking is enabled and configure options
-        const rerankMode = args.input.rerank_mode ?? "none";
-        const useRerank = rerankMode !== "none";
+        const rerankMode = args.input.rerank_mode ?? 'none';
+        const useRerank = rerankMode !== 'none';
         const initialTopK = useRerank ? 20 : 6; // Fetch more when reranking
         let ranked = queryMemoryIndex({ index, query, topK: initialTopK });
         // Apply rerank if enabled
@@ -133,24 +136,37 @@ export async function memoryRetrieve(args) {
             ranked = applyRerank(ranked, query, rerankOptions);
             ranked = ranked.slice(0, 6); // Limit to top 6 after reranking
         }
-        const backendLabel = index.schema_version === "memory.hashvec.index.v1" ? "local_hashvec" : "local_tfidf";
-        const rerankLabel = useRerank ? `, rerank=${rerankMode}` : "";
-        let out = `MEMORY_RETRIEVE (${backendLabel}${rerankLabel}${offline ? ", offline" : ""})\nquery: ${query}\n\n`;
+        const backendLabel = index.schema_version === 'memory.hashvec.index.v1'
+            ? 'local_hashvec'
+            : index.schema_version === 'memory.embeddings.index.v1'
+                ? getMemoryBackendId() === 'local_lancedb'
+                    ? 'local_lancedb'
+                    : getMemoryBackendId() === 'bitnet_embeddings'
+                        ? 'bitnet_embeddings'
+                        : 'local_embeddings'
+                : 'local_tfidf';
+        const rerankLabel = useRerank ? `, rerank=${rerankMode}` : '';
+        let out = `MEMORY_RETRIEVE (${backendLabel}${rerankLabel}${offline ? ', offline' : ''})\nquery: ${query}\n\n`;
         if (docsResolved.issues.length) {
-            out += `NOTE: ${docsResolved.issues.join(", ")}\n\n`;
+            out += `NOTE: ${docsResolved.issues.join(', ')}\n\n`;
         }
         if (persistOverrideIgnored) {
-            out += "NOTE: persist_dir override ignored (enforced .vibe/cache/chroma)\n\n";
+            out += 'NOTE: persist_dir override ignored (enforced .vibe/cache/chroma)\n\n';
         }
         if (ranked.length === 0) {
-            out += "NO_MATCH: 인덱스에서 유의미한 결과를 찾지 못했습니다.\n";
-            return MemoryRetrieveOutputSchema.parse({ query, docs_root: docsRoot, persist_dir: persistDir, context_block: out });
+            out += 'NO_MATCH: 인덱스에서 유의미한 결과를 찾지 못했습니다.\n';
+            return MemoryRetrieveOutputSchema.parse({
+                query,
+                docs_root: docsRoot,
+                persist_dir: persistDir,
+                context_block: out,
+            });
         }
         let remaining = Math.max(500, Math.min(20000, maxChars)) - out.length;
         for (const r of ranked) {
             if (remaining <= 0)
                 break;
-            const header = `--- ${r.chunk.file_rel}${r.chunk.heading ? ` :: ${r.chunk.heading}` : ""} (score=${r.score.toFixed(4)}) ---\n`;
+            const header = `--- ${r.chunk.file_rel}${r.chunk.heading ? ` :: ${r.chunk.heading}` : ''} (score=${r.score.toFixed(4)}) ---\n`;
             if (header.length > remaining)
                 break;
             out += header;
@@ -161,9 +177,9 @@ export async function memoryRetrieve(args) {
                 tokens,
                 maxChars: remaining,
             })
-                .replace(/\r\n/g, "\n")
+                .replace(/\r\n/g, '\n')
                 .trim();
-            const body = snippet + "\n\n";
+            const body = snippet + '\n\n';
             out += body.slice(0, Math.max(0, remaining));
             remaining -= body.length;
         }
@@ -180,14 +196,14 @@ export async function memoryRetrieve(args) {
             query,
             docs_root: docsRoot,
             persist_dir: persistDir,
-            context_block: `NO_DOCS: ${docsRoot} 아래에 .md/.mdx 문서가 없습니다.${persistOverrideIgnored ? "\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)" : ""}`,
+            context_block: `NO_DOCS: ${docsRoot} 아래에 .md/.mdx 문서가 없습니다.${persistOverrideIgnored ? '\nNOTE: persist_dir override ignored (enforced .vibe/cache/chroma)' : ''}`,
         });
     }
     const scored = [];
     for (const f of files) {
         try {
-            const rel = path.relative(args.workspaceRoot, f).replaceAll("\\", "/");
-            const raw = await fsPromises.readFile(f, "utf-8");
+            const rel = path.relative(args.workspaceRoot, f).replaceAll('\\', '/');
+            const raw = await fsPromises.readFile(f, 'utf-8');
             const lower = raw.toLowerCase();
             const s = scoreDoc(lower, tokens);
             if (s <= 0)
@@ -201,16 +217,16 @@ export async function memoryRetrieve(args) {
     scored.sort((a, b) => b.score - a.score);
     const top = scored.slice(0, 5);
     // Build context block with a strict max length
-    let out = `MEMORY_RETRIEVE (best-effort${offline ? ", offline" : ""})\nquery: ${query}\n\n`;
+    let out = `MEMORY_RETRIEVE (best-effort${offline ? ', offline' : ''})\nquery: ${query}\n\n`;
     if (docsResolved.issues.length) {
-        out += `NOTE: ${docsResolved.issues.join(", ")}\n\n`;
+        out += `NOTE: ${docsResolved.issues.join(', ')}\n\n`;
     }
     if (persistOverrideIgnored) {
-        out += "NOTE: persist_dir override ignored (enforced .vibe/cache/chroma)\n\n";
+        out += 'NOTE: persist_dir override ignored (enforced .vibe/cache/chroma)\n\n';
     }
     let remaining = Math.max(500, Math.min(20000, maxChars)) - out.length;
     if (top.length === 0) {
-        out += "NO_MATCH: 문서에서 검색어를 찾지 못했습니다.\n";
+        out += 'NO_MATCH: 문서에서 검색어를 찾지 못했습니다.\n';
         return MemoryRetrieveOutputSchema.parse({
             query,
             docs_root: docsRoot,
@@ -232,9 +248,9 @@ export async function memoryRetrieve(args) {
             tokens,
             maxChars: remaining,
         })
-            .replace(/\r\n/g, "\n")
+            .replace(/\r\n/g, '\n')
             .trim();
-        const body = snippet + "\n\n";
+        const body = snippet + '\n\n';
         out += body.slice(0, Math.max(0, remaining));
         remaining -= body.length;
     }

package/build/mcp/tools/vibe_pm/memory_status.d.ts

@@ -1,5 +1,5 @@
-import { type MemoryStatusOutputSSOT } from "../../generated/memory_status_output.js";
-import type { MemoryStatusInput } from "../../generated/memory_status_input.js";
+import { type MemoryStatusOutputSSOT } from '../../generated/memory_status_output.js';
+import type { MemoryStatusInput } from '../../generated/memory_status_input.js';
 export declare function memoryStatus(args: {
     workspaceRoot: string;
     input: MemoryStatusInput;