@coreyuan/vector-mind 1.0.17 → 1.0.20

package/dist/index.js

@@ -12,7 +12,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 const SERVER_NAME = "vector-mind";
-const SERVER_VERSION = "1.0.17";
+const SERVER_VERSION = "1.0.19";
 const rootFromEnv = process.env.VECTORMIND_ROOT?.trim() ?? "";
 const prettyJsonOutput = ["1", "true", "on", "yes"].includes((process.env.VECTORMIND_PRETTY_JSON ?? "").trim().toLowerCase());
 const debugLogEnabled = ["1", "true", "on", "yes"].includes((process.env.VECTORMIND_DEBUG_LOG ?? "").trim().toLowerCase());
@@ -61,6 +61,36 @@ const PENDING_PRUNE_EVERY = (() => {
         return 500;
     return n;
 })();
+const INDEX_MAX_CODE_BYTES = (() => {
+    const raw = process.env.VECTORMIND_INDEX_MAX_CODE_BYTES?.trim();
+    if (!raw)
+        return 400_000;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return 400_000;
+    return n;
+})();
+const INDEX_MAX_DOC_BYTES = (() => {
+    const raw = process.env.VECTORMIND_INDEX_MAX_DOC_BYTES?.trim();
+    if (!raw)
+        return 600_000;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return 600_000;
+    return n;
+})();
+const INDEX_SKIP_MINIFIED = (() => {
+    const raw = (process.env.VECTORMIND_INDEX_SKIP_MINIFIED ?? "").trim().toLowerCase();
+    if (!raw)
+        return true;
+    return ["1", "true", "on", "yes"].includes(raw);
+})();
+const INDEX_AUTO_PRUNE_IGNORED = (() => {
+    const raw = (process.env.VECTORMIND_INDEX_AUTO_PRUNE_IGNORED ?? "").trim().toLowerCase();
+    if (!raw)
+        return true;
+    return ["1", "true", "on", "yes"].includes(raw);
+})();
 const ROOTS_LIST_TIMEOUT_MS = (() => {
     const raw = process.env.VECTORMIND_ROOTS_TIMEOUT_MS?.trim();
     if (!raw)
@@ -99,6 +129,10 @@ let insertChangeLogStmt;
 let insertMemoryItemStmt;
 let getMemoryItemByIdStmt;
 let getRequirementMemoryItemIdStmt;
+let getConventionByKeyStmt;
+let insertConventionStmt;
+let updateConventionByIdStmt;
+let listConventionsStmt;
 let upsertProjectSummaryStmt;
 let getProjectSummaryStmt;
 let listRecentNotesStmt;
@@ -119,6 +153,37 @@ let searchSymbolsStmt;
 let indexFileSymbolsTx = null;
 let activitySeq = 0;
 const activityLog = [];
+function sanitizeForLog(value, depth = 0) {
+    if (depth > 4)
+        return "[max-depth]";
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string") {
+        return value.length > 500 ? `${value.slice(0, 500)}...` : value;
+    }
+    if (typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value)) {
+        const sliced = value.slice(0, 20).map((v) => sanitizeForLog(v, depth + 1));
+        return value.length > 20 ? [...sliced, `[+${value.length - 20} more]`] : sliced;
+    }
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).slice(0, 40);
+        const out = {};
+        for (const k of keys)
+            out[k] = sanitizeForLog(obj[k], depth + 1);
+        if (Object.keys(obj).length > 40)
+            out["__more_keys__"] = Object.keys(obj).length - 40;
+        return out;
+    }
+    try {
+        return String(value);
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
 function logActivity(type, data) {
     if (!debugLogEnabled)
         return;
@@ -127,7 +192,7 @@ function logActivity(type, data) {
         ts: new Date().toISOString(),
         type,
         project_root: projectRoot || "",
-        data,
+        data: sanitizeForLog(data),
     });
     while (activityLog.length > debugLogMaxEntries)
         activityLog.shift();
@@ -143,6 +208,37 @@ function clearActivityLog() {
     activityLog.length = 0;
     activitySeq = 0;
 }
+function summarizeActivityEvent(e) {
+    const d = e.data ?? {};
+    switch (e.type) {
+        case "index_file":
+            return `index ${String(d.file_path ?? "")} reason=${String(d.reason ?? "")} symbols=${String(d.symbols ?? "")} chunks=${String(d.chunks ?? "")}`;
+        case "remove_file":
+            return `remove ${String(d.file_path ?? "")}`;
+        case "pending_flush":
+            return `pending_flush entries=${String(d.entries ?? "")}`;
+        case "pending_prune":
+            return `pending_prune ${String(d.before ?? "")}->${String(d.after ?? "")}`;
+        case "bootstrap_context":
+            return `bootstrap q=${String(d.query ?? "")} pending=${String(d.pending_returned ?? "")}/${String(d.pending_total ?? "")} reqs=${String(d.requirements_returned ?? "")} semantic=${String(d.semantic_mode ?? "")}+${String(d.semantic_matches ?? "")}`;
+        case "get_brain_dump":
+            return `brain_dump pending=${String(d.pending_returned ?? "")}/${String(d.pending_total ?? "")} reqs=${String(d.requirements_returned ?? "")} notes=${String(d.notes_returned ?? "")}`;
+        case "get_pending_changes":
+            return `pending_list returned=${String(d.returned ?? "")} total=${String(d.total ?? "")}`;
+        case "semantic_search":
+            return `semantic_search mode=${String(d.mode ?? "")} q=${String(d.query ?? "")} matches=${String(d.matches ?? "")}`;
+        case "query_codebase":
+            return `query_codebase q=${String(d.query ?? "")} matches=${String(d.matches ?? "")}`;
+        case "start_requirement":
+            return `start_requirement #${String(d.req_id ?? "")} ${String(d.title ?? "")}`;
+        case "sync_change_intent":
+            return `sync_change_intent #${String(d.req_id ?? "")} files=${String(d.files_total ?? "")}`;
+        case "complete_requirement":
+            return `complete_requirement ${String(d.all_active ? "all_active" : d.req_id ?? "")}`;
+        default:
+            return e.type;
+    }
+}
 const FTS_TABLE_NAME = "memory_items_fts";
 let ftsAvailable = false;
 function isProbablyVscodeInstallDir(dir) {
@@ -340,6 +436,10 @@ const IGNORED_PATH_SEGMENTS = new Set([
     ".next",
     ".nuxt",
     ".svelte-kit",
+    ".turbo",
+    ".nx",
+    ".cache",
+    ".parcel-cache",
     // .NET / VS build artifacts
     "bin",
     "obj",
@@ -348,9 +448,11 @@ const IGNORED_PATH_SEGMENTS = new Set([
     // General build outputs
     "dist",
     "build",
+    "buildfiles",
     "out",
     "target",
     "coverage",
+    "artifacts",
     // Python caches/venvs
     "__pycache__",
     ".pytest_cache",
@@ -399,7 +501,9 @@ function pruneIgnoredPendingChanges() {
     try {
         if (!IGNORED_LIKE_PATTERNS.length)
             return;
-        const where = IGNORED_LIKE_PATTERNS.map(() => "LOWER(file_path) LIKE ?").join(" OR ");
+        const where = IGNORED_LIKE_PATTERNS
+            .map(() => "LOWER(REPLACE(file_path, '\\\\', '/')) LIKE ?")
+            .join(" OR ");
         db.prepare(`DELETE FROM pending_changes WHERE ${where}`).run(...IGNORED_LIKE_PATTERNS);
     }
     catch (err) {
@@ -432,6 +536,102 @@ function prunePendingChanges() {
         console.error("[vectormind] prune pending_changes failed:", err);
     }
 }
+function pruneIgnoredIndexesByPathPatterns() {
+    if (!db)
+        return { chunks_deleted: 0, symbols_deleted: 0 };
+    try {
+        if (!IGNORED_LIKE_PATTERNS.length)
+            return { chunks_deleted: 0, symbols_deleted: 0 };
+        const where = IGNORED_LIKE_PATTERNS
+            .map(() => "LOWER(REPLACE(file_path, '\\\\', '/')) LIKE ?")
+            .join(" OR ");
+        const chunksDeleted = db
+            .prepare(`DELETE FROM memory_items
+         WHERE file_path IS NOT NULL
+           AND (kind = 'code_chunk' OR kind = 'doc_chunk')
+           AND (${where})`)
+            .run(...IGNORED_LIKE_PATTERNS).changes;
+        const symbolsDeleted = db
+            .prepare(`DELETE FROM symbols
+         WHERE file_path IS NOT NULL
+           AND (${where})`)
+            .run(...IGNORED_LIKE_PATTERNS).changes;
+        if (chunksDeleted || symbolsDeleted) {
+            logActivity("index_prune", {
+                reason: "ignored_paths",
+                chunks_deleted: chunksDeleted,
+                symbols_deleted: symbolsDeleted,
+            });
+        }
+        return { chunks_deleted: chunksDeleted, symbols_deleted: symbolsDeleted };
+    }
+    catch (err) {
+        console.error("[vectormind] prune indexes failed:", err);
+        return { chunks_deleted: 0, symbols_deleted: 0 };
+    }
+}
+function pruneFilenameNoiseIndexes() {
+    if (!db)
+        return { chunks_deleted: 0, symbols_deleted: 0 };
+    const suffixes = [
+        ".min.js",
+        ".min.css",
+        ".bundle.js",
+        ".bundle.css",
+        ".chunk.js",
+        ".chunk.css",
+    ];
+    const baseNames = [
+        "package-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "bun.lockb",
+        "cargo.lock",
+        "composer.lock",
+    ];
+    try {
+        const suffixWhere = suffixes.map(() => "LOWER(file_path) LIKE ?").join(" OR ");
+        const baseWhere = baseNames.map(() => "LOWER(file_path) LIKE ?").join(" OR ");
+        const suffixArgs = suffixes.map((s) => `%${s}`);
+        const baseArgs = baseNames.map((n) => `%/${n}`);
+        const whereParts = [];
+        const args = [];
+        if (suffixWhere) {
+            whereParts.push(`(${suffixWhere})`);
+            args.push(...suffixArgs);
+        }
+        if (baseWhere) {
+            whereParts.push(`(${baseWhere})`);
+            args.push(...baseArgs);
+        }
+        if (!whereParts.length)
+            return { chunks_deleted: 0, symbols_deleted: 0 };
+        const where = whereParts.join(" OR ");
+        const chunksDeleted = db
+            .prepare(`DELETE FROM memory_items
+         WHERE file_path IS NOT NULL
+           AND (kind = 'code_chunk' OR kind = 'doc_chunk')
+           AND (${where})`)
+            .run(...args).changes;
+        const symbolsDeleted = db
+            .prepare(`DELETE FROM symbols
+         WHERE file_path IS NOT NULL
+           AND (${where})`)
+            .run(...args).changes;
+        if (chunksDeleted || symbolsDeleted) {
+            logActivity("index_prune", {
+                reason: "filename_noise",
+                chunks_deleted: chunksDeleted,
+                symbols_deleted: symbolsDeleted,
+            });
+        }
+        return { chunks_deleted: chunksDeleted, symbols_deleted: symbolsDeleted };
+    }
+    catch (err) {
+        console.error("[vectormind] prune filename noise failed:", err);
+        return { chunks_deleted: 0, symbols_deleted: 0 };
+    }
+}
 function shouldIgnorePath(inputPath) {
     const normalizedAbs = path.resolve(inputPath);
     const rel = path.relative(projectRoot, normalizedAbs);
@@ -449,6 +649,8 @@ function shouldIgnorePath(inputPath) {
     return false;
 }
 function isSymbolIndexableFile(filePath) {
+    if (shouldIgnoreContentFile(filePath))
+        return false;
     const ext = path.extname(filePath).toLowerCase();
     const allowed = new Set([
         ".ts",
@@ -485,6 +687,56 @@ function shouldIgnoreContentFile(filePath) {
         return true;
     if (base.endsWith(".min.js") || base.endsWith(".min.css"))
         return true;
+    if (base.endsWith(".bundle.js") || base.endsWith(".bundle.css"))
+        return true;
+    if (base.endsWith(".chunk.js") || base.endsWith(".chunk.css"))
+        return true;
+    return false;
+}
+function looksLikeGeneratedFile(content) {
+    const head = content.slice(0, 4000).toLowerCase();
+    if (head.includes("@generated"))
+        return true;
+    if (head.includes("do not edit") && (head.includes("generated") || head.includes("auto-generated"))) {
+        return true;
+    }
+    if (head.includes("this file was generated") && head.includes("do not edit"))
+        return true;
+    return false;
+}
+function looksLikeMinifiedBundle(content) {
+    if (content.length < 30_000)
+        return false;
+    let lines = 1;
+    let currentLen = 0;
+    let maxLineLen = 0;
+    let longLines = 0;
+    for (let i = 0; i < content.length; i++) {
+        const code = content.charCodeAt(i);
+        if (code === 10 /* \\n */) {
+            if (currentLen > maxLineLen)
+                maxLineLen = currentLen;
+            if (currentLen >= 800)
+                longLines += 1;
+            currentLen = 0;
+            lines += 1;
+            continue;
+        }
+        currentLen += 1;
+    }
+    if (currentLen > maxLineLen)
+        maxLineLen = currentLen;
+    if (currentLen >= 800)
+        longLines += 1;
+    const avgLineLen = content.length / Math.max(1, lines);
+    if (lines <= 2 && maxLineLen >= 2000)
+        return true;
+    if (maxLineLen >= 6000)
+        return true;
+    if (avgLineLen >= 900)
+        return true;
+    if (lines <= 10 && longLines >= Math.ceil(lines * 0.6))
+        return true;
     return false;
 }
 function getContentChunkKind(filePath) {
@@ -787,6 +1039,9 @@ function indexFile(absPath, reason) {
     const indexContent = isContentIndexableFile(absPath);
     if (!indexSymbols && !indexContent)
         return;
+    const kind = getContentChunkKind(absPath);
+    if (!kind)
+        return;
     let stat;
     try {
         stat = fs.statSync(absPath);
@@ -796,7 +1051,8 @@ function indexFile(absPath, reason) {
     }
     if (!stat.isFile())
         return;
-    if (stat.size > 1_000_000)
+    const maxBytes = kind === "code_chunk" ? INDEX_MAX_CODE_BYTES : INDEX_MAX_DOC_BYTES;
+    if (maxBytes > 0 && stat.size > maxBytes)
         return;
     let content;
     try {
@@ -807,7 +1063,19 @@ function indexFile(absPath, reason) {
     }
     if (content.includes("\u0000"))
         return;
+    const ext = path.extname(absPath).toLowerCase();
     const filePath = normalizeToDbPath(absPath);
+    if (INDEX_SKIP_MINIFIED &&
+        kind === "code_chunk" &&
+        (ext === ".js" || ext === ".mjs" || ext === ".cjs" || ext === ".css") &&
+        looksLikeMinifiedBundle(content)) {
+        logActivity("index_skip", { file_path: filePath, reason: "minified_bundle", bytes: stat.size });
+        return;
+    }
+    if (kind === "code_chunk" && stat.size >= 20_000 && looksLikeGeneratedFile(content)) {
+        logActivity("index_skip", { file_path: filePath, reason: "generated_file", bytes: stat.size });
+        return;
+    }
     let symbolCount = 0;
     let chunkCount = 0;
     if (indexSymbols) {
@@ -873,6 +1141,18 @@ const AddNoteArgsSchema = ProjectRootArgSchema.merge(z.object({
     content: z.string().min(1),
     tags: z.array(z.string().min(1)).optional(),
 }));
+const PruneIndexArgsSchema = ProjectRootArgSchema.merge(z.object({
+    dry_run: z.boolean().optional().default(true),
+    prune_ignored_paths: z.boolean().optional().default(true),
+    prune_minified_bundles: z.boolean().optional().default(false),
+    max_files: z.number().int().min(1).max(50_000).optional().default(2000),
+    vacuum: z.boolean().optional().default(false),
+}));
+const UpsertConventionArgsSchema = ProjectRootArgSchema.merge(z.object({
+    key: z.string().min(1),
+    content: z.string().min(1),
+    tags: z.array(z.string().min(1)).optional(),
+}));
 const DEFAULT_PENDING_LIMIT = 50;
 const MAX_PENDING_LIMIT = 2000;
 const PendingPagingSchema = z.object({
@@ -890,10 +1170,12 @@ const ContentMaxSchema = z.object({
 const DEFAULT_RECENT_REQUIREMENTS = 3;
 const DEFAULT_RECENT_CHANGES_PER_REQ = 5;
 const DEFAULT_RECENT_NOTES = 5;
+const DEFAULT_CONVENTIONS_LIMIT = 20;
 const BrainDumpLimitsSchema = z.object({
     requirements_limit: z.number().int().min(1).max(20).optional().default(DEFAULT_RECENT_REQUIREMENTS),
     changes_limit: z.number().int().min(1).max(100).optional().default(DEFAULT_RECENT_CHANGES_PER_REQ),
     notes_limit: z.number().int().min(0).max(50).optional().default(DEFAULT_RECENT_NOTES),
+    conventions_limit: z.number().int().min(0).max(200).optional().default(DEFAULT_CONVENTIONS_LIMIT),
 });
 const GetPendingChangesArgsSchema = ProjectRootArgSchema.merge(z.object({
     offset: z.number().int().min(0).optional().default(0),
@@ -905,7 +1187,12 @@ const CompleteRequirementArgsSchema = ProjectRootArgSchema.merge(z.object({
 }));
 const GetActivityLogArgsSchema = ProjectRootArgSchema.merge(z.object({
     since_id: z.number().int().min(0).optional().default(0),
-    limit: z.number().int().min(1).max(500).optional().default(50),
+    limit: z.number().int().min(1).max(500).optional().default(30),
+    verbose: z.boolean().optional().default(false),
+}));
+const GetActivitySummaryArgsSchema = ProjectRootArgSchema.merge(z.object({
+    since_id: z.number().int().min(0).optional().default(0),
+    max_files: z.number().int().min(0).max(200).optional().default(20),
 }));
 const ClearActivityLogArgsSchema = ProjectRootArgSchema;
 const GetBrainDumpArgsSchema = ProjectRootArgSchema.merge(PendingPagingSchema)
@@ -1415,6 +1702,7 @@ const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, {
         "- BEFORE editing code: call start_requirement(title, background) to set the active requirement.",
         "- AFTER editing + saving: call get_pending_changes() to see unsynced files, then call sync_change_intent(intent, files). (You can omit files to auto-link all pending changes.)",
         "- After major milestones/decisions: call upsert_project_summary(summary) and/or add_note(...) to persist durable context locally.",
+        "- If the user states a durable project convention (build commands, frameworks, naming rules, output paths): call upsert_convention(key, content, tags) so it is applied in future sessions.",
         "- When you need full text for a specific note/summary/match: call read_memory_item(id, offset, limit) and page through it.",
         "- When asked to locate code (class/function/type): call query_codebase(query) instead of guessing.",
         "- When you need to recall relevant context from history/code/docs: call semantic_search(query, ...) instead of guessing.",
@@ -1629,6 +1917,9 @@ function initDatabase() {
     CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_items_project_summary
       ON memory_items(kind) WHERE kind = 'project_summary';
 
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_items_convention_key
+      ON memory_items(kind, title) WHERE kind = 'convention';
+
     CREATE INDEX IF NOT EXISTS idx_memory_items_kind_updated_at
       ON memory_items(kind, updated_at DESC);
 
@@ -1688,12 +1979,27 @@ function initDatabase() {
      LIMIT ?`);
     insertChangeLogStmt = db.prepare(`INSERT INTO change_logs (req_id, file_path, intent_summary) VALUES (?, ?, ?)`);
     insertMemoryItemStmt = db.prepare(`INSERT INTO memory_items
-      (kind, title, content, file_path, start_line, end_line, req_id, metadata_json, content_hash)
+       (kind, title, content, file_path, start_line, end_line, req_id, metadata_json, content_hash)
      VALUES
-      (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+       (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     getMemoryItemByIdStmt = db.prepare(`SELECT id, kind, title, content, file_path, start_line, end_line, req_id, metadata_json, content_hash, created_at, updated_at
      FROM memory_items
      WHERE id = ?`);
+    getConventionByKeyStmt = db.prepare(`SELECT id, kind, title, content, file_path, start_line, end_line, req_id, metadata_json, content_hash, created_at, updated_at
+     FROM memory_items
+     WHERE kind = 'convention' AND title = ?
+     ORDER BY updated_at DESC, id DESC
+     LIMIT 1`);
+    insertConventionStmt = db.prepare(`INSERT INTO memory_items (kind, title, content, metadata_json, content_hash)
+     VALUES ('convention', ?, ?, ?, ?)`);
+    updateConventionByIdStmt = db.prepare(`UPDATE memory_items
+     SET content = ?, metadata_json = ?, content_hash = ?, updated_at = CURRENT_TIMESTAMP
+     WHERE id = ?`);
+    listConventionsStmt = db.prepare(`SELECT id, kind, title, content, file_path, start_line, end_line, req_id, metadata_json, content_hash, created_at, updated_at
+     FROM memory_items
+     WHERE kind = 'convention'
+     ORDER BY updated_at DESC, id DESC
+     LIMIT ?`);
     getRequirementMemoryItemIdStmt = db.prepare(`SELECT id
      FROM memory_items
      WHERE kind = 'requirement' AND req_id = ?
@@ -1773,6 +2079,13 @@ function initDatabase() {
     });
     // Clean up noisy pending changes recorded by older versions (build artifacts, node_modules, etc).
     prunePendingChanges();
+    // Clean up noisy indexes recorded by older versions (build artifacts, etc).
+    if (INDEX_AUTO_PRUNE_IGNORED) {
+        pruneIgnoredIndexesByPathPatterns();
+    }
+    // Clean up common "file name noise" recorded by older versions.
+    // (These files are ignored by current index rules; keep the DB consistent automatically.)
+    pruneFilenameNoiseIndexes();
 }
 function initWatcher() {
     watcherReady = false;
@@ -1942,6 +2255,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 description: "Get recent debug activity (indexing/search/pending) for troubleshooting. Enable logging with VECTORMIND_DEBUG_LOG=1. Use since_id/limit to page.",
                 inputSchema: toJsonSchemaCompat(GetActivityLogArgsSchema),
             },
+            {
+                name: "get_activity_summary",
+                description: "Get a compact summary of recent debug activity (counts + small samples). Enable logging with VECTORMIND_DEBUG_LOG=1. Use since_id to get incremental summaries.",
+                inputSchema: toJsonSchemaCompat(GetActivitySummaryArgsSchema),
+            },
             {
                 name: "clear_activity_log",
                 description: "Clear the in-memory debug activity log. Enable logging with VECTORMIND_DEBUG_LOG=1.",
@@ -1962,11 +2280,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 description: "Save a durable project note (decision, constraint, TODO, architecture detail). Use this to persist important context locally instead of relying on chat memory.",
                 inputSchema: toJsonSchemaCompat(AddNoteArgsSchema),
             },
+            {
+                name: "upsert_convention",
+                description: "Save/update a project convention (framework choice, build command, naming rules, etc). Conventions are durable and should be applied automatically in future sessions.",
+                inputSchema: toJsonSchemaCompat(UpsertConventionArgsSchema),
+            },
             {
                 name: "semantic_search",
                 description: "Semantic search across the local memory store (requirements, change intents, notes, project summary, and indexed code/doc chunks). Use this to retrieve relevant context instead of guessing.",
                 inputSchema: toJsonSchemaCompat(SemanticSearchArgsSchema),
             },
+            {
+                name: "prune_index",
+                description: "Prune noisy auto-indexed items (code_chunk/doc_chunk + symbols). Useful after tightening ignore rules to shrink the index and improve search relevance.",
+                inputSchema: toJsonSchemaCompat(PruneIndexArgsSchema),
+            },
         ],
     };
 });
@@ -2013,6 +2341,142 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        if (toolName === "prune_index") {
+            const args = PruneIndexArgsSchema.parse(rawArgs);
+            flushPendingChangeBuffer();
+            const result = {
+                ok: true,
+                dry_run: args.dry_run,
+                config: {
+                    index_max_code_bytes: INDEX_MAX_CODE_BYTES,
+                    index_max_doc_bytes: INDEX_MAX_DOC_BYTES,
+                    index_skip_minified: INDEX_SKIP_MINIFIED,
+                    index_auto_prune_ignored: INDEX_AUTO_PRUNE_IGNORED,
+                },
+                pruned: {
+                    ignored_paths: { chunks_deleted: 0, symbols_deleted: 0 },
+                    minified_bundles: { files_matched: 0, chunks_deleted: 0, symbols_deleted: 0 },
+                },
+            };
+            if (args.prune_ignored_paths) {
+                if (!IGNORED_LIKE_PATTERNS.length) {
+                    result.pruned.ignored_paths = { chunks_deleted: 0, symbols_deleted: 0 };
+                }
+                else if (args.dry_run) {
+                    const where = IGNORED_LIKE_PATTERNS
+                        .map(() => "LOWER(REPLACE(file_path, '\\\\', '/')) LIKE ?")
+                        .join(" OR ");
+                    const chunksWould = Number(db
+                        .prepare(`SELECT COUNT(1) AS c
+                   FROM memory_items
+                   WHERE file_path IS NOT NULL
+                     AND (kind = 'code_chunk' OR kind = 'doc_chunk')
+                     AND (${where})`)
+                        .get(...IGNORED_LIKE_PATTERNS)?.c ?? 0);
+                    const symbolsWould = Number(db
+                        .prepare(`SELECT COUNT(1) AS c
+                   FROM symbols
+                   WHERE file_path IS NOT NULL
+                     AND (${where})`)
+                        .get(...IGNORED_LIKE_PATTERNS)?.c ?? 0);
+                    result.pruned.ignored_paths = { chunks_deleted: chunksWould, symbols_deleted: symbolsWould };
+                }
+                else {
+                    result.pruned.ignored_paths = pruneIgnoredIndexesByPathPatterns();
+                }
+            }
+            if (args.prune_minified_bundles) {
+                const maxFiles = args.max_files;
+                const candidates = db
+                    .prepare(`SELECT file_path, content
+             FROM memory_items
+             WHERE kind = 'code_chunk'
+               AND file_path IS NOT NULL
+               AND (
+                 LOWER(file_path) LIKE '%.js'
+                 OR LOWER(file_path) LIKE '%.mjs'
+                 OR LOWER(file_path) LIKE '%.cjs'
+                 OR LOWER(file_path) LIKE '%.css'
+               )
+             ORDER BY updated_at DESC, id DESC
+             LIMIT ?`)
+                    .all(Math.min(50_000, maxFiles * 5));
+                const matched = new Set();
+                for (const row of candidates) {
+                    if (matched.size >= maxFiles)
+                        break;
+                    const fp = row.file_path;
+                    if (!fp || matched.has(fp))
+                        continue;
+                    if (looksLikeMinifiedBundle(row.content))
+                        matched.add(fp);
+                }
+                if (args.dry_run) {
+                    let chunksWould = 0;
+                    let symbolsWould = 0;
+                    const countChunksStmt = db.prepare(`SELECT COUNT(1) AS c
+             FROM memory_items
+             WHERE file_path = ?
+               AND (kind = 'code_chunk' OR kind = 'doc_chunk')`);
+                    const countSymbolsStmt = db.prepare(`SELECT COUNT(1) AS c FROM symbols WHERE file_path = ?`);
+                    for (const fp of matched) {
+                        chunksWould += Number(countChunksStmt.get(fp)?.c ?? 0);
+                        symbolsWould += Number(countSymbolsStmt.get(fp)?.c ?? 0);
+                    }
+                    result.pruned.minified_bundles = {
+                        files_matched: matched.size,
+                        chunks_deleted: chunksWould,
+                        symbols_deleted: symbolsWould,
+                    };
+                }
+                else {
+                    let chunksDeleted = 0;
+                    let symbolsDeleted = 0;
+                    const tx = db.transaction(() => {
+                        for (const fp of matched) {
+                            chunksDeleted += deleteFileChunkItemsStmt.run(fp).changes;
+                            symbolsDeleted += deleteSymbolsForFileStmt.run(fp).changes;
+                        }
+                    });
+                    try {
+                        tx();
+                    }
+                    catch (err) {
+                        console.error("[vectormind] prune minified bundles failed:", err);
+                    }
+                    if (matched.size) {
+                        logActivity("index_prune", {
+                            reason: "minified_bundles",
+                            files_matched: matched.size,
+                            chunks_deleted: chunksDeleted,
+                            symbols_deleted: symbolsDeleted,
+                        });
+                    }
+                    result.pruned.minified_bundles = {
+                        files_matched: matched.size,
+                        chunks_deleted: chunksDeleted,
+                        symbols_deleted: symbolsDeleted,
+                    };
+                }
+            }
+            if (!args.dry_run && args.vacuum) {
+                try {
+                    db.exec("VACUUM");
+                    logActivity("index_prune", { reason: "vacuum" });
+                }
+                catch (err) {
+                    console.error("[vectormind] vacuum failed:", err);
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: toolJson(result),
+                    },
+                ],
+            };
+        }
         if (toolName === "sync_change_intent") {
             const args = SyncChangeIntentArgsSchema.parse(rawArgs);
             flushPendingChangeBuffer();
@@ -2132,6 +2596,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const requirementsLimit = args.requirements_limit;
             const changesLimit = args.changes_limit;
             const notesLimit = args.notes_limit;
+            const conventionsLimit = args.conventions_limit;
             const recent = listRecentRequirementsStmt.all(requirementsLimit);
             const items = recent.map((req) => {
                 const changes = listChangeLogsForRequirementStmt.all(req.id, changesLimit);
@@ -2145,6 +2610,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ? toMemoryItemPreview(projectSummaryRow, includeContent, previewChars, contentMaxChars)
                 : null;
             const recent_notes = listRecentNotesStmt.all(notesLimit).map((n) => toMemoryItemPreview(n, includeContent, previewChars, contentMaxChars));
+            const conventions = listConventionsStmt.all(conventionsLimit).map((c) => toMemoryItemPreview(c, false, previewChars, contentMaxChars));
             const pending_total = Number(countPendingChangesStmt.get()?.total ?? 0);
             const pending_offset = args.pending_offset;
             const pending_limit = args.pending_limit;
@@ -2172,6 +2638,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 pending_total,
                 pending_returned: pending_changes.length,
                 requirements_returned: items.length,
+                conventions_returned: conventions.length,
                 semantic_mode: semantic?.mode ?? null,
                 semantic_matches: semantic?.matches?.length ?? 0,
             });
@@ -2199,8 +2666,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 requirements_limit: requirementsLimit,
                                 changes_limit: changesLimit,
                                 notes_limit: notesLimit,
+                                conventions_limit: conventionsLimit,
                             },
                             project_summary,
+                            conventions,
                             recent_notes,
                             pending_total,
                             pending_offset,
@@ -2223,6 +2692,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const requirementsLimit = args.requirements_limit;
             const changesLimit = args.changes_limit;
             const notesLimit = args.notes_limit;
+            const conventionsLimit = args.conventions_limit;
             const recent = listRecentRequirementsStmt.all(requirementsLimit);
             const items = recent.map((req) => {
                 const changes = listChangeLogsForRequirementStmt.all(req.id, changesLimit);
@@ -2236,6 +2706,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ? toMemoryItemPreview(projectSummaryRow, includeContent, previewChars, contentMaxChars)
                 : null;
             const recent_notes = listRecentNotesStmt.all(notesLimit).map((n) => toMemoryItemPreview(n, includeContent, previewChars, contentMaxChars));
+            const conventions = listConventionsStmt.all(conventionsLimit).map((c) => toMemoryItemPreview(c, false, previewChars, contentMaxChars));
             const pending_total = Number(countPendingChangesStmt.get()?.total ?? 0);
             const pending_offset = args.pending_offset;
             const pending_limit = args.pending_limit;
@@ -2246,6 +2717,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 pending_returned: pending_changes.length,
                 requirements_returned: items.length,
                 notes_returned: recent_notes.length,
+                conventions_returned: conventions.length,
             });
             return {
                 content: [
@@ -2271,8 +2743,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 requirements_limit: requirementsLimit,
                                 changes_limit: changesLimit,
                                 notes_limit: notesLimit,
+                                conventions_limit: conventionsLimit,
                             },
                             project_summary,
+                            conventions,
                             recent_notes,
                             pending_total,
                             pending_offset,
@@ -2384,6 +2858,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const args = GetActivityLogArgsSchema.parse(rawArgs);
             flushPendingChangeBuffer();
             const { events, last_id } = snapshotActivityLog({ sinceId: args.since_id, limit: args.limit });
+            const outEvents = args.verbose
+                ? events
+                : events.map((e) => ({ id: e.id, ts: e.ts, type: e.type, summary: summarizeActivityEvent(e) }));
             return {
                 content: [
                     {
@@ -2393,7 +2870,61 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             enabled: debugLogEnabled,
                             max_entries: debugLogMaxEntries,
                             last_id,
-                            events,
+                            events: outEvents,
+                        }),
+                    },
+                ],
+            };
+        }
+        if (toolName === "get_activity_summary") {
+            const args = GetActivitySummaryArgsSchema.parse(rawArgs);
+            flushPendingChangeBuffer();
+            const { events, last_id } = snapshotActivityLog({ sinceId: args.since_id, limit: 500 });
+            const counts = {};
+            const indexedFiles = new Set();
+            let semanticCount = 0;
+            let queryCodebaseCount = 0;
+            let pendingFlushes = 0;
+            let pendingPrunes = 0;
+            let lastSemantic = null;
+            let lastQueryCodebase = null;
+            for (const e of events) {
+                counts[e.type] = (counts[e.type] ?? 0) + 1;
+                if (e.type === "index_file") {
+                    const fp = String(e.data.file_path ?? "");
+                    if (fp)
+                        indexedFiles.add(fp);
+                }
+                if (e.type === "semantic_search") {
+                    semanticCount += 1;
+                    lastSemantic = e.data;
+                }
+                if (e.type === "query_codebase") {
+                    queryCodebaseCount += 1;
+                    lastQueryCodebase = e.data;
+                }
+                if (e.type === "pending_flush")
+                    pendingFlushes += 1;
+                if (e.type === "pending_prune")
+                    pendingPrunes += 1;
+            }
+            const sampleFiles = Array.from(indexedFiles).slice(0, args.max_files);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: toolJson({
+                            ok: true,
+                            enabled: debugLogEnabled,
+                            last_id,
+                            since_id: args.since_id,
+                            counts,
+                            indexed_files: { unique: indexedFiles.size, sample: sampleFiles },
+                            searches: {
+                                semantic_search: { count: semanticCount, last: lastSemantic },
+                                query_codebase: { count: queryCodebaseCount, last: lastQueryCodebase },
+                            },
+                            pending: { flushes: pendingFlushes, prunes: pendingPrunes },
                         }),
                     },
                 ],
@@ -2461,6 +2992,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ],
             };
         }
+        if (toolName === "upsert_convention") {
+            const args = UpsertConventionArgsSchema.parse(rawArgs);
+            const key = args.key.trim();
+            const content = args.content.trim();
+            const contentHash = sha256Hex(content);
+            const meta = safeJson({ tags: args.tags ?? [] });
+            const existing = getConventionByKeyStmt.get(key);
+            if (existing) {
+                updateConventionByIdStmt.run(content, meta, contentHash, existing.id);
+            }
+            else {
+                insertConventionStmt.run(key, content, meta, contentHash);
+            }
+            const row = getConventionByKeyStmt.get(key);
+            if (row)
+                enqueueEmbedding(row.id);
+            logActivity("upsert_convention", { key, content_preview: makePreviewText(content, 200) });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: toolJson({
+                            ok: true,
+                            convention: row
+                                ? {
+                                    id: row.id,
+                                    key: row.title,
+                                    updated_at: row.updated_at,
+                                    preview: makePreviewText(row.content, DEFAULT_PREVIEW_CHARS),
+                                }
+                                : null,
+                        }),
+                    },
+                ],
+            };
+        }
         if (toolName === "semantic_search") {
             const args = SemanticSearchArgsSchema.parse(rawArgs);
             const result = await semanticSearchHybridInternal({