@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/mapping/orchestrator.js

@@ -0,0 +1,200 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/orchestrator.ts
+import fs from "fs";
+import fsPromises from "fs/promises";
+import path from "path";
+import { loadSpecMap } from "./spec_map.js";
+import { scanChangedFiles, scanStagedFiles, scanChangedFilesAsync, scanStagedFilesAsync, scanChangedFilesSmart, scanStagedFilesSmart, } from "./diff_scan.js";
+import { scanImportHints } from "./import_scan.js";
+import { buildChangeMap } from "./change_map.js";
+import { buildSkeletonMapPatch } from "./skeleton_patch.js";
+import { judgeMappingGate } from "./gate_judge.js";
+import { getPmRunDir, resolvePmRunDirForRead, resolveSpecMapPath } from "../../../paths.js";
+import { emitEvent } from "../../../events/emitter.js";
+/**
+ * 상대 경로 계산
+ */
+function rel(root, abs) {
+    const r = path.relative(root, abs);
+    return r.startsWith("..") ? abs : r;
+}
+/**
+ * Core pipeline logic: import hints → change map → skeleton patch → gate
+ * Sync version (uses fs.writeFileSync)
+ */
+function executePipelineCoreSync(args) {
+    const { workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs } = args;
+    // Import hints
+    const importHints = scanImportHints(workspaceRoot, changed.map((c) => c.file));
+    // Change map
+    const changeMap = buildChangeMap({
+        run_id,
+        base: useStaged ? "staged" : base,
+        head: useStaged ? "working" : head,
+        spec,
+        changed,
+        imports: importHints,
+    });
+    // Output directory
+    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), "mapping");
+    fs.mkdirSync(outDir, { recursive: true });
+    // Save change_map
+    const changeMapPath = path.join(outDir, "change_map.v1.json");
+    fs.writeFileSync(changeMapPath, JSON.stringify(changeMap, null, 2), "utf-8");
+    // Skeleton patch
+    const skeletonPatch = buildSkeletonMapPatch({
+        workspaceRoot,
+        run_id,
+        specMapAbsPath: specAbs,
+        changeMapAbsPath: changeMapPath,
+        changeMap,
+    });
+    const skeletonPatchPath = path.join(outDir, "skeleton_map_patch.v1.json");
+    fs.writeFileSync(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), "utf-8");
+    emitEvent({
+        runId: run_id,
+        type: "artifact.mapping_written",
+        reason: "mapping_sync",
+        paths: [changeMapPath, skeletonPatchPath],
+        component: "mapping_orchestrator",
+        workspaceRoot: workspaceRoot,
+    });
+    // Gate decision
+    const decision = judgeMappingGate({
+        run_id,
+        spec,
+        changeMap,
+        changeMapPath: rel(workspaceRoot, changeMapPath),
+    });
+    return { decision, changeMap, skeletonPatch, changeMapPath, skeletonPatchPath };
+}
+/**
+ * Core pipeline logic: import hints → change map → skeleton patch → gate
+ * Async version (uses fs.promises for file writes)
+ */
+async function executePipelineCoreAsync(args) {
+    const { workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs } = args;
+    // Import hints
+    const importHints = scanImportHints(workspaceRoot, changed.map((c) => c.file));
+    // Change map
+    const changeMap = buildChangeMap({
+        run_id,
+        base: useStaged ? "staged" : base,
+        head: useStaged ? "working" : head,
+        spec,
+        changed,
+        imports: importHints,
+    });
+    // Output directory
+    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), "mapping");
+    await fsPromises.mkdir(outDir, { recursive: true });
+    // Save change_map
+    const changeMapPath = path.join(outDir, "change_map.v1.json");
+    await fsPromises.writeFile(changeMapPath, JSON.stringify(changeMap, null, 2), "utf-8");
+    // Skeleton patch
+    const skeletonPatch = buildSkeletonMapPatch({
+        workspaceRoot,
+        run_id,
+        specMapAbsPath: specAbs,
+        changeMapAbsPath: changeMapPath,
+        changeMap,
+    });
+    const skeletonPatchPath = path.join(outDir, "skeleton_map_patch.v1.json");
+    await fsPromises.writeFile(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), "utf-8");
+    emitEvent({
+        runId: run_id,
+        type: "artifact.mapping_written",
+        reason: "mapping_async",
+        paths: [changeMapPath, skeletonPatchPath],
+        component: "mapping_orchestrator",
+        workspaceRoot: workspaceRoot,
+    });
+    // Gate decision
+    const decision = judgeMappingGate({
+        run_id,
+        spec,
+        changeMap,
+        changeMapPath: rel(workspaceRoot, changeMapPath),
+    });
+    return { decision, changeMap, skeletonPatch, changeMapPath, skeletonPatchPath };
+}
+/**
+ * 매핑 파이프라인 실행 (동기 버전)
+ * @deprecated Use runMappingPipelineAsync or runMappingPipelineSmart instead.
+ * Sync operations block the event loop.
+ */
+export function runMappingPipeline(options) {
+    const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
+    const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
+    const base = baseRef ?? "HEAD~1";
+    const head = headRef ?? "HEAD";
+    const changed = useStaged
+        ? scanStagedFiles(workspaceRoot)
+        : scanChangedFiles(base, head, workspaceRoot);
+    return executePipelineCoreSync({
+        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
+    });
+}
+/**
+ * spec_map 존재 여부 확인
+ */
+export function hasSpecMap(workspaceRoot) {
+    const { absPath } = resolveSpecMapPath(workspaceRoot);
+    return fs.existsSync(absPath);
+}
+/**
+ * change_map 존재 여부 확인
+ */
+export function hasChangeMap(workspaceRoot, run_id) {
+    const runDir = resolvePmRunDirForRead(workspaceRoot, run_id);
+    const changeMapPath = path.join(runDir, "mapping", "change_map.v1.json");
+    return fs.existsSync(changeMapPath);
+}
+/**
+ * change_map 로드
+ */
+export function loadChangeMap(workspaceRoot, run_id) {
+    const runDir = resolvePmRunDirForRead(workspaceRoot, run_id);
+    const changeMapPath = path.join(runDir, "mapping", "change_map.v1.json");
+    if (!fs.existsSync(changeMapPath))
+        return null;
+    try {
+        const raw = fs.readFileSync(changeMapPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
+// Async Pipeline (non-blocking)
+// ============================================================
+/**
+ * Async mapping pipeline - uses async git operations and file I/O
+ */
+export async function runMappingPipelineAsync(options) {
+    const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
+    const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
+    const base = baseRef ?? "HEAD~1";
+    const head = headRef ?? "HEAD";
+    const changed = useStaged
+        ? await scanStagedFilesAsync(workspaceRoot)
+        : await scanChangedFilesAsync(base, head, workspaceRoot);
+    return executePipelineCoreAsync({
+        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
+    });
+}
+/**
+ * Smart mapping pipeline - uses worker if available, otherwise async local
+ */
+export async function runMappingPipelineSmart(options) {
+    const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
+    const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
+    const base = baseRef ?? "HEAD~1";
+    const head = headRef ?? "HEAD";
+    const changed = useStaged
+        ? await scanStagedFilesSmart(workspaceRoot, run_id)
+        : await scanChangedFilesSmart(base, head, workspaceRoot, run_id);
+    return executePipelineCoreAsync({
+        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
+    });
+}

package/build/mcp/tools/vibe_pm/mapping/skeleton_patch.d.ts

@@ -0,0 +1,15 @@
+import { ChangeMap, SkeletonMapPatch } from "./types.js";
+/**
+ * skeleton_map에 mapping ref 기록용 패치 생성
+ */
+export declare function buildSkeletonMapPatch(args: {
+    workspaceRoot: string;
+    run_id: string;
+    specMapAbsPath: string;
+    changeMapAbsPath: string;
+    changeMap: ChangeMap;
+}): SkeletonMapPatch;
+/**
+ * 기존 skeleton_map 파일에 mapping 섹션 병합
+ */
+export declare function mergeSkeletonMapPatch(existingSkeletonPath: string, patch: SkeletonMapPatch): Record<string, unknown>;

package/build/mcp/tools/vibe_pm/mapping/skeleton_patch.js

@@ -0,0 +1,59 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/skeleton_patch.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+/**
+ * 파일의 SHA256 해시 계산
+ */
+function sha256File(absPath) {
+    if (!fs.existsSync(absPath))
+        return undefined;
+    const raw = fs.readFileSync(absPath);
+    return crypto.createHash("sha256").update(raw).digest("hex");
+}
+/**
+ * 상대 경로 계산 (workspace 밖이면 절대 경로 반환)
+ */
+function rel(root, abs) {
+    const r = path.relative(root, abs);
+    return r.startsWith("..") ? abs : r;
+}
+/**
+ * skeleton_map에 mapping ref 기록용 패치 생성
+ */
+export function buildSkeletonMapPatch(args) {
+    return {
+        version: "1.0",
+        run_id: args.run_id,
+        mapping: {
+            spec_map_ref: {
+                path: rel(args.workspaceRoot, args.specMapAbsPath),
+                sha256: sha256File(args.specMapAbsPath),
+            },
+            change_map_ref: {
+                path: rel(args.workspaceRoot, args.changeMapAbsPath),
+                sha256: sha256File(args.changeMapAbsPath),
+            },
+            summary: args.changeMap.summary,
+        },
+    };
+}
+/**
+ * 기존 skeleton_map 파일에 mapping 섹션 병합
+ */
+export function mergeSkeletonMapPatch(existingSkeletonPath, patch) {
+    let existing = {};
+    if (fs.existsSync(existingSkeletonPath)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(existingSkeletonPath, "utf-8"));
+        }
+        catch {
+            // 파싱 실패 시 빈 객체로 시작
+            existing = {};
+        }
+    }
+    return {
+        ...existing,
+        mapping: patch.mapping,
+    };
+}

package/build/mcp/tools/vibe_pm/mapping/spec_map.d.ts

@@ -0,0 +1,19 @@
+import { SpecMap, SpecOwner } from "./types.js";
+export declare function loadSpecMap(workspaceRoot: string): {
+    spec: SpecMap;
+    sha256: string;
+    absPath: string;
+};
+/**
+ * 간단한 glob prefix 매칭 (운영 안정성 우선)
+ * 실사용에서 glob이 필요하면 minimatch를 쓰되, 여기선 skeleton로 둔다.
+ */
+export declare function pathMatches(owner: SpecOwner, file: string): boolean;
+/**
+ * 키워드 매칭 스코어 (0~1)
+ */
+export declare function keywordScore(owner: SpecOwner, text: string): number;
+/**
+ * import 힌트 매칭 스코어 (0~1)
+ */
+export declare function importHintScore(owner: SpecOwner, importTargets: string[]): number;

package/build/mcp/tools/vibe_pm/mapping/spec_map.js

@@ -0,0 +1,43 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/spec_map.ts
+import fs from "fs";
+import crypto from "crypto";
+import { resolveSpecMapPath } from "../../../paths.js";
+export function loadSpecMap(workspaceRoot) {
+    // Preferred: `.vibe/config/spec_map.v1.json`, fallback: `.vibe/spec_map.v1.json`
+    const { absPath } = resolveSpecMapPath(workspaceRoot);
+    const raw = fs.readFileSync(absPath, "utf-8");
+    const sha256 = crypto.createHash("sha256").update(raw).digest("hex");
+    const spec = JSON.parse(raw);
+    return { spec, sha256, absPath };
+}
+/**
+ * 간단한 glob prefix 매칭 (운영 안정성 우선)
+ * 실사용에서 glob이 필요하면 minimatch를 쓰되, 여기선 skeleton로 둔다.
+ */
+export function pathMatches(owner, file) {
+    return owner.paths.some((p) => {
+        const prefix = p.replace("/**", "").replace("/*", "").replace("*", "");
+        return file.startsWith(prefix);
+    });
+}
+/**
+ * 키워드 매칭 스코어 (0~1)
+ */
+export function keywordScore(owner, text) {
+    if (!owner.keywords || owner.keywords.length === 0)
+        return 0;
+    const lower = text.toLowerCase();
+    const hits = owner.keywords.filter((k) => lower.includes(k.toLowerCase())).length;
+    // 거친 정규화: 키워드 3개 중 1개만 맞아도 0.33
+    return Math.min(1, hits / Math.max(3, owner.keywords.length / 3));
+}
+/**
+ * import 힌트 매칭 스코어 (0~1)
+ */
+export function importHintScore(owner, importTargets) {
+    if (!owner.import_hints || owner.import_hints.length === 0)
+        return 0;
+    const hints = owner.import_hints.map((h) => h.replace("from:", ""));
+    const hits = importTargets.filter((t) => hints.some((h) => t.includes(h))).length;
+    return Math.min(1, hits / Math.max(1, hints.length));
+}

package/build/mcp/tools/vibe_pm/mapping/types.d.ts

@@ -0,0 +1,126 @@
+export type Verdict = "GO" | "FIX" | "BLOCK";
+export type LayerId = "LAYER_ENTRY" | "LAYER_API" | "LAYER_SERVICE" | "LAYER_DOMAIN" | "LAYER_INFRA" | "LAYER_UI" | "LAYER_SHARED" | "LAYER_TEST";
+export type ViolationCode = "DENY_PATH_TOUCHED" | "BOUNDARY_CONFLICT" | "IMPORT_EDGE_DENIED" | "DUPLICATE_OWNER_SIGNAL" | "OWNER_AMBIGUOUS" | "UNMAPPED_CHANGE";
+export type Violation = {
+    code: ViolationCode;
+    severity: "FIX" | "BLOCK";
+    file: string;
+    detail: string;
+    evidence?: string[];
+};
+export type SpecOwner = {
+    id: string;
+    axis: {
+        domain: string;
+        layer: LayerId;
+    };
+    paths: string[];
+    keywords?: string[];
+    import_hints?: string[];
+    anchor_files?: string[];
+    notes?: string;
+};
+export type SpecMap = {
+    version: "1.0";
+    rules: {
+        match_order: Array<"path" | "keyword" | "import_hint">;
+        confidence_thresholds: {
+            mapped_min: number;
+            suggest_min: number;
+        };
+        unmapped_policy: {
+            default_verdict: "FIX" | "BLOCK";
+            upgrade_to_block_if: Array<"DENY_PATH_TOUCHED" | "BOUNDARY_CONFLICT">;
+        };
+    };
+    owners: SpecOwner[];
+    boundaries: {
+        deny_paths?: Array<{
+            path: string;
+            reason: string;
+        }>;
+        allowed_import_edges?: Array<{
+            from: string;
+            to: string;
+            reason: string;
+        }>;
+        denied_import_edges?: Array<{
+            from: string;
+            to: string;
+            reason: string;
+        }>;
+    };
+};
+export type ChangedFile = {
+    file: string;
+    status: "A" | "M" | "D" | "R";
+    addedLines: number;
+    deletedLines: number;
+    patch?: string;
+};
+export type ImportHint = {
+    file: string;
+    imports: string[];
+};
+export type ChangeMapMapped = {
+    file: string;
+    domain_id: string;
+    layer: LayerId;
+    owner_id: string;
+    confidence: number;
+    evidence: string[];
+};
+export type ChangeMapUnmapped = {
+    file: string;
+    reasons: string[];
+    suggested_owners: Array<{
+        owner_id: string;
+        domain_id: string;
+        layer: LayerId;
+        confidence: number;
+    }>;
+};
+export type ChangeMap = {
+    version: "1.0";
+    run_id: string;
+    base?: string;
+    head?: string;
+    generated_at: string;
+    mapped: ChangeMapMapped[];
+    unmapped: ChangeMapUnmapped[];
+    violations: Violation[];
+    summary: {
+        mapped_files: number;
+        unmapped_files: number;
+        domains_touched: string[];
+        layers_touched: LayerId[];
+    };
+};
+export type SkeletonMapPatch = {
+    version: "1.0";
+    run_id: string;
+    mapping: {
+        spec_map_ref: {
+            path: string;
+            sha256?: string;
+        };
+        change_map_ref: {
+            path: string;
+            sha256?: string;
+        };
+        summary: {
+            mapped_files: number;
+            unmapped_files: number;
+            domains_touched: string[];
+            layers_touched: LayerId[];
+        };
+    };
+};
+export type GateDecision = {
+    verdict: Verdict;
+    title: string;
+    summary: string;
+    evidence: Record<string, unknown>;
+    navigation: string[];
+    next_actions: string[];
+};

package/build/mcp/tools/vibe_pm/mapping/types.js

@@ -0,0 +1,2 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/types.ts
+export {};

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

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const MemoryInputSchema: z.ZodObject<{
+    mode: z.ZodEnum<["status", "sync", "retrieve"]>;
+    project_id: z.ZodOptional<z.ZodString>;
+    docs_root: z.ZodDefault<z.ZodString>;
+    force_full: z.ZodOptional<z.ZodBoolean>;
+    sync_mode: z.ZodOptional<z.ZodEnum<["on_demand", "pre_finalize"]>>;
+    query: z.ZodOptional<z.ZodString>;
+    max_chars: z.ZodOptional<z.ZodNumber>;
+    rerank_mode: z.ZodOptional<z.ZodEnum<["none", "rule_based", "hybrid"]>>;
+    rerank_file_patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rerank_heading_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rerank_semantic_weight: z.ZodOptional<z.ZodNumber>;
+    rerank_rule_weight: z.ZodOptional<z.ZodNumber>;
+    persist_dir: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    mode: "status" | "sync" | "retrieve";
+    docs_root: string;
+    project_id?: string | undefined;
+    persist_dir?: string | undefined;
+    force_full?: boolean | undefined;
+    query?: string | undefined;
+    max_chars?: number | undefined;
+    sync_mode?: "on_demand" | "pre_finalize" | undefined;
+    rerank_mode?: "none" | "rule_based" | "hybrid" | undefined;
+    rerank_file_patterns?: string[] | undefined;
+    rerank_heading_keywords?: string[] | undefined;
+    rerank_semantic_weight?: number | undefined;
+    rerank_rule_weight?: number | undefined;
+}, {
+    mode: "status" | "sync" | "retrieve";
+    project_id?: string | undefined;
+    docs_root?: string | undefined;
+    persist_dir?: string | undefined;
+    force_full?: boolean | undefined;
+    query?: string | undefined;
+    max_chars?: number | undefined;
+    sync_mode?: "on_demand" | "pre_finalize" | undefined;
+    rerank_mode?: "none" | "rule_based" | "hybrid" | undefined;
+    rerank_file_patterns?: string[] | undefined;
+    rerank_heading_keywords?: string[] | undefined;
+    rerank_semantic_weight?: number | undefined;
+    rerank_rule_weight?: number | undefined;
+}>;
+export type MemoryInput = z.infer<typeof MemoryInputSchema>;
+export type MemoryOutput = {
+    mode: "status" | "sync" | "retrieve";
+    result: unknown;
+};
+export declare function memory(args: {
+    workspaceRoot: string;
+    input: MemoryInput;
+}): Promise<MemoryOutput>;

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

@@ -0,0 +1,92 @@
+// vibe_pm.memory - Consolidated memory tool
+//
+// Combines memory_status, memory_sync, memory_retrieve into a single entry point.
+// Mode-based routing to reduce tool surface.
+//
+// Usage:
+//   vibe_pm.memory({ mode: "status" })
+//   vibe_pm.memory({ mode: "sync", force_full: true })
+//   vibe_pm.memory({ mode: "retrieve", query: "..." })
+import { z } from "zod";
+import { memoryStatus } from "./memory_status.js";
+import { memorySync } from "./memory_sync.js";
+import { memoryRetrieve } from "./memory_retrieve.js";
+import { MemoryStatusInputSchema } from "../../generated/memory_status_input.js";
+import { MemorySyncInputSchema } from "../../generated/memory_sync_input.js";
+import { MemoryRetrieveInputSchema } from "../../generated/memory_retrieve_input.js";
+// ============================================================================
+// Input Schema
+// ============================================================================
+export const MemoryInputSchema = z.object({
+    mode: z.enum(["status", "sync", "retrieve"]).describe("Operation mode: status (check index state), sync (build/update index), retrieve (query docs)"),
+    // Common fields
+    project_id: z.string().min(1).describe("Project ID (optional)").optional(),
+    docs_root: z.string().min(1).describe("Docs root directory (default: docs)").default("docs"),
+    // sync-specific fields
+    force_full: z.boolean().describe("Force full reindex (sync mode only)").optional(),
+    sync_mode: z.enum(["on_demand", "pre_finalize"]).describe("Sync hint (sync mode only)").optional(),
+    // retrieve-specific fields
+    query: z.string().min(1).describe("Search query (retrieve mode only)").optional(),
+    max_chars: z.number().int().gte(500).lte(20000).describe("Max context block length (retrieve mode only)").optional(),
+    // rerank fields (retrieve mode only)
+    rerank_mode: z.enum(["none", "rule_based", "hybrid"]).describe("Rerank mode: none (default), rule_based (pattern/keyword boost), hybrid (weighted combination)").optional(),
+    rerank_file_patterns: z.array(z.string()).describe("File glob patterns to boost (e.g., ['docs/DEV_SPEC/active/**'])").optional(),
+    rerank_heading_keywords: z.array(z.string()).describe("Heading keywords to boost").optional(),
+    rerank_semantic_weight: z.number().min(0).max(1).describe("Semantic score weight for hybrid mode (default: 0.8)").optional(),
+    rerank_rule_weight: z.number().min(0).max(1).describe("Rule score weight for hybrid mode (default: 0.2)").optional(),
+    // Legacy field (ignored, enforced to .vibe/cache/chroma)
+    persist_dir: z.string().min(1).describe("(Ignored) Persist dir override").optional(),
+}).strict().describe("Consolidated memory tool input");
+// ============================================================================
+// Handler
+// ============================================================================
+export async function memory(args) {
+    const { mode, project_id, docs_root, force_full, sync_mode, query, max_chars, persist_dir, rerank_mode, rerank_file_patterns, rerank_heading_keywords, rerank_semantic_weight, rerank_rule_weight, } = args.input;
+    switch (mode) {
+        case "status": {
+            const statusInput = MemoryStatusInputSchema.parse({
+                project_id,
+                docs_root,
+                persist_dir,
+            });
+            const result = await memoryStatus({ workspaceRoot: args.workspaceRoot, input: statusInput });
+            return { mode: "status", result };
+        }
+        case "sync": {
+            const syncInput = MemorySyncInputSchema.parse({
+                project_id,
+                docs_root,
+                mode: sync_mode ?? "on_demand",
+                force_full: force_full ?? false,
+            });
+            const result = await memorySync({ workspaceRoot: args.workspaceRoot, input: syncInput });
+            return { mode: "sync", result };
+        }
+        case "retrieve": {
+            if (!query) {
+                throw new Error("query is required for retrieve mode");
+            }
+            // Parse base input with generated schema
+            const baseInput = MemoryRetrieveInputSchema.parse({
+                project_id,
+                docs_root,
+                persist_dir,
+                query,
+                max_chars: max_chars ?? 6000,
+            });
+            // Extend with rerank options (not in generated schema)
+            const retrieveInput = {
+                ...baseInput,
+                rerank_mode,
+                rerank_file_patterns,
+                rerank_heading_keywords,
+                rerank_semantic_weight,
+                rerank_rule_weight,
+            };
+            const result = await memoryRetrieve({ workspaceRoot: args.workspaceRoot, input: retrieveInput });
+            return { mode: "retrieve", result };
+        }
+        default:
+            throw new Error(`Unknown mode: ${mode}`);
+    }
+}

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

@@ -0,0 +1,50 @@
+import { type MemoryIndexFileV1 } from "./memory_index.js";
+import { type HashVecIndexFileV1 } from "./memory_index_hashvec.js";
+import { type EmbeddingsIndexFileV1 } from "./memory_index_embeddings.js";
+export type MemoryBackendId = "local_tfidf" | "local_hashvec" | "local_embeddings" | "bitnet_embeddings";
+export type AnyMemoryIndex = MemoryIndexFileV1 | HashVecIndexFileV1 | EmbeddingsIndexFileV1;
+export declare function getMemoryBackendId(): MemoryBackendId;
+export declare function buildAndPersistMemoryIndex(args: {
+    workspaceRoot: string;
+    docsRoot: string;
+    docsFilesAbs: string[];
+    persistDir: string;
+}): Promise<{
+    backend: MemoryBackendId;
+    index: AnyMemoryIndex;
+    issues: string[];
+}>;
+export declare function loadMemoryIndexFromPersistDir(persistDir: string): Promise<AnyMemoryIndex | null>;
+export declare function queryMemoryIndex(args: {
+    index: AnyMemoryIndex;
+    query: string;
+    topK?: number;
+}): Array<{
+    score: number;
+    chunk: AnyMemoryIndex["chunks"][number];
+}>;
+export declare function getIndexFilePaths(persistDir: string): {
+    tfidf: string;
+    hashvec: string;
+    embeddings: string;
+};
+export declare function updateHashvecIndexBestEffort(args: {
+    workspaceRoot: string;
+    docsRoot: string;
+    persistDir: string;
+    changedFilesAbs: string[];
+    removedFileRels: string[];
+}): Promise<{
+    index: HashVecIndexFileV1 | null;
+    issues: string[];
+}>;
+export declare function updateEmbeddingsIndexBestEffort(args: {
+    workspaceRoot: string;
+    docsRoot: string;
+    persistDir: string;
+    changedFilesAbs: string[];
+    removedFileRels: string[];
+}): Promise<{
+    index: EmbeddingsIndexFileV1 | null;
+    issues: string[];
+}>;