memory-journal-mcp 6.3.0 → 7.0.0

package/dist/{chunk-QQ2ZY3CH.js → chunk-SBNQ7MXZ.js}

@@ -1,5 +1,5 @@
-import { setDefaultSandboxMode, getTools, callTool, sendProgress, execQuery, transformEntryRow, resolveGitHubRepo, isResourceError, milestoneCompletionPct, DEFAULT_BRIEFING_CONFIG } from './chunk-VH4SRTLB.js';
-import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-K2SCUSN4.js';
+import { withSessionInit, withPriority, ASSISTANT_FOCUSED, TOOL_GROUPS, HIGH_PRIORITY, LOW_PRIORITY, MEDIUM_PRIORITY, setDefaultSandboxMode, initializeAuditLogger, parseToolFilter, getFilterSummary, getToolFilterFromEnv, getTools, getEnabledGroups, callTool, getGlobalAuditLogger, sendProgress, SUPPORTED_SCOPES, getRequiredScope, hasScope, getAuditResourceDef, execQuery, transformEntryRow, resolveGitHubRepo, isResourceError, milestoneCompletionPct, parseScopes, BASE_SCOPES, getAllToolNames, globalMetrics, DEFAULT_BRIEFING_CONFIG } from './chunk-2BJHLTYP.js';
+import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-ARLH46WS.js';
 import { createRequire } from 'module';
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -17,216 +17,6 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { z } from 'zod';
 
-// src/filtering/tool-filter.ts
-var TOOL_GROUPS = {
-  core: [
-    "create_entry",
-    "get_entry_by_id",
-    "get_recent_entries",
-    "create_entry_minimal",
-    "test_simple",
-    "list_tags"
-  ],
-  search: ["search_entries", "search_by_date_range", "semantic_search", "get_vector_index_stats"],
-  analytics: ["get_statistics", "get_cross_project_insights"],
-  relationships: ["link_entries", "visualize_relationships"],
-  export: ["export_entries"],
-  admin: [
-    "update_entry",
-    "delete_entry",
-    "rebuild_vector_index",
-    "add_to_vector_index",
-    "merge_tags"
-  ],
-  github: [
-    "get_github_issues",
-    "get_github_prs",
-    "get_github_issue",
-    "get_github_pr",
-    "get_github_context",
-    "get_kanban_board",
-    "move_kanban_item",
-    "create_github_issue_with_entry",
-    "close_github_issue_with_entry",
-    "get_github_milestones",
-    "get_github_milestone",
-    "create_github_milestone",
-    "update_github_milestone",
-    "delete_github_milestone",
-    "get_repo_insights",
-    "get_copilot_reviews"
-  ],
-  backup: ["backup_journal", "list_backups", "restore_backup", "cleanup_backups"],
-  team: [
-    "team_create_entry",
-    "team_get_entry_by_id",
-    "team_get_recent",
-    "team_list_tags",
-    "team_search",
-    "team_search_by_date_range",
-    "team_update_entry",
-    "team_delete_entry",
-    "team_merge_tags",
-    "team_get_statistics",
-    "team_link_entries",
-    "team_visualize_relationships",
-    "team_export_entries",
-    "team_backup",
-    "team_list_backups",
-    "team_semantic_search",
-    "team_get_vector_index_stats",
-    "team_rebuild_vector_index",
-    "team_add_to_vector_index",
-    "team_get_cross_project_insights"
-  ],
-  codemode: ["mj_execute_code"]
-};
-var META_GROUPS = {
-  starter: ["core", "search", "codemode"],
-  essential: ["core", "codemode"],
-  full: [
-    "core",
-    "search",
-    "analytics",
-    "relationships",
-    "export",
-    "admin",
-    "github",
-    "backup",
-    "team",
-    "codemode"
-  ],
-  readonly: ["core", "search", "analytics", "relationships", "export"]
-};
-function getAllToolNames() {
-  const allTools = [];
-  for (const tools of Object.values(TOOL_GROUPS)) {
-    allTools.push(...tools);
-  }
-  return allTools;
-}
-function getToolGroup(toolName) {
-  for (const [group, tools] of Object.entries(TOOL_GROUPS)) {
-    if (tools.includes(toolName)) {
-      return group;
-    }
-  }
-  return void 0;
-}
-function getEnabledGroups(enabledTools) {
-  const groups = /* @__PURE__ */ new Set();
-  for (const [group, tools] of Object.entries(TOOL_GROUPS)) {
-    if (tools.some((t) => enabledTools.has(t))) {
-      groups.add(group);
-    }
-  }
-  return groups;
-}
-function isGroup(name) {
-  return name in TOOL_GROUPS;
-}
-function isMetaGroup(name) {
-  return name in META_GROUPS;
-}
-function parseToolFilter(filterString) {
-  const rules = [];
-  const parts = filterString.split(",").map((p) => p.trim()).filter(Boolean);
-  let enabledTools = /* @__PURE__ */ new Set();
-  let isWhitelistMode = false;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (!part) continue;
-    const isAdd = part.startsWith("+");
-    const isRemove = part.startsWith("-");
-    const name = isAdd || isRemove ? part.slice(1) : part;
-    if (i === 0 && !isAdd && !isRemove) {
-      isWhitelistMode = true;
-      if (isMetaGroup(name)) {
-        for (const group of META_GROUPS[name]) {
-          enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[group]]);
-        }
-      } else if (isGroup(name)) {
-        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[name]]);
-      } else {
-        enabledTools.add(name);
-      }
-      rules.push({
-        type: "include",
-        target: name,
-        isGroup: isGroup(name) || isMetaGroup(name)
-      });
-    } else if (isRemove) {
-      if (isGroup(name)) {
-        for (const tool of TOOL_GROUPS[name]) {
-          enabledTools.delete(tool);
-        }
-      } else {
-        enabledTools.delete(name);
-      }
-      rules.push({
-        type: "exclude",
-        target: name,
-        isGroup: isGroup(name)
-      });
-    } else {
-      if (isMetaGroup(name)) {
-        for (const group of META_GROUPS[name]) {
-          enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[group]]);
-        }
-      } else if (isGroup(name)) {
-        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[name]]);
-      } else {
-        enabledTools.add(name);
-      }
-      rules.push({
-        type: "include",
-        target: name,
-        isGroup: isGroup(name) || isMetaGroup(name)
-      });
-    }
-  }
-  if (!isWhitelistMode && rules.length > 0 && rules[0]?.type === "exclude") {
-    enabledTools = new Set(getAllToolNames());
-    for (const rule of rules) {
-      if (rule.type === "exclude") {
-        if (isGroup(rule.target)) {
-          for (const tool of TOOL_GROUPS[rule.target]) {
-            enabledTools.delete(tool);
-          }
-        } else {
-          enabledTools.delete(rule.target);
-        }
-      }
-    }
-  }
-  return {
-    raw: filterString,
-    rules,
-    enabledTools
-  };
-}
-function isToolEnabled(toolName, filterConfig) {
-  return filterConfig.enabledTools.has(toolName);
-}
-function filterTools(tools, filterConfig) {
-  return tools.filter((tool) => isToolEnabled(tool.name, filterConfig));
-}
-function getToolFilterFromEnv() {
-  const filterString = process.env["MEMORY_JOURNAL_MCP_TOOL_FILTER"];
-  if (!filterString) return null;
-  return parseToolFilter(filterString);
-}
-function calculateTokenSavings(totalTools, enabledTools, avgTokensPerTool = 150) {
-  const savedTokens = (totalTools - enabledTools) * avgTokensPerTool;
-  const reduction = (totalTools - enabledTools) / totalTools * 100;
-  return { reduction, savedTokens };
-}
-function getFilterSummary(filterConfig) {
-  const total = getAllToolNames().length;
-  const enabled = filterConfig.enabledTools.size;
-  const { reduction } = calculateTokenSavings(total, enabled);
-  return `${enabled}/${total} tools enabled (${reduction.toFixed(0)}% reduction)`;
-}
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var VERSION = pkg.version;
@@ -421,7 +211,11 @@ var NativeConnectionManager = class {
       }
     }
     db.prepare("UPDATE tags SET usage_count = 0 WHERE usage_count IS NULL").run();
