@alaarab/cortex 1.13.6 → 1.15.0

package/mcp/dist/cli.js

@@ -21,7 +21,13 @@ import { handleHookPrompt, handleHookSessionStart, handleHookStop, handleHookCon
 import { handleExtractMemories } from "./cli-extract.js";
 import { handleGovernMemories, handlePruneMemories, handleConsolidateMemories, handleMigrateFindings, handleMaintain, handleBackgroundMaintenance, } from "./cli-govern.js";
 import { handleConfig, handleIndexPolicy, handleRetentionPolicy, handleWorkflowPolicy, handleAccessControl, } from "./cli-config.js";
-const cortexPath = ensureCortexPath();
+import { readInstallPreferences, writeInstallPreferences } from "./init-preferences.js";
+let _cortexPath;
+function getCortexPath() {
+    if (!_cortexPath)
+        _cortexPath = ensureCortexPath();
+    return _cortexPath;
+}
 const profile = process.env.CORTEX_PROFILE || "";
 // ── Search types and parsing ─────────────────────────────────────────────────
 const SEARCH_TYPE_ALIASES = {
@@ -42,7 +48,7 @@ const SEARCH_TYPES = new Set([
 // ── Search history ───────────────────────────────────────────────────────────
 const MAX_HISTORY = 20;
 function historyFile() {
-    return runtimeFile(cortexPath, "search-history.jsonl");
+    return runtimeFile(getCortexPath(), "search-history.jsonl");
 }
 function readSearchHistory() {
     const file = historyFile();
@@ -270,6 +276,10 @@ export async function runCliCommand(command, args) {
             return handleMaintain(args);
         case "skill-list":
             return handleSkillList();
+        case "skills":
+            return handleSkillsNamespace(args);
+        case "hooks":
+            return handleHooksNamespace(args);
         case "backlog":
             return handleBacklogView();
         case "quickstart":
@@ -294,13 +304,13 @@ async function handleSearch(opts) {
         return;
     }
     recordSearchQuery(opts);
-    const db = await buildIndex(cortexPath, profile);
+    const db = await buildIndex(getCortexPath(), profile);
     try {
         let sql = "SELECT project, filename, type, content, path FROM docs";
         const where = [];
         const params = [];
         if (opts.query) {
-            const safeQuery = buildRobustFtsQuery(opts.query);
+            const safeQuery = buildRobustFtsQuery(opts.query, opts.project);
             if (!safeQuery) {
                 console.error("Query empty after sanitization.");
                 process.exit(1);
@@ -334,7 +344,7 @@ async function handleSearch(opts) {
             if (opts.query) {
                 try {
                     const { logSearchMiss } = await import("./mcp-search.js");
-                    logSearchMiss(cortexPath, opts.query, opts.project);
+                    logSearchMiss(getCortexPath(), opts.query, opts.project);
                 }
                 catch { /* best-effort */ }
             }
@@ -371,7 +381,7 @@ async function handleAddFinding(project, learning) {
         process.exit(1);
     }
     try {
-        const result = addFindingCore(cortexPath, project, learning);
+        const result = addFindingCore(getCortexPath(), project, learning);
         if (!result.ok) {
             console.error(result.message);
             process.exit(1);
@@ -388,14 +398,14 @@ async function handlePinCanonical(project, memory) {
         console.error('Usage: cortex pin <project> "<memory>"');
         process.exit(1);
     }
-    const result = upsertCanonical(cortexPath, project, memory);
+    const result = upsertCanonical(getCortexPath(), project, memory);
     console.log(result.ok ? result.data : result.error);
 }
 async function handleDoctor(args) {
     const fix = args.includes("--fix");
     const checkData = args.includes("--check-data");
     const agentsOnly = args.includes("--agents");
-    const result = await runDoctor(cortexPath, fix, checkData);
+    const result = await runDoctor(getCortexPath(), fix, checkData);
     if (agentsOnly) {
         // Filter to only agent-related checks
         const agentChecks = result.checks.filter((c) => c.name.includes("cursor") || c.name.includes("copilot") || c.name.includes("codex") || c.name.includes("windsurf"));
@@ -418,7 +428,7 @@ async function handleDoctor(args) {
     }
     // Q30: Show top search miss patterns
     try {
-        const missFile = runtimeFile(cortexPath, "search-misses.jsonl");
+        const missFile = runtimeFile(getCortexPath(), "search-misses.jsonl");
         if (fs.existsSync(missFile)) {
             const lines = fs.readFileSync(missFile, "utf8").split("\n").filter(Boolean);
             if (lines.length > 0) {
@@ -455,15 +465,15 @@ async function handleQualityFeedback(args) {
         console.error("Usage: cortex quality-feedback --key=<entry-key> --type=helpful|reprompt|regression");
         process.exit(1);
     }
-    recordFeedback(cortexPath, key, feedback);
-    flushEntryScores(cortexPath);
+    recordFeedback(getCortexPath(), key, feedback);
+    flushEntryScores(getCortexPath());
     console.log(`Recorded feedback: ${feedback} for ${key}`);
 }
 async function handleMemoryUi(args) {
     const portArg = args.find((a) => a.startsWith("--port="));
     const port = portArg ? Number.parseInt(portArg.slice("--port=".length), 10) : 3499;
     const safePort = Number.isNaN(port) ? 3499 : port;
-    await startReviewUi(cortexPath, safePort);
+    await startReviewUi(getCortexPath(), safePort);
 }
 async function handleShell(args) {
     if (args.includes("--help") || args.includes("-h")) {
@@ -471,7 +481,7 @@ async function handleShell(args) {
         console.log("Interactive shell with views for Projects, Backlog, Learnings, Memory Queue, Machines/Profiles, and Health.");
         return;
     }
-    await startShell(cortexPath, profile);
+    await startShell(getCortexPath(), profile);
 }
 async function handleUpdate(args) {
     if (args.includes("--help") || args.includes("-h")) {
@@ -482,14 +492,149 @@ async function handleUpdate(args) {
     const result = await runCortexUpdate();
     console.log(result);
 }
+const HOOK_TOOLS = ["claude", "copilot", "cursor", "codex"];
+function printSkillsUsage() {
+    console.log("Usage:");
+    console.log("  cortex skills list");
+    console.log("  cortex skills add <project> <path>");
+    console.log("  cortex skills remove <project> <name>");
+}
+function printHooksUsage() {
+    console.log("Usage:");
+    console.log("  cortex hooks list");
+    console.log("  cortex hooks enable <tool>");
+    console.log("  cortex hooks disable <tool>");
+    console.log("  tools: claude|copilot|cursor|codex");
+}
+function normalizeHookTool(raw) {
+    if (!raw)
+        return null;
+    const tool = raw.toLowerCase();
+    return HOOK_TOOLS.includes(tool) ? tool : null;
+}
+function handleSkillsNamespace(args) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        printSkillsUsage();
+        return;
+    }
+    if (subcommand === "list") {
+        handleSkillList();
+        return;
+    }
+    if (subcommand === "add") {
+        const project = args[1];
+        const skillPath = args[2];
+        if (!project || !skillPath) {
+            printSkillsUsage();
+            process.exit(1);
+        }
+        if (!isValidProjectName(project)) {
+            console.error(`Invalid project name: "${project}"`);
+            process.exit(1);
+        }
+        const source = path.resolve(skillPath.replace(/^~/, os.homedir()));
+        if (!fs.existsSync(source) || !fs.statSync(source).isFile()) {
+            console.error(`Skill file not found: ${source}`);
+            process.exit(1);
+        }
+        const baseName = path.basename(source);
+        const fileName = baseName.toLowerCase().endsWith(".md") ? baseName : `${baseName}.md`;
+        const destDir = path.join(getCortexPath(), project, ".claude", "skills");
+        const dest = path.join(destDir, fileName);
+        fs.mkdirSync(destDir, { recursive: true });
+        if (fs.existsSync(dest)) {
+            console.error(`Skill already exists: ${dest}`);
+            process.exit(1);
+        }
+        try {
+            fs.symlinkSync(source, dest);
+            console.log(`Linked skill ${fileName} into ${project}.`);
+        }
+        catch {
+            fs.copyFileSync(source, dest);
+            console.log(`Copied skill ${fileName} into ${project}.`);
+        }
+        return;
+    }
+    if (subcommand === "remove") {
+        const project = args[1];
+        const name = args[2];
+        if (!project || !name) {
+            printSkillsUsage();
+            process.exit(1);
+        }
+        if (!isValidProjectName(project)) {
+            console.error(`Invalid project name: "${project}"`);
+            process.exit(1);
+        }
+        const dest = path.join(getCortexPath(), project, ".claude", "skills", `${name.replace(/\.md$/i, "")}.md`);
+        if (!fs.existsSync(dest)) {
+            console.error(`Skill not found: ${dest}`);
+            process.exit(1);
+        }
+        fs.unlinkSync(dest);
+        console.log(`Removed skill ${name.replace(/\.md$/i, "")}.md from ${project}.`);
+        return;
+    }
+    console.error(`Unknown skills subcommand: ${subcommand}`);
+    printSkillsUsage();
+    process.exit(1);
+}
+function handleHooksNamespace(args) {
+    const subcommand = args[0];
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        printHooksUsage();
+        return;
+    }
+    if (subcommand === "list") {
+        const prefs = readInstallPreferences(getCortexPath());
+        const hooksEnabled = prefs.hooksEnabled !== false;
+        const toolPrefs = prefs.hookTools && typeof prefs.hookTools === "object" ? prefs.hookTools : {};
+        const rows = HOOK_TOOLS.map((tool) => ({
+            tool,
+            hookType: "lifecycle",
+            status: hooksEnabled && toolPrefs[tool] !== false ? "enabled" : "disabled",
+        }));
+        console.log(`Tool      Hook Type  Status`);
+        console.log(`--------  ---------  --------`);
+        for (const row of rows) {
+            console.log(`${row.tool.padEnd(8)}  ${row.hookType.padEnd(9)}  ${row.status}`);
+        }
+        return;
+    }
+    if (subcommand === "enable" || subcommand === "disable") {
+        const tool = normalizeHookTool(args[1]);
+        if (!tool) {
+            printHooksUsage();
+            process.exit(1);
+        }
+        const prefs = readInstallPreferences(getCortexPath());
+        writeInstallPreferences(getCortexPath(), {
+            hookTools: {
+                ...(prefs.hookTools && typeof prefs.hookTools === "object" ? prefs.hookTools : {}),
+                [tool]: subcommand === "enable",
+            },
+        });
+        console.log(`${subcommand === "enable" ? "Enabled" : "Disabled"} hooks for ${tool}.`);
+        return;
+    }
+    console.error(`Unknown hooks subcommand: ${subcommand}`);
+    printHooksUsage();
+    process.exit(1);
+}
 function handleSkillList() {
     const sources = [];
+    const seenPaths = new Set();
     function collectSkills(root, sourceLabel) {
         if (!fs.existsSync(root))
             return;
         for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
             const entryPath = path.join(root, entry.name);
             if (entry.isFile() && entry.name.endsWith(".md")) {
+                if (seenPaths.has(entryPath))
+                    continue;
+                seenPaths.add(entryPath);
                 sources.push({
                     name: entry.name.replace(/\.md$/, ""),
                     source: sourceLabel,
@@ -502,6 +647,9 @@ function handleSkillList() {
                 const skillFile = path.join(entryPath, "SKILL.md");
                 if (!fs.existsSync(skillFile))
                     continue;
+                if (seenPaths.has(skillFile))
+                    continue;
+                seenPaths.add(skillFile);
                 sources.push({
                     name: entry.name,
                     source: sourceLabel,
@@ -511,15 +659,15 @@ function handleSkillList() {
             }
         }
     }
-    const globalSkillsDir = path.join(cortexPath, "global", "skills");
+    const globalSkillsDir = path.join(getCortexPath(), "global", "skills");
     collectSkills(globalSkillsDir, "global");
-    const projectDirs = getProjectDirs(cortexPath, profile);
+    const projectDirs = getProjectDirs(getCortexPath(), profile);
     for (const dir of projectDirs) {
         const projectName = path.basename(dir);
         if (projectName === "global")
             continue;
-        const projectSkillsDir = path.join(dir, "skills");
-        collectSkills(projectSkillsDir, projectName);
+        collectSkills(path.join(dir, "skills"), projectName);
+        collectSkills(path.join(dir, ".claude", "skills"), projectName);
     }
     if (!sources.length) {
         console.log("No skills found.");
@@ -543,7 +691,7 @@ function handleDetectSkills(args) {
         return;
     }
     const trackedSkills = new Set();
-    const globalSkillsDir = path.join(cortexPath, "global", "skills");
+    const globalSkillsDir = path.join(getCortexPath(), "global", "skills");
     if (fs.existsSync(globalSkillsDir)) {
         for (const entry of fs.readdirSync(globalSkillsDir)) {
             trackedSkills.add(entry.replace(/\.md$/, ""));
@@ -552,7 +700,7 @@ function handleDetectSkills(args) {
             }
         }
     }
-    const projectDirs = getProjectDirs(cortexPath, profile);
+    const projectDirs = getProjectDirs(getCortexPath(), profile);
     for (const dir of projectDirs) {
         const projectSkillsDir = path.join(dir, ".claude", "skills");
         if (!fs.existsSync(projectSkillsDir))
@@ -620,7 +768,7 @@ function handleDetectSkills(args) {
     console.log(`\nImported ${imported} skill(s). Run \`cortex link\` to activate.`);
 }
 function handleBacklogView() {
-    const docs = readBacklogs(cortexPath, profile);
+    const docs = readBacklogs(getCortexPath(), profile);
     if (!docs.length) {
         console.log("No backlogs found.");
         return;
@@ -670,8 +818,8 @@ async function handleQuickstart() {
     });
     console.log(`\nInitializing cortex for "${projectName}"...\n`);
     await runInit({ yes: true });
-    await runLink(cortexPath, {});
-    const projectDir = path.join(cortexPath, projectName);
+    await runLink(getCortexPath(), {});
+    const projectDir = path.join(getCortexPath(), projectName);
     if (!fs.existsSync(projectDir)) {
         fs.mkdirSync(projectDir, { recursive: true });
         fs.writeFileSync(path.join(projectDir, "FINDINGS.md"), `# ${projectName} Findings\n`);
@@ -722,7 +870,7 @@ async function handleDebugInjection(args) {
             input: payload,
             env: {
                 ...process.env,
-                CORTEX_PATH: cortexPath,
+                CORTEX_PATH: getCortexPath(),
                 CORTEX_PROFILE: profile,
             },
             timeout: EXEC_TIMEOUT_MS,
@@ -766,7 +914,7 @@ async function handleInspectIndex(args) {
             return;
         }
     }
-    const db = await buildIndex(cortexPath, profile);
+    const db = await buildIndex(getCortexPath(), profile);
     const where = [];
     const params = [];
     if (project) {

package/mcp/dist/data-access.js

@@ -2,55 +2,19 @@ import * as fs from "fs";
 import * as path from "path";
 import * as yaml from "js-yaml";
 import { appendAuditLog, cortexErr, CortexError, cortexOk, forwardErr, getProjectDirs, } from "./shared.js";
-import { checkPermission, getWorkflowPolicy, getRuntimeHealth, } from "./shared-governance.js";
+import { checkPermission, getWorkflowPolicy, getRuntimeHealth, withFileLock as withFileLockRaw, } from "./shared-governance.js";
 import { addFindingToFile, validateBacklogFormat, } from "./shared-content.js";
 import { isValidProjectName, queueFilePath, safeProjectPath } from "./utils.js";
 function withFileLock(filePath, fn) {
-    const lockPath = filePath + ".lock";
-    const maxWait = Number.parseInt(process.env.CORTEX_FILE_LOCK_MAX_WAIT_MS || "5000", 10) || 5000;
-    const pollInterval = Number.parseInt(process.env.CORTEX_FILE_LOCK_POLL_MS || "100", 10) || 100;
-    const staleThreshold = Number.parseInt(process.env.CORTEX_FILE_LOCK_STALE_MS || "30000", 10) || 30000;
-    const waiter = new Int32Array(new SharedArrayBuffer(4));
-    const sleep = (ms) => Atomics.wait(waiter, 0, 0, ms);
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    let waited = 0;
-    let hasLock = false;
-    while (waited < maxWait) {
-        try {
-            fs.writeFileSync(lockPath, `${process.pid}\n${Date.now()}`, { flag: "wx" });
-            hasLock = true;
-            break;
-        }
-        catch {
-            try {
-                const stat = fs.statSync(lockPath);
-                if (Date.now() - stat.mtimeMs > staleThreshold) {
-                    fs.unlinkSync(lockPath);
-                    continue;
-                }
-            }
-            catch {
-                sleep(pollInterval);
-                waited += pollInterval;
-                continue;
-            }
-            // Block this thread without spin-looping CPU while waiting to retry lock acquisition.
-            sleep(pollInterval);
-            waited += pollInterval;
-        }
-    }
-    if (!hasLock)
-        return cortexErr(`Could not acquire write lock for "${path.basename(filePath)}" within ${maxWait}ms. Another write may be in progress; please retry.`, CortexError.LOCK_TIMEOUT);
     try {
-        return fn();
+        return withFileLockRaw(filePath, fn);
     }
-    finally {
-        if (hasLock) {
-            try {
-                fs.unlinkSync(lockPath);
-            }
-            catch { /* lock may not exist */ }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("could not acquire lock")) {
+            return cortexErr(`Could not acquire write lock for "${path.basename(filePath)}". Another write may be in progress; please retry.`, CortexError.LOCK_TIMEOUT);
         }
+        throw err;
     }
 }
 const SHELL_STATE_VERSION = 1;

package/mcp/dist/index.js

@@ -1,6 +1,21 @@
 #!/usr/bin/env node
 import { parseMcpMode, runInit } from "./init.js";
 import * as os from "os";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { findCortexPathWithArg, debugLog, runtimeDir, } from "./shared.js";
+import { buildIndex, updateFileInIndex as updateFileInIndexFn } from "./shared-index.js";
+import { runCustomHooks } from "./hooks.js";
+import { register as registerSearch } from "./mcp-search.js";
+import { register as registerBacklog } from "./mcp-backlog.js";
+import { register as registerFinding } from "./mcp-finding.js";
+import { register as registerMemory } from "./mcp-memory.js";
+import { register as registerData } from "./mcp-data.js";
+import { register as registerGraph } from "./mcp-graph.js";
+import { register as registerSession } from "./mcp-session.js";
 if (process.argv[2] === "--help" || process.argv[2] === "-h" || process.argv[2] === "help") {
     console.log(`cortex - Long-term memory for Claude Code
 
@@ -10,6 +25,12 @@ Usage:
   cortex init [--machine <n>] [--profile <n>] [--mcp on|off] [--template <t>] [--from-existing <path>] [--dry-run] [-y]
                                          Set up cortex (templates: python-project, monorepo, library, frontend)
   cortex detect-skills [--import]        Find untracked skills in ~/.claude/skills/
+  cortex skills list                     List installed skills
+  cortex skills add <project> <path>    Link or copy a skill file into one project
+  cortex skills remove <project> <name> Remove a project skill by name
+  cortex hooks list                      Show hook tool preferences
+  cortex hooks enable <tool>             Enable hooks for one tool
+  cortex hooks disable <tool>            Disable hooks for one tool
   cortex status                          Health, active project, stats
   cortex search <query> [--project <n>] [--type <t>] [--limit <n>]
                                          Search your cortex
@@ -191,6 +212,8 @@ const CLI_COMMANDS = [
     "review-ui",
     "quality-feedback",
     "skill-list",
+    "skills",
+    "hooks",
     "detect-skills",
     "backlog",
     "quickstart",
@@ -218,21 +241,6 @@ if (CLI_COMMANDS.includes(process.argv[2])) {
     await runCliCommand(cmd, process.argv.slice(3));
     process.exit(0);
 }
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { findCortexPathWithArg, debugLog, runtimeDir, } from "./shared.js";
-import { buildIndex, updateFileInIndex as updateFileInIndexFn } from "./shared-index.js";
-import { runCustomHooks } from "./hooks.js";
-import { register as registerSearch } from "./mcp-search.js";
-import { register as registerBacklog } from "./mcp-backlog.js";
-import { register as registerFinding } from "./mcp-finding.js";
-import { register as registerMemory } from "./mcp-memory.js";
-import { register as registerData } from "./mcp-data.js";
-import { register as registerGraph } from "./mcp-graph.js";
-import { register as registerSession } from "./mcp-session.js";
 // MCP mode: first non-flag arg is the cortex path
 const cortexArg = process.argv.find((a, i) => i >= 2 && !a.startsWith("-"));
 const cortexPath = findCortexPathWithArg(cortexArg);

package/mcp/dist/link-skills.js

@@ -215,12 +215,6 @@ Cursor, Codex, and more.
 - \`import_project\`: import project from previously exported JSON
 - \`manage_project(project, action: "archive"|"unarchive")\`: archive or restore a project
 
-**Graph and session:**
-- \`get_learnings\`: alias for browsing findings/learnings
-- \`add_learning\`: alias for add_finding (backward compat)
-- \`add_learnings\`: alias for add_findings (backward compat)
-- \`remove_learning\`: alias for remove_finding (backward compat)
-- \`remove_learnings\`: alias for remove_findings (backward compat)
 `;
     const dest = path.join(cortexPath, "cortex.SKILL.md");
     fs.writeFileSync(dest, content);

package/mcp/dist/link.js

@@ -124,6 +124,18 @@ function currentPackageVersion() {
         return null;
     }
 }
+function readProjectConfig(cortexPath, project) {
+    const configPath = path.join(cortexPath, project, "cortex.project.yaml");
+    if (!fs.existsSync(configPath))
+        return {};
+    try {
+        const parsed = yaml.load(fs.readFileSync(configPath, "utf8"), { schema: yaml.CORE_SCHEMA });
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
 function maybeOfferStarterTemplateUpdate(cortexPath) {
     const current = currentPackageVersion();
     if (!current)
@@ -318,7 +330,8 @@ function linkProject(cortexPath, project, tools) {
     }
     // Project-level skills
     const projectSkills = path.join(cortexPath, project, ".claude", "skills");
-    if (fs.existsSync(projectSkills)) {
+    const config = readProjectConfig(cortexPath, project);
+    if (config.skills !== false && fs.existsSync(projectSkills)) {
         const targetSkills = path.join(target, ".claude", "skills");
         linkSkillsDir(projectSkills, targetSkills, cortexPath, symlinkFile);
     }

package/mcp/dist/mcp-finding.js

@@ -4,7 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { isValidProjectName, safeProjectPath } from "./utils.js";
 import { removeFinding as removeFindingCore, removeFindings as removeFindingsCore, } from "./core-finding.js";
-import { debugLog, EXEC_TIMEOUT_MS, } from "./shared.js";
+import { debugLog, EXEC_TIMEOUT_MS, FINDING_TYPES, } from "./shared.js";
 import { addFindingToFile, addFindingsToFile, checkSemanticDedup, checkSemanticConflicts, autoMergeConflicts, } from "./shared-content.js";
 import { runCustomHooks } from "./hooks.js";
 import { incrementSessionFindings } from "./mcp-session.js";
@@ -26,7 +26,7 @@ export function register(server, ctx) {
                 commit: z.string().optional().describe("Git commit SHA that supports this finding."),
                 supersedes: z.string().optional().describe("First 60 chars of the old finding this one replaces. The old entry will be marked as superseded."),
             }).optional().describe("Optional source citation for traceability."),
-            findingType: z.enum(["decision", "pitfall", "pattern"])
+            findingType: z.enum(FINDING_TYPES)
                 .optional()
                 .describe("Classify this finding: 'decision' (architectural choice with rationale), 'pitfall' (bug or gotcha to avoid), 'pattern' (reusable approach that works well)."),
         }),

package/mcp/dist/mcp-search.js

@@ -4,7 +4,7 @@ import * as fs from "fs";
 import { isValidProjectName, buildRobustFtsQuery } from "./utils.js";
 import { keywordFallbackSearch } from "./core-search.js";
 import { readFindings } from "./data-access.js";
-import { debugLog, runtimeFile, } from "./shared.js";
+import { debugLog, runtimeFile, DOC_TYPES, FINDING_TAGS, } from "./shared.js";
 import { queryRows, cosineFallback, queryEntityLinks, extractSnippet, queryDocBySourceKey, } from "./shared-index.js";
 import { runCustomHooks } from "./hooks.js";
 import { entryScoreKey, getQualityMultiplier } from "./shared-governance.js";
@@ -72,10 +72,10 @@ export function register(server, ctx) {
             query: z.string().describe("Search query (supports FTS5 syntax: AND, OR, NOT, phrase matching with quotes)"),
             limit: z.number().min(1).max(20).optional().describe("Max results to return (1-20, default 5)"),
             project: z.string().optional().describe("Filter by project name."),
-            type: z.enum(["claude", "findings", "reference", "skills", "summary", "backlog", "changelog", "canonical", "memory-queue", "skill", "other"])
+            type: z.enum(DOC_TYPES)
                 .optional()
                 .describe("Filter by document type: claude, findings, reference, summary, backlog, skill"),
-            tag: z.enum(["decision", "pitfall", "pattern", "tradeoff", "architecture", "bug"])
+            tag: z.enum(FINDING_TAGS)
                 .optional()
                 .describe("Filter findings by type tag (decision, pitfall, pattern are canonical; tradeoff, architecture, bug are legacy aliases)."),
             since: z.string().optional().describe('Filter findings by creation date. Formats: "7d" (last 7 days), "30d" (last 30 days), "YYYY-MM" (since start of month), "YYYY-MM-DD" (since date).'),
@@ -277,8 +277,8 @@ export function register(server, ctx) {
                         boost = 1.2;
                 }
                 catch { /* file may not exist on disk */ }
+                const scoreKey = entryScoreKey(rowProject, filename, content);
                 const snippet = extractSnippet(content, query);
-                const scoreKey = entryScoreKey(rowProject, filename, snippet);
                 boost *= getQualityMultiplier(cortexPath, scoreKey);
                 return { row, rank: (rows.length - idx) * boost };
             });