-    const ftsCount = db.prepare("SELECT COUNT(*) as c FROM fts_content").get().c;
+    let ftsCount = 0;
+    try {
+      ftsCount = db.prepare("SELECT COUNT(*) as c FROM fts_content_docsize").get().c;
+    } catch {
+    }
     const entryCount = db.prepare("SELECT COUNT(*) as c FROM memory_journal").get().c;
     if (ftsCount === 0 && entryCount > 0) {
       db.exec("INSERT INTO fts_content(fts_content) VALUES ('rebuild')");
@@ -930,6 +724,12 @@ function buildSearchQuery(queryStr, options, useFts) {
             FROM memory_journal e
         `;
   }
+  if (options?.tags && options.tags.length > 0) {
+    query += `
+            JOIN entry_tags et ON e.id = et.entry_id
+            JOIN tags t ON et.tag_id = t.id
+        `;
+  }
   const params = [];
   const conditions = ["e.deleted_at IS NULL"];
   if (queryStr.length > 0) {
@@ -965,6 +765,27 @@ function buildSearchQuery(queryStr, options, useFts) {
     conditions.push(`e.workflow_run_id = ?`);
     params.push(options.workflowRunId);
   }
+  if (options?.tags && options.tags.length > 0) {
+    const placeholders = options.tags.map(() => "?").join(",");
+    conditions.push(`t.name IN (${placeholders})`);
+    params.push(...options.tags);
+  }
+  if (options?.entryType !== void 0) {
+    conditions.push(`e.entry_type = ?`);
+    params.push(options.entryType);
+  }
+  if (options?.startDate) {
+    let start = options.startDate;
+    if (!start.includes("T")) start += "T00:00:00.000Z";
+    conditions.push(`e.timestamp >= ?`);
+    params.push(start);
+  }
+  if (options?.endDate) {
+    let end = options.endDate;
+    if (!end.includes("T")) end += "T23:59:59.999Z";
+    conditions.push(`e.timestamp <= ?`);
+    params.push(end);
+  }
   if (conditions.length > 0) {
     query += ` WHERE ${conditions.join(" AND ")}`;
   }
@@ -1119,7 +940,7 @@ function getStatistics(context, groupBy = "week", startDate, endDate, projectBre
     const countRow = db.prepare(
       `SELECT COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL${dateFilter}`
     ).get(...dateParams);
-    totalEntries = countRow?.count ?? 0;
+    totalEntries = countRow.count;
     const typeRows = db.prepare(
       `SELECT entry_type, COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL${dateFilter} GROUP BY entry_type`
     ).all(...dateParams);
@@ -1128,7 +949,7 @@ function getStatistics(context, groupBy = "week", startDate, endDate, projectBre
     }
   } else {
     const countRow = db.prepare("SELECT COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL").get();
-    totalEntries = countRow?.count ?? 0;
+    totalEntries = countRow.count;
     const typeRows = db.prepare(
       `SELECT entry_type, COUNT(*) as count FROM memory_journal WHERE deleted_at IS NULL GROUP BY entry_type`
     ).all();
@@ -1165,7 +986,7 @@ function getStatistics(context, groupBy = "week", startDate, endDate, projectBre
         GROUP BY relationship_type
     `
   ).all();
-  const totalRelationships = relCountRow?.count ?? 0;
+  const totalRelationships = relCountRow.count;
   const avgPerEntry = totalEntries > 0 ? totalRelationships / totalEntries : 0;
   const currentPeriod = entriesByPeriod[0]?.period ?? "";
   const previousPeriod = entriesByPeriod[1]?.period ?? "";
@@ -1194,8 +1015,8 @@ function getStatistics(context, groupBy = "week", startDate, endDate, projectBre
   };
   if (startDate || endDate) {
     result["dateRange"] = {
-      startDate: startDate ?? "",
-      endDate: endDate ?? ""
+      startDate: startDate || "",
+      endDate: endDate || ""
     };
   }
   if (projectBreakdown) {
@@ -1315,6 +1136,7 @@ var BackupManager = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   async exportToFile(backupName) {
     const backupsDir = this.ctx.getBackupsDir();
     if (backupName) {
@@ -1407,9 +1229,7 @@ var BackupManager = class {
     await this.exportToFile(`pre_restore_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`);
     this.ctx.closeDbBeforeRestore();
     await fs2.promises.copyFile(backupPath, this.ctx.getDbPath());
-    const DatabaseAdapter3 = await import('better-sqlite3').then((m) => m.default);
-    const newDb = new DatabaseAdapter3(this.ctx.getDbPath());
-    this.ctx.setDbAndInitialized(newDb);
+    await this.ctx.initialize();
     const newCountResult = this.ctx.exec(
       "SELECT COUNT(*) FROM memory_journal WHERE deleted_at IS NULL"
     );
@@ -1598,9 +1418,16 @@ var VectorSearchManager = class {
     this.dbAdapter = dbAdapter;
     this.modelName = modelName;
   }
+  dbAdapter;
   // Use a more flexible type since FeatureExtractionPipeline doesn't fully implement Pipeline
   embedder = null;
-  db = null;
+  get db() {
+    try {
+      return this.dbAdapter.getRawDb();
+    } catch {
+      return null;
+    }
+  }
   modelName;
   initialized = false;
   initializing = false;
@@ -1625,7 +1452,6 @@ var VectorSearchManager = class {
         // Quantized int8 for faster inference and smaller model size
       });
       logger.info("Embedding model loaded", { module: "VectorSearch" });
-      this.db = this.dbAdapter.getRawDb();
       this.initialized = true;
       this.initializing = false;
       logger.info("Vector search initialized successfully", { module: "VectorSearch" });
@@ -1728,6 +1554,60 @@ var VectorSearchManager = class {
       return [];
     }
   }
+  /**
+   * Find entries related to a given entry by its existing embedding.
+   * Uses the stored embedding directly, skipping the re-embedding step.
+   *
+   * @param entryId - Entry ID whose embedding is used as the search vector
+   * @param limit - Max number of results
+   * @param similarityThreshold - Minimum similarity score
+   */
+  async searchByEntryId(entryId, limit = 10, similarityThreshold = 0.3) {
+    if (!this.initialized) {
+      try {
+        await this.initialize();
+      } catch {
+        return [];
+      }
+    }
+    if (!this.db) {
+      return [];
+    }
+    try {
+      const row = this.db.prepare("SELECT embedding FROM vec_embeddings WHERE entry_id = ?").get(BigInt(entryId));
+      if (!row) {
+        logger.debug("No embedding found for entry", {
+          module: "VectorSearch",
+          entityId: entryId
+        });
+        return [];
+      }
+      const queryVec = new Float32Array(
+        row.embedding.buffer,
+        row.embedding.byteOffset,
+        EMBEDDING_DIMENSIONS
+      );
+      const results = this.db.prepare(
+        `SELECT entry_id, distance
+                     FROM vec_embeddings
+                     WHERE embedding MATCH ?
+                     ORDER BY distance
+                     LIMIT ?`
+      ).all(queryVec, (limit + 1) * 2);
+      const filteredResults = results.filter((r) => r.entry_id !== entryId).map((r) => ({
+        entryId: r.entry_id,
+        score: 1 / (1 + r.distance)
+      })).filter((r) => r.score >= similarityThreshold).slice(0, limit);
+      return filteredResults;
+    } catch (error) {
+      logger.error("searchByEntryId failed", {
+        module: "VectorSearch",
+        entityId: entryId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
   /**
    * Remove an entry from the vector index
    */
@@ -1938,30 +1818,6 @@ var ICON_PROMPT = {
   sizes: ["24x24"]
 };
 
-// src/utils/resource-annotations.ts
-var HIGH_PRIORITY = {
-  priority: 0.9,
-  audience: ["user", "assistant"]
-};
-var MEDIUM_PRIORITY = {
-  priority: 0.6,
-  audience: ["user", "assistant"]
-};
-var LOW_PRIORITY = {
-  priority: 0.4,
-  audience: ["user", "assistant"]
-};
-var ASSISTANT_FOCUSED = {
-  priority: 0.5,
-  audience: ["assistant"]
-};
-function withPriority(priority, base = MEDIUM_PRIORITY) {
-  return { ...base, priority };
-}
-function withSessionInit(base = HIGH_PRIORITY) {
-  return { ...base, sessionInit: true };
-}
-
 // src/handlers/resources/core/briefing/github-section.ts
 async function buildGitHubSection(github, config) {
   if (!github) return null;
@@ -2012,7 +1868,10 @@ async function fetchCiStatus(github, owner, repo, config) {
     const runLimit = Math.max(1, config.workflowCount, config.workflowStatusBreakdown ? 10 : 1);
     const runs = await github.getWorkflowRuns(owner, repo, runLimit);
     if (runs.length === 0) return { status: "unknown" };
-    const latestRun = runs[0];
+    const primaryRun = runs.find(
+      (r) => r.status !== "completed" || ["success", "failure", "cancelled"].includes(r.conclusion ?? "")
+    ) ?? runs[0];
+    const latestRun = primaryRun;
     let status;
     if (!latestRun) {
       status = "unknown";
@@ -2377,7 +2236,7 @@ var briefingResource = {
   }
 };
 var dynamicBriefingResource = {
-  uri: "memory://briefing/{repo}",
+  uri: "memory://briefing/{+repo}",
   name: "Dynamic Briefing",
   title: "Project-Specific Session Context",
   description: "Project-specific briefing context for AI agents. Same as memory://briefing but targets a specific repository name from the registered workspaces.",
@@ -2465,32 +2324,37 @@ async function buildBriefingData(context, targetRepo) {
 // src/constants/server-instructions.ts
 var CORE_INSTRUCTIONS = `# memory-journal-mcp
 
-## Session Start
+## ESSENTIAL SESSION START!**
 
-**REQUIRED**: Before processing any user request, read \`memory://briefing/{repo_name}\` inferring \`repo_name\` strictly from the context of the user's prompt and present the \`userMessage\` to the user as a formatted bullet list of key facts, with all available fields, including:
+1. You **MUST** read the \`memory://briefing/{repo_name}\` at the start of each chat!
+2. Use the standard MCP \`read_resource\` tool for this (do NOT use Code Mode/execute_code).
+3. Infer the \`repo_name\` from the user's prompt or your active workspace context.
+4. Once read, present the \`userMessage\` from the briefing to the user as a formatted bullet list containing the key facts for all available fields including:
 
+- Project Name:
 - Entry counts (journal + team)
-- GitHub: repo, branch, CI status, open issues/PRs
+- Latest Entry (journal + team):
+- GitHub: repo, branch, CI status, open issues/PRs, insights
 - Milestone progress (if any)
 - Template resources count
 - Registered Workspaces (if available - provides automatic repo-to-project routing)
 - Optional metadata present (rulesFile, skillsDir, workflowSummary, copilotReviews, Team DB)
 
-**Server name for resource calls**: Derive from tool prefixes \u2014 strip the tool name suffix to get the server name.
-
 - **AntiGravity**: Tools are \`mcp_{name}_{tool}\` \u2192 server name = \`memory-journal-mcp\`
 - **Cursor**: Tools are \`user-{name}-{tool}\` \u2192 server name = \`user-memory-journal-mcp\`
 - **Other clients**: Use configured name exactly. Use tool-prefix discovery if unsure.
 
 ## Behaviors
 
+### memory-journal-mcp Behaviors
+
 - **Personal vs Team**: **ALWAYS use the personal journal** (e.g., \`create_entry\`) by default. ONLY save to the team journal (e.g., \`team_create_entry\`) if the user explicitly requests it.
 - **Create entries for**: implementations, decisions, bug fixes, milestones, user requests to "remember"
 - **Search before**: major decisions, referencing prior work, understanding project context
 - **Analyze insights**: Use cross-project insights (\`get_cross_project_insights\`) before defining architectures or cross-cutting abstractions. Use repo insights (\`memory://github/insights\`) to gauge traction.
 - **Link entries**: implementation\u2192spec, bugfix\u2192issue, followup\u2192prior work
 
-## Rule & Skill Suggestions
+### Rule & Skill Suggestions
 
 When you notice the user consistently applies patterns, preferences, or workflows that could be codified:
 
@@ -2556,18 +2420,65 @@ function buildQuickAccess(groups) {
   return table;
 }
 var CODE_MODE_NAMESPACE_ROWS = [
-  { group: "core", label: "Core", namespace: "`mj.core.*`", example: '`mj.core.createEntry("Implemented feature X")`' },
-  { group: "search", label: "Search", namespace: "`mj.search.*`", example: '`mj.search.searchEntries("performance")`' },
-  { group: "analytics", label: "Analytics", namespace: "`mj.analytics.*`", example: "`mj.analytics.getStatistics()`" },
-  { group: "relationships", label: "Relationships", namespace: "`mj.relationships.*`", example: '`mj.relationships.linkEntries(1, 2, "implements")`' },
-  { group: "export", label: "Export", namespace: "`mj.export.*`", example: '`mj.export.exportEntries("json")`' },
-  { group: "admin", label: "Admin", namespace: "`mj.admin.*`", example: "`mj.admin.rebuildVectorIndex()`" },
-  { group: "github", label: "GitHub", namespace: "`mj.github.*`", example: '`mj.github.getGithubIssues({ state: "open" })`' },
-  { group: "backup", label: "Backup", namespace: "`mj.backup.*`", example: "`mj.backup.backupJournal()`" },
-  { group: "team", label: "Team", namespace: "`mj.team.*`", example: '`mj.team.teamCreateEntry("Team update")`' }
+  {
+    group: "core",
+    label: "Core",
+    namespace: "`mj.core.*`",
+    example: '`mj.core.createEntry("Implemented feature X")`'
+  },
+  {
+    group: "search",
+    label: "Search",
+    namespace: "`mj.search.*`",
+    example: '`mj.search.searchEntries("performance")`'
+  },
+  {
+    group: "analytics",
+    label: "Analytics",
+    namespace: "`mj.analytics.*`",
+    example: "`mj.analytics.getStatistics()`"
+  },
+  {
+    group: "relationships",
+    label: "Relationships",
+    namespace: "`mj.relationships.*`",
+    example: '`mj.relationships.linkEntries(1, 2, "implements")`'
+  },
+  {
+    group: "export",
+    label: "Export",
+    namespace: "`mj.export.*`",
+    example: '`mj.export.exportEntries("json")`'
+  },
+  {
+    group: "admin",
+    label: "Admin",
+    namespace: "`mj.admin.*`",
+    example: "`mj.admin.rebuildVectorIndex()`"
+  },
+  {
+    group: "github",
+    label: "GitHub",
+    namespace: "`mj.github.*`",
+    example: '`mj.github.getGithubIssues({ state: "open" })`'
+  },
+  {
+    group: "backup",
+    label: "Backup",
+    namespace: "`mj.backup.*`",
+    example: "`mj.backup.backupJournal()`"
+  },
+  {
+    group: "team",
+    label: "Team",
+    namespace: "`mj.team.*`",
+    example: '`mj.team.teamCreateEntry("Team update")`'
+  }
 ];
 function buildCodeModeInstructions(groups) {
-  const rows = CODE_MODE_NAMESPACE_ROWS.filter((r) => groups.has(r.group)).map((r) => `| ${r.label.padEnd(13)} | ${r.namespace.padEnd(20)} | ${r.example.padEnd(50)} |`).join("\n");
+  const rows = CODE_MODE_NAMESPACE_ROWS.filter((r) => groups.has(r.group)).map(
+    (r) => `| ${r.label.padEnd(13)} | ${r.namespace.padEnd(20)} | ${r.example.padEnd(50)} |`
+  ).join("\n");
   const fullSection = CODE_MODE_FULL_TEXT;
   const tableStart = fullSection.indexOf("| Group");
   const tableEnd = fullSection.indexOf("\n\n**Features**");
@@ -2687,10 +2598,13 @@ var GOTCHAS_CONTENT = `# memory-journal-mcp \u2014 Field Notes & Gotchas
 ## Semantic Search
 
 - **Indexing**: Entries are auto-indexed on creation (fire-and-forget). If index count drifts from DB count, use \`rebuild_vector_index\` or enable \`AUTO_REBUILD_INDEX=true\` for automatic reconciliation on server startup.
+- **Related by ID**: Provide \`entry_id\` instead of a query string to find entries semantically related to an existing entry (reuses the existing embedding to avoid inference costs).
+- **Metadata Filters**: Semantic search supports explicit filtering by \`tags\`, \`entry_type\`, \`start_date\`, and \`end_date\`.
 - **Thresholds**: Default similarity threshold is 0.25. For broader matches, try 0.15-0.2. Higher values (0.4+) return only very close semantic matches. A quality floor of 0.5 is always enforced: if all results score below 0.5, a hint is included indicating results may be noise. The \`hint_on_empty\` flag (default true) only controls advisory hints for empty indexes and zero-match queries \u2014 the quality gate hint is always shown.
 
 ## Search
 
+- **Hybrid Ranking**: \`search_entries\` defaults to \`mode: 'auto'\`. Conversational prompts automatically utilize Reciprocal Rank Fusion (true Hybrid) bridging keyword and vector algorithms.
 - **\`search_entries\` FTS5 query syntax**: Uses FTS5 full-text search with Porter stemmer. Phrase queries: \`"error handling"\`. Prefix: \`auth*\`. Boolean: \`deploy OR release\`, \`error NOT warning\`. Word-boundary matching ("log" matches "log" but not "catalog"). Results ranked by BM25 relevance. Falls back to LIKE substring matching for queries with unbalanced quotes or special characters.
 
 ## Relationships & Analytics
@@ -2712,7 +2626,7 @@ var GOTCHAS_CONTENT = `# memory-journal-mcp \u2014 Field Notes & Gotchas
 
 - **Team cross-database search**: \`search_entries\` and \`search_by_date_range\` automatically merge team DB results when \`TEAM_DB_PATH\` is configured. Results include a \`source\` field ("personal" or "team").
 - **Team vector search**: Team has its own isolated vector index. Use \`team_rebuild_vector_index\` if the team index drifts. \`team_semantic_search\` works identically to personal \`semantic_search\`.
-- **Team tools without \`TEAM_DB_PATH\`**: All ${TOOL_GROUPS.team.length} team tools return \`{ success: false, error: "Team collaboration is not configured..." }\` \u2014 no crash, no partial results.
+- **Team tools without \`TEAM_DB_PATH\`**: All 20 team tools return \`{ success: false, error: "Team collaboration is not configured..." }\` \u2014 no crash, no partial results.
 `;
 function generateInstructions(enabledTools, prompts, latestEntry, level = "standard", enabledGroups) {
   const groups = enabledGroups ?? getEnabledGroups(enabledTools);
@@ -3472,6 +3386,19 @@ var healthResource = {
       filterString: context.filterConfig?.raw ?? null
     };
     const lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    const metricsSummary = (() => {
+      try {
+        const s = globalMetrics.getSummary();
+        return {
+          totalCalls: s.totalCalls,
+          totalErrors: s.totalErrors,
+          totalOutputTokens: s.totalOutputTokens,
+          upSince: s.upSince
+        };
+      } catch {
+        return null;
+      }
+    })();
     return {
       data: {
         ...dbHealth,
@@ -3482,6 +3409,7 @@ var healthResource = {
           ...context.teamDb.getHealthStatus()
         } : { configured: false },
         scheduler: context.scheduler ? context.scheduler.getStatus() : { active: false, jobs: [] },
+        metrics: metricsSummary,
         timestamp: lastModified
       },
       annotations: { lastModified }
@@ -3778,6 +3706,143 @@ var skillsResource = {
   }
 };
 
+// src/handlers/resources/core/metrics-resource.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var metricsSummaryResource = {
+  uri: "memory://metrics/summary",
+  name: "Metrics Summary",
+  title: "Tool Call Metrics Summary",
+  description: "Aggregate metrics across all tool calls since server start. Includes total calls, errors, duration, and token estimates.",
+  mimeType: "text/plain",
+  annotations: {
+    ...HIGH_PRIORITY,
+    audience: ["assistant"]
+  },
+  handler: (_uri, _ctx) => {
+    const lastModified = nowIso();
+    const s = globalMetrics.getSummary();
+    const errorRate = s.totalCalls > 0 ? (s.totalErrors / s.totalCalls * 100).toFixed(1) : "0.0";
+    const avgDuration = s.totalCalls > 0 ? Math.round(s.totalDurationMs / s.totalCalls) : 0;
+    const text = `metrics_summary:
+  up_since: ${s.upSince}
+  as_of: ${lastModified}
+  total_calls: ${s.totalCalls}
+  total_errors: ${s.totalErrors}
+  error_rate_pct: ${errorRate}
+  total_duration_ms: ${s.totalDurationMs}
+  avg_duration_ms: ${avgDuration}
+  total_input_tokens: ${s.totalInputTokens}
+  total_output_tokens: ${s.totalOutputTokens}
+  tools_called: ${Object.keys(s.toolBreakdown).length}
+`;
+    return { data: text, annotations: { lastModified } };
+  }
+};
+var metricsTokensResource = {
+  uri: "memory://metrics/tokens",
+  name: "Metrics Tokens",
+  title: "Token Usage Breakdown by Tool",
+  description: "Per-tool token usage breakdown sorted by total output tokens. Use this to identify which tools are consuming the most context window.",
+  mimeType: "text/plain",
+  annotations: {
+    ...MEDIUM_PRIORITY,
+    audience: ["assistant"]
+  },
+  handler: (_uri, _ctx) => {
+    const lastModified = nowIso();
+    const breakdown = globalMetrics.getTokenBreakdown();
+    if (breakdown.length === 0) {
+      return {
+        data: `token_breakdown:
+  note: No tool calls recorded yet.
+  as_of: ${lastModified}
+`,
+        annotations: { lastModified }
+      };
+    }
+    const rows = breakdown.map(
+      (t) => `  - tool: ${t.toolName}
+    calls: ${t.callCount}
+    input_tokens: ${t.inputTokens}
+    output_tokens: ${t.outputTokens}
+    avg_output_tokens: ${t.avgOutputTokens}`
+    ).join("\n");
+    const text = `token_breakdown:
+  as_of: ${lastModified}
+${rows}
+`;
+    return { data: text, annotations: { lastModified } };
+  }
+};
+var metricsSystemResource = {
+  uri: "memory://metrics/system",
+  name: "Metrics System",
+  title: "System Metrics",
+  description: "Process-level system metrics: memory usage, uptime, Node.js version, and platform.",
+  mimeType: "text/plain",
+  annotations: {
+    ...MEDIUM_PRIORITY,
+    audience: ["assistant"]
+  },
+  handler: (_uri, _ctx) => {
+    const lastModified = nowIso();
+    const sys = globalMetrics.getSystemMetrics();
+    const text = `system_metrics:
+  up_since: ${sys.upSince}
+  uptime_seconds: ${sys.uptimeSeconds}
+  process_memory_mb: ${sys.processMemoryMb}
+  node_version: ${sys.nodeVersion}
+  platform: ${sys.platform}
+  as_of: ${lastModified}
+`;
+    return { data: text, annotations: { lastModified } };
+  }
+};
+var metricsUsersResource = {
+  uri: "memory://metrics/users",
+  name: "Metrics Users",
+  title: "Per-User Call Counts",
+  description: "Per-user tool call counts. Populated when user identifiers are provided via OAuth or request metadata. Returns empty breakdown when no user tracking configured.",
+  mimeType: "text/plain",
+  annotations: {
+    ...LOW_PRIORITY,
+    audience: ["assistant"]
+  },
+  handler: (_uri, _ctx) => {
+    const lastModified = nowIso();
+    const userBreakdown = globalMetrics.getUserBreakdown();
+    const users = Object.entries(userBreakdown);
+    if (users.length === 0) {
+      return {
+        data: `user_metrics:
+  note: No user tracking data available.
+  hint: User tracking activates when OAuth user identifiers are present.
+  as_of: ${lastModified}
+`,
+        annotations: { lastModified }
+      };
+    }
+    const sorted = users.sort(([, a], [, b]) => b - a);
+    const rows = sorted.map(([user, count]) => `  - user: ${user}
+    calls: ${count}`).join("\n");
+    const text = `user_metrics:
+  as_of: ${lastModified}
+${rows}
+`;
+    return { data: text, annotations: { lastModified } };
+  }
+};
+function getMetricsResourceDefinitions() {
+  return [
+    metricsSummaryResource,
+    metricsTokensResource,
+    metricsSystemResource,
+    metricsUsersResource
+  ];
+}
+
 // src/handlers/resources/core/index.ts
 function getCoreResourceDefinitions() {
   return [
@@ -3791,7 +3856,8 @@ function getCoreResourceDefinitions() {
     rulesResource,
     workflowsResource,
     skillsResource,
-    healthResource
+    healthResource,
+    ...getMetricsResourceDefinitions()
   ];
 }
 
@@ -3872,11 +3938,11 @@ function getGraphResourceDefinitions() {
       annotations: MEDIUM_PRIORITY,
       handler: async (_uri, context) => {
         if (!context.github) {
-          return 'graph LR\n  NoGitHub["GitHub integration not available \u2014 set GITHUB_TOKEN and GITHUB_REPO_PATH"]';
+          return 'graph LR\n  NoGitHub["GitHub integration not available \u2014 set GITHUB_TOKEN"]';
         }
         const repoInfo = await context.github.getRepoInfo();
         if (!repoInfo.owner || !repoInfo.repo) {
-          return 'graph LR\n  NoRepo["Repository not detected \u2014 set GITHUB_REPO_PATH in your config"]';
+          return 'graph LR\n  NoRepo["Repository not detected \u2014 run in valid git repo or configure PROJECT_REGISTRY"]';
         }
         const workflowRuns = await context.github.getWorkflowRuns(
           repoInfo.owner,
@@ -3984,7 +4050,11 @@ function getGitHubResourceDefinitions() {
       handler: async (uri, context) => {
         const match = /memory:\/\/github\/status\/?(.*)?/.exec(uri);
         const targetRepo = match?.[1] ? decodeURIComponent(match[1]) : void 0;
-        const resolved = await resolveGitHubRepo(context.github, context.briefingConfig, targetRepo);
+        const resolved = await resolveGitHubRepo(
+          context.github,
+          context.briefingConfig,
+          targetRepo
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, branch, lastModified, github } = resolved;
         const defaultProjectNumber = context.briefingConfig?.defaultProjectNumber;
@@ -4121,7 +4191,11 @@ function getGitHubResourceDefinitions() {
       handler: async (uri, context) => {
         const match = /memory:\/\/github\/insights\/?(.*)?/.exec(uri);
         const targetRepo = match?.[1] ? decodeURIComponent(match[1]) : void 0;
-        const resolved = await resolveGitHubRepo(context.github, context.briefingConfig, targetRepo);
+        const resolved = await resolveGitHubRepo(
+          context.github,
+          context.briefingConfig,
+          targetRepo
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, lastModified, github } = resolved;
         const stats = await github.getRepoStats(owner, repo);
@@ -4161,7 +4235,11 @@ function getGitHubResourceDefinitions() {
       handler: async (uri, context) => {
         const match = /memory:\/\/github\/milestones\/?(.*)?/.exec(uri);
         const targetRepo = match?.[1] ? decodeURIComponent(match[1]) : void 0;
-        const resolved = await resolveGitHubRepo(context.github, context.briefingConfig, targetRepo);
+        const resolved = await resolveGitHubRepo(
+          context.github,
+          context.briefingConfig,
+          targetRepo
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, lastModified, github } = resolved;
         const milestones = await github.getMilestones(
@@ -4207,7 +4285,11 @@ function getGitHubResourceDefinitions() {
             annotations: { lastModified }
           };
         }
-        const resolved = await resolveGitHubRepo(context.github, context.briefingConfig, targetRepo);
+        const resolved = await resolveGitHubRepo(
+          context.github,
+          context.briefingConfig,
+          targetRepo
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, github } = resolved;
         const milestone = await github.getMilestone(owner, repo, milestoneNumber);
@@ -4236,9 +4318,9 @@ function getGitHubResourceDefinitions() {
     const dynamicName = def.name + " (Dynamic)";
     let dynamicUri;
     if (def.uri === "memory://milestones/{number}") {
-      dynamicUri = "memory://milestones/{repo}/{number}";
+      dynamicUri = "memory://milestones/{+repo}/{number}";
     } else {
-      dynamicUri = def.uri + "/{repo}";
+      dynamicUri = def.uri + "/{+repo}";
     }
     return {
       ...def,
@@ -4433,7 +4515,7 @@ function getTemplateResourceDefinitions() {
         if (!context.github) {
           return {
             error: "GitHub integration not available",
-            hint: "Set GITHUB_TOKEN and GITHUB_REPO_PATH environment variables."
+            hint: "Set GITHUB_TOKEN environment variable."
           };
         }
         const repoInfo = await context.github.getRepoInfo();
@@ -4442,7 +4524,7 @@ function getTemplateResourceDefinitions() {
         if (!owner) {
           return {
             error: "Could not detect repository owner",
-            hint: "Set GITHUB_REPO_PATH to your git repository."
+            hint: "Run the MCP server from a valid git repository or configure PROJECT_REGISTRY."
           };
         }
         const board = await context.github.getProjectKanban(owner, projectNumber, repo);
@@ -4812,7 +4894,7 @@ function getHelpResourceDefinitions() {
 var toolIndexModule = null;
 async function getAllToolDefinitionsAsync(context) {
   try {
-    toolIndexModule ??= await import('./tools-P4XXHO3Z.js');
+    toolIndexModule ??= await import('./tools-FFFGXIKN.js');
     if (toolIndexModule === null) return [];
     const tools = toolIndexModule.getTools(context.db, null);
     return tools.map((t) => ({
@@ -4933,9 +5015,13 @@ async function readResource(uri, db, vectorManager, filterConfig, github, schedu
   }
   for (const resource of resources) {
     if (resource.uri.includes("{")) {
-      const pattern = resource.uri.replace(/\{([^}]+)\}/g, (_match, paramName) => {
-        return paramName === "repo" ? "(.+)" : "([^/]+)";
-      });
+      const pattern = resource.uri.replace(
+        /\{([^}]+)\}/g,
+        (_match, paramName) => {
+          const cleanParam = paramName.startsWith("+") ? paramName.slice(1) : paramName;
+          return cleanParam === "repo" ? "(.+)" : "([^/]+)";
+        }
+      );
       const regex = new RegExp(`^${pattern}$`);
       if (regex.test(baseUri)) {
         const result = await Promise.resolve(resource.handler(uri, context));
@@ -4955,7 +5041,9 @@ function getAllResourceDefinitions() {
     ...getGitHubResourceDefinitions(),
     ...getTemplateResourceDefinitions(),
     ...getTeamResourceDefinitions(),
-    ...getHelpResourceDefinitions()
+    ...getHelpResourceDefinitions(),
+    // Audit resource — bound to the global audit logger (or null if unconfigured)
+    getAuditResourceDef(getGlobalAuditLogger)
   ];
 }
 
@@ -5367,81 +5455,6 @@ var JwksFetchError = class extends OAuthError {
 function isOAuthError(error) {
   return error instanceof OAuthError;
 }
-
-// src/auth/scopes.ts
-var SCOPES = {
-  /** Read-only access */
-  READ: "read",
-  /** Read and write access */
-  WRITE: "write",
-  /** Administrative access */
-  ADMIN: "admin",
-  /** Unrestricted access to all operations */
-  FULL: "full"
-};
-var BASE_SCOPES = ["read", "write", "admin", "full"];
-var SUPPORTED_SCOPES = ["read", "write", "admin", "full"];
-var TOOL_GROUP_SCOPES = {
-  core: SCOPES.READ,
-  search: SCOPES.READ,
-  analytics: SCOPES.READ,
-  relationships: SCOPES.READ,
-  export: SCOPES.READ,
-  admin: SCOPES.ADMIN,
-  github: SCOPES.WRITE,
-  backup: SCOPES.ADMIN,
-  team: SCOPES.WRITE,
-  codemode: SCOPES.ADMIN
-};
-var groupsForScope = (maxScope) => {
-  const hierarchy = {
-    read: 0,
-    write: 1,
-    admin: 2,
-    full: 3
-  };
-  const maxLevel = hierarchy[maxScope];
-  return Object.entries(TOOL_GROUP_SCOPES).filter(([, scope]) => hierarchy[scope] <= maxLevel).map(([group]) => group);
-};
-groupsForScope(SCOPES.READ);
-groupsForScope(SCOPES.WRITE);
-groupsForScope(SCOPES.ADMIN);
-function parseScopes(scopeString) {
-  return scopeString.split(/\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function hasScope(grantedScopes, requiredScope) {
-  if (grantedScopes.includes(SCOPES.FULL)) {
-    return true;
-  }
-  if (grantedScopes.includes(requiredScope)) {
-    return true;
-  }
-  if (requiredScope === SCOPES.READ || requiredScope === SCOPES.WRITE) {
-    if (grantedScopes.includes(SCOPES.ADMIN)) {
-      return true;
-    }
-  }
-  if (requiredScope === SCOPES.READ) {
-    if (grantedScopes.includes(SCOPES.WRITE)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/auth/scope-map.ts
-var toolScopeMap = /* @__PURE__ */ new Map();
-for (const [group, tools] of Object.entries(TOOL_GROUPS)) {
-  const scope = TOOL_GROUP_SCOPES[group];
-  if (scope) {
-    for (const toolName of tools) {
-      toolScopeMap.set(toolName, scope);
-    }
-  }
-}
-function getRequiredScope(toolName) {
-  return toolScopeMap.get(toolName) ?? SCOPES.READ;
-}
 new AsyncLocalStorage();
 
 // src/auth/oauth-resource-server.ts
@@ -6462,6 +6475,15 @@ async function createServer(options) {
   const db = await DatabaseAdapterFactory.create(dbPath);
   await db.initialize();
   logger.info("Database initialized", { module: "McpServer", dbPath });
+  if (options.auditConfig?.enabled) {
+    initializeAuditLogger(options.auditConfig);
+    logger.info("Audit logging enabled", {
+      module: "McpServer",
+      path: options.auditConfig.logPath,
+      redact: options.auditConfig.redact,
+      auditReads: options.auditConfig.auditReads
+    });
+  }
   let teamDb;
   if (teamDbPath) {
     teamDb = await DatabaseAdapterFactory.create(teamDbPath);
@@ -6486,12 +6508,20 @@ async function createServer(options) {
     });
   }
   let githubPath = ".";
-  if (options.defaultProjectNumber !== void 0 && options.projectRegistry) {
-    const defaultEntry = Object.values(options.projectRegistry).find(
-      (r) => r.project_number === options.defaultProjectNumber
-    );
-    if (defaultEntry?.path) {
-      githubPath = defaultEntry.path;
+  if (options.projectRegistry && Object.keys(options.projectRegistry).length > 0) {
+    if (options.defaultProjectNumber !== void 0) {
+      const defaultEntry = Object.values(options.projectRegistry).find(
+        (r) => r.project_number === options.defaultProjectNumber
+      );
+      if (defaultEntry?.path) {
+        githubPath = defaultEntry.path;
+      }
+    }
+    if (githubPath === ".") {
+      const firstEntry = Object.values(options.projectRegistry)[0];
+      if (firstEntry?.path) {
+        githubPath = firstEntry.path;
+      }
     }
   }
   const github = new GitHubIntegration(githubPath);
@@ -6596,7 +6626,16 @@ async function createServer(options) {
       }
     }
     if (tool.outputSchema !== void 0) {
-      toolOptions["outputSchema"] = tool.outputSchema;
+      const outSchema = tool.outputSchema;
+      if (typeof outSchema === "object" && outSchema !== null && "passthrough" in outSchema && typeof outSchema.passthrough === "function") {
+        try {
+          toolOptions["outputSchema"] = outSchema.passthrough();
+        } catch {
+          toolOptions["outputSchema"] = outSchema;
+        }
+      } else {
+        toolOptions["outputSchema"] = outSchema;
+      }
     }
     if (tool.annotations !== void 0) {
       toolOptions["annotations"] = tool.annotations;
@@ -6720,6 +6759,10 @@ async function createServer(options) {
     logger.info("MCP server started on stdio", { module: "McpServer" });
     process.on("SIGINT", () => {
       logger.info("Shutting down...", { module: "McpServer" });
+      const auditLogger = getGlobalAuditLogger();
+      if (auditLogger) {
+        void auditLogger.close();
+      }
       db.close();
       teamDb?.close();
       process.exit(0);
@@ -6747,6 +6790,10 @@ async function createServer(options) {
     process.on("SIGINT", () => {
       void (async () => {
         await httpTransport.stop(scheduler);
+        const auditLogger = getGlobalAuditLogger();
+        if (auditLogger) {
+          await auditLogger.close();
+        }
         db.close();
         teamDb?.close();
         process.exit(0);
@@ -6755,4 +6802,4 @@ async function createServer(options) {
   }
 }
 
-export { META_GROUPS, TOOL_GROUPS, VERSION, calculateTokenSavings, createServer, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, parseToolFilter };
+export { VERSION, createServer };