memory-journal-mcp 6.2.1 → 7.0.0

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

@@ -1,13 +1,11 @@
-import { setDefaultSandboxMode, logger, getTools, callTool, ConfigurationError, sendProgress, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, execQuery, transformEntryRow, resolveGitHubRepo, isResourceError, milestoneCompletionPct, MemoryJournalMcpError, validateDateFormatPattern, DEFAULT_BRIEFING_CONFIG } from './chunk-BI4ZNSKA.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';
 import DatabaseAdapter from 'better-sqlite3';
 import * as fs2 from 'fs';
 import * as path4 from 'path';
-import { Octokit } from '@octokit/rest';
-import { graphql } from '@octokit/graphql';
-import * as simpleGitImport from 'simple-git';
 import { fileURLToPath } from 'url';
 import express from 'express';
 import { timingSafeEqual, randomUUID } from 'crypto';
@@ -19,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;
@@ -423,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')");
@@ -932,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) {
@@ -967,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 ")}`;
   }
@@ -1121,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);
@@ -1130,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();
@@ -1167,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 ?? "";
@@ -1196,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) {
@@ -1317,6 +1136,7 @@ var BackupManager = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
+  ctx;
   async exportToFile(backupName) {
     const backupsDir = this.ctx.getBackupsDir();
     if (backupName) {
@@ -1409,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"
     );
@@ -1600,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;
@@ -1627,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" });
@@ -1730,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
    */
@@ -1822,1378 +1700,54 @@ var VectorSearchManager = class {
           } else {
             failed++;
             if (embError !== null) firstError ??= embError;
-          }
-        }
-        if (indexed % 10 === 0 || indexed === totalEntries) {
-          await sendProgress(
-            progress,
-            indexed,
-            totalEntries,
-            `Indexed ${String(indexed)} of ${String(totalEntries)} entries`
-          );
-        }
-      }
-    }
-    await sendProgress(progress, indexed, totalEntries, "Vector index rebuild complete");
-    if (failed > 0) {
-      logger.warning(
-        `Vector index rebuild: ${String(indexed)} indexed, ${String(failed)} failed`,
-        {
-          module: "VectorSearch"
-        }
-      );
-    } else {
-      logger.info(`Rebuilt vector index with ${String(indexed)} entries`, {
-        module: "VectorSearch"
-      });
-    }
-    return { indexed, failed, firstError };
-  }
-  /**
-   * Get index statistics
-   */
-  getStats() {
-    if (!this.db) {
-      return { itemCount: 0, modelName: this.modelName, dimensions: EMBEDDING_DIMENSIONS };
-    }
-    try {
-      const result = this.db.prepare("SELECT COUNT(*) as count FROM vec_embeddings").get();
-      return {
-        itemCount: result?.count ?? 0,
-        modelName: this.modelName,
-        dimensions: EMBEDDING_DIMENSIONS
-      };
-    } catch (error) {
-      logger.debug("Failed to get vector index stats", {
-        module: "VectorSearch",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return { itemCount: 0, modelName: this.modelName, dimensions: EMBEDDING_DIMENSIONS };
-    }
-  }
-};
-var CACHE_TTL_MS = 5 * 60 * 1e3;
-var TRAFFIC_CACHE_TTL_MS = 10 * 60 * 1e3;
-var simpleGit2 = simpleGitImport.simpleGit;
-var GitHubClient = class {
-  octokit = null;
-  graphqlWithAuth = null;
-  git;
-  token;
-  cachedRepoInfo = null;
-  apiCache = /* @__PURE__ */ new Map();
-  constructor(workingDir = ".") {
-    this.token = process.env["GITHUB_TOKEN"];
-    const envRepoPath = process.env["GITHUB_REPO_PATH"];
-    const effectiveDir = envRepoPath || workingDir;
-    const resolvedDir = effectiveDir === "." ? process.cwd() : effectiveDir;
-    logger.info("GitHub integration using directory", {
-      module: "GitHub",
-      workingDir,
-      envRepoPath: envRepoPath ?? "not set",
-      effectiveDir,
-      resolvedDir,
-      cwd: process.cwd()
-    });
-    this.git = simpleGit2(effectiveDir);
-    if (this.token) {
-      this.octokit = new Octokit({ auth: this.token });
-      this.graphqlWithAuth = graphql.defaults({
-        headers: { authorization: `token ${this.token}` }
-      });
-      logger.info("GitHub integration initialized with token", { module: "GitHub" });
-    } else {
-      logger.info("GitHub integration initialized without token (limited functionality)", {
-        module: "GitHub"
-      });
-    }
-  }
-  isApiAvailable() {
-    return this.octokit !== null;
-  }
-  getCached(key) {
-    const entry = this.apiCache.get(key);
-    if (entry && Date.now() - entry.timestamp < CACHE_TTL_MS) {
-      this.apiCache.delete(key);
-      this.apiCache.set(key, entry);
-      return entry.data;
-    }
-    if (entry) {
-      this.apiCache.delete(key);
-    }
-    return void 0;
-  }
-  getCachedWithTtl(key, ttlMs) {
-    const entry = this.apiCache.get(key);
-    if (entry && Date.now() - entry.timestamp < ttlMs) {
-      this.apiCache.delete(key);
-      this.apiCache.set(key, entry);
-      return entry.data;
-    }
-    if (entry) {
-      this.apiCache.delete(key);
-    }
-    return void 0;
-  }
-  setCache(key, data) {
-    this.apiCache.delete(key);
-    this.apiCache.set(key, { data, timestamp: Date.now() });
-    if (this.apiCache.size > 100) {
-      const oldestKey = this.apiCache.keys().next().value;
-      if (oldestKey !== void 0) {
-        this.apiCache.delete(oldestKey);
-      }
-    }
-  }
-  invalidateCache(prefix) {
-    for (const key of this.apiCache.keys()) {
-      if (key.startsWith(prefix)) {
-        this.apiCache.delete(key);
-      }
-    }
-  }
-  clearCache() {
-    this.apiCache.clear();
-  }
-};
-
-// src/github/github-integration/issues.ts
-var IssuesManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getIssues(owner, repo, state = "open", limit = 20) {
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `issues:${owner}:${repo}:${state}:${String(limit)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.issues.listForRepo({
-        owner,
-        repo,
-        state,
-        per_page: Math.min(limit * 2, 100),
-        sort: "updated",
-        direction: "desc"
-      });
-      const result = response.data.filter((issue) => !issue.pull_request).slice(0, limit).map((issue) => ({
-        number: issue.number,
-        title: issue.title,
-        url: issue.html_url,
-        state: issue.state === "open" ? "OPEN" : "CLOSED",
-        milestone: issue.milestone ? {
-          number: issue.milestone.number,
-          title: issue.milestone.title
-        } : null
-      }));
-      this.client.setCache(cacheKey, result);
-      return result;
-    } catch (error) {
-      logger.error("Failed to get issues", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  async getIssue(owner, repo, issueNumber) {
-    if (!this.client.octokit) {
-      return null;
-    }
-    const cacheKey = `issue:${owner}:${repo}:${String(issueNumber)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached !== void 0) return cached;
-    try {
-      const response = await this.client.octokit.issues.get({
-        owner,
-        repo,
-        issue_number: issueNumber
-      });
-      const issue = response.data;
-      if (issue.pull_request) {
-        return null;
-      }
-      const details = {
-        number: issue.number,
-        title: issue.title,
-        url: issue.html_url,
-        state: issue.state === "open" ? "OPEN" : "CLOSED",
-        nodeId: issue.node_id,
-        body: issue.body ?? null,
-        labels: issue.labels.map((l) => typeof l === "string" ? l : l.name ?? ""),
-        assignees: issue.assignees?.map((a) => a.login) ?? [],
-        createdAt: issue.created_at,
-        updatedAt: issue.updated_at,
-        closedAt: issue.closed_at,
-        commentsCount: issue.comments,
-        milestone: issue.milestone ? { number: issue.milestone.number, title: issue.milestone.title } : null
-      };
-      this.client.setCache(cacheKey, details);
-      return details;
-    } catch (error) {
-      logger.error("Failed to get issue details", {
-        module: "GitHub",
-        entityId: issueNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-  async createIssue(owner, repo, title, body, labels, assignees, milestone) {
-    if (!this.client.octokit) {
-      logger.error("Cannot create issue: GitHub API not available", { module: "GitHub" });
-      return null;
-    }
-    try {
-      const response = await this.client.octokit.issues.create({
-        owner,
-        repo,
-        title,
-        body,
-        labels,
-        assignees,
-        milestone
-      });
-      logger.info("Created GitHub issue", {
-        module: "GitHub",
-        entityId: response.data.number,
-        context: { title, owner, repo }
-      });
-      return {
-        number: response.data.number,
-        url: response.data.html_url,
-        title: response.data.title,
-        nodeId: response.data.node_id
-      };
-    } catch (error) {
-      logger.error("Failed to create issue", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { title, owner, repo }
-      });
-      return null;
-    } finally {
-      this.client.invalidateCache(`issues:${owner}:${repo}`);
-      this.client.invalidateCache("context:");
-    }
-  }
-  async closeIssue(owner, repo, issueNumber, comment) {
-    if (!this.client.octokit) {
-      logger.error("Cannot close issue: GitHub API not available", { module: "GitHub" });
-      return null;
-    }
-    try {
-      if (comment) {
-        await this.client.octokit.issues.createComment({
-          owner,
-          repo,
-          issue_number: issueNumber,
-          body: comment
-        });
-      }
-      const response = await this.client.octokit.issues.update({
-        owner,
-        repo,
-        issue_number: issueNumber,
-        state: "closed"
-      });
-      logger.info("Closed GitHub issue", {
-        module: "GitHub",
-        entityId: issueNumber,
-        context: { owner, repo, hadComment: !!comment }
-      });
-      return {
-        success: true,
-        url: response.data.html_url
-      };
-    } catch (error) {
-      logger.error("Failed to close issue", {
-        module: "GitHub",
-        entityId: issueNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    } finally {
-      this.client.invalidateCache(`issues:${owner}:${repo}`);
-      this.client.invalidateCache(`issue:${owner}:${repo}:${String(issueNumber)}`);
-      this.client.invalidateCache("context:");
-    }
-  }
-};
-
-// src/github/github-integration/pull-requests.ts
-var PullRequestsManager = class _PullRequestsManager {
-  constructor(client) {
-    this.client = client;
-  }
-  /** Known Copilot bot login patterns */
-  static COPILOT_BOT_PATTERNS = [
-    "copilot-pull-request-reviewer[bot]",
-    "github-copilot[bot]",
-    "copilot[bot]"
-  ];
-  async getPullRequests(owner, repo, state = "open", limit = 20) {
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `prs:${owner}:${repo}:${state}:${String(limit)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.pulls.list({
-        owner,
-        repo,
-        state,
-        per_page: limit,
-        sort: "updated",
-        direction: "desc"
-      });
-      const result = response.data.map((pr) => ({
-        number: pr.number,
-        title: pr.title,
-        url: pr.html_url,
-        state: pr.merged_at ? "MERGED" : pr.state === "open" ? "OPEN" : "CLOSED"
-      }));
-      this.client.setCache(cacheKey, result);
-      return result;
-    } catch (error) {
-      logger.error("Failed to get pull requests", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  async getPullRequest(owner, repo, prNumber) {
-    if (!this.client.octokit) {
-      return null;
-    }
-    const cacheKey = `pr:${owner}:${repo}:${String(prNumber)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached !== void 0) return cached;
-    try {
-      const response = await this.client.octokit.pulls.get({
-        owner,
-        repo,
-        pull_number: prNumber
-      });
-      const pr = response.data;
-      const details = {
-        number: pr.number,
-        title: pr.title,
-        url: pr.html_url,
-        state: pr.merged_at ? "MERGED" : pr.state === "open" ? "OPEN" : "CLOSED",
-        body: pr.body,
-        draft: pr.draft ?? false,
-        headBranch: pr.head.ref,
-        baseBranch: pr.base.ref,
-        author: pr.user?.login ?? "unknown",
-        createdAt: pr.created_at,
-        updatedAt: pr.updated_at,
-        mergedAt: pr.merged_at,
-        closedAt: pr.closed_at,
-        additions: pr.additions,
-        deletions: pr.deletions,
-        changedFiles: pr.changed_files
-      };
-      this.client.setCache(cacheKey, details);
-      return details;
-    } catch (error) {
-      logger.error("Failed to get PR details", {
-        module: "GitHub",
-        entityId: prNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-  static isCopilotAuthor(login) {
-    const lower = login.toLowerCase();
-    return _PullRequestsManager.COPILOT_BOT_PATTERNS.some(
-      (p) => lower === p || lower.includes("copilot")
-    );
-  }
-  async getReviews(owner, repo, prNumber) {
-    if (!this.client.octokit) return [];
-    const cacheKey = `reviews:${owner}:${repo}:${String(prNumber)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.rest.pulls.listReviews({
-        owner,
-        repo,
-        pull_number: prNumber,
-        per_page: 100
-      });
-      const reviews = response.data.map((r) => ({
-        id: r.id,
-        author: r.user?.login ?? "unknown",
-        state: r.state,
-        body: r.body ?? null,
-        submittedAt: r.submitted_at ?? r.commit_id ?? (/* @__PURE__ */ new Date()).toISOString(),
-        isCopilot: _PullRequestsManager.isCopilotAuthor(r.user?.login ?? "")
-      }));
-      this.client.setCache(cacheKey, reviews);
-      return reviews;
-    } catch (error) {
-      logger.error("Failed to get PR reviews", {
-        module: "GitHub",
-        entityId: prNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  async getReviewComments(owner, repo, prNumber) {
-    if (!this.client.octokit) return [];
-    const cacheKey = `review-comments:${owner}:${repo}:${String(prNumber)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.rest.pulls.listReviewComments({
-        owner,
-        repo,
-        pull_number: prNumber,
-        per_page: 100
-      });
-      const comments = response.data.map((c) => ({
-        id: c.id,
-        author: c.user?.login ?? "unknown",
-        body: c.body,
-        path: c.path,
-        line: c.line ?? c.original_line ?? null,
-        side: c.side ?? "RIGHT",
-        createdAt: c.created_at,
-        isCopilot: _PullRequestsManager.isCopilotAuthor(c.user?.login ?? "")
-      }));
-      this.client.setCache(cacheKey, comments);
-      return comments;
-    } catch (error) {
-      logger.error("Failed to get review comments", {
-        module: "GitHub",
-        entityId: prNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  async getCopilotReviewSummary(owner, repo, prNumber) {
-    const [reviews, comments] = await Promise.all([
-      this.getReviews(owner, repo, prNumber),
-      this.getReviewComments(owner, repo, prNumber)
-    ]);
-    const copilotReviews = reviews.filter((r) => r.isCopilot);
-    const copilotComments = comments.filter((c) => c.isCopilot);
-    let state = "none";
-    if (copilotReviews.length > 0) {
-      const latest = copilotReviews[copilotReviews.length - 1];
-      if (latest !== void 0) {
-        if (latest.state === "APPROVED") state = "approved";
-        else if (latest.state === "CHANGES_REQUESTED") state = "changes_requested";
-        else if (latest.state === "COMMENTED") state = "commented";
-      }
-    }
-    return {
-      prNumber,
-      state,
-      commentCount: copilotComments.length,
-      comments: copilotComments
-    };
-  }
-};
-
-// src/github/github-integration/projects.ts
-var ProjectsManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getProjectKanban(owner, projectNumber, repo) {
-    if (!this.client.graphqlWithAuth) {
-      logger.debug("GraphQL not available - no token", { module: "GitHub" });
-      return null;
-    }
-    const projectFragment = `
-            fragment ProjectData on ProjectV2 {
-                id
-                title
-                fields(first: 20) {
-                    nodes {
-                        ... on ProjectV2SingleSelectField {
-                            id
-                            name
-                            options {
-                                id
-                                name
-                                color
-                            }
-                        }
-                    }
-                }
-                items(first: 100) {
-                    nodes {
-                        id
-                        type
-                        createdAt
-                        updatedAt
-                        fieldValues(first: 10) {
-                            nodes {
-                                ... on ProjectV2ItemFieldSingleSelectValue {
-                                    name
-                                    field {
-                                        ... on ProjectV2SingleSelectField {
-                                            name
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        content {
-                            ... on Issue {
-                                number
-                                title
-                                url
-                                labels(first: 5) {
-                                    nodes { name }
-                                }
-                                assignees(first: 5) {
-                                    nodes { login }
-                                }
-                            }
-                            ... on PullRequest {
-                                number
-                                title
-                                url
-                                labels(first: 5) {
-                                    nodes { name }
-                                }
-                                assignees(first: 5) {
-                                    nodes { login }
-                                }
-                            }
-                            ... on DraftIssue {
-                                title
-                            }
-                        }
-                    }
-                }
-            }
-        `;
-    const userQuery = `
-            ${projectFragment}
-            query($owner: String!, $number: Int!) {
-                user(login: $owner) {
-                    projectV2(number: $number) {
-                        ...ProjectData
-                    }
-                }
-            }
-        `;
-    const repoQuery = `
-            ${projectFragment}
-            query($owner: String!, $repo: String!, $number: Int!) {
-                repository(owner: $owner, name: $repo) {
-                    projectV2(number: $number) {
-                        ...ProjectData
-                    }
-                }
-            }
-        `;
-    const orgQuery = `
-            ${projectFragment}
-            query($owner: String!, $number: Int!) {
-                organization(login: $owner) {
-                    projectV2(number: $number) {
-                        ...ProjectData
-                    }
-                }
-            }
-        `;
-    let project = null;
-    let source = "";
-    try {
-      const response = await this.client.graphqlWithAuth(userQuery, {
-        owner,
-        number: projectNumber
-      });
-      if (response.user?.projectV2) {
-        project = response.user.projectV2;
-        source = "user";
-      }
-    } catch {
-      logger.debug("User project not found, trying repository...", { module: "GitHub" });
-    }
-    if (!project && repo) {
-      try {
-        const response = await this.client.graphqlWithAuth(repoQuery, {
-          owner,
-          repo,
-          number: projectNumber
-        });
-        if (response.repository?.projectV2) {
-          project = response.repository.projectV2;
-          source = "repository";
-        }
-      } catch {
-        logger.debug("Repository project not found, trying organization...", {
-          module: "GitHub"
-        });
-      }
-    }
-    if (!project) {
-      try {
-        const response = await this.client.graphqlWithAuth(orgQuery, {
-          owner,
-          number: projectNumber
-        });
-        if (response.organization?.projectV2) {
-          project = response.organization.projectV2;
-          source = "organization";
-        }
-      } catch {
-        logger.debug("Organization project not found", { module: "GitHub" });
-      }
-    }
-    if (!project) {
-      logger.warning("Project not found", { module: "GitHub", entityId: projectNumber });
-      return null;
-    }
-    const statusField = project.fields.nodes.find(
-      (f) => f.name === "Status" && f.options !== void 0 && f.options.length > 0
-    );
-    if (!statusField?.id || !statusField.options) {
-      logger.warning("Status field not found in project", {
-        module: "GitHub",
-        entityId: projectNumber
-      });
-      return null;
-    }
-    const statusOptions = statusField.options.map((opt) => ({
-      id: opt.id,
-      name: opt.name,
-      color: opt.color
-    }));
-    const columnMap = /* @__PURE__ */ new Map();
-    for (const opt of statusOptions) {
-      columnMap.set(opt.name, []);
-    }
-    columnMap.set("No Status", []);
-    for (const item of project.items.nodes) {
-      const statusValue = item.fieldValues.nodes.find((fv) => fv.field?.name === "Status");
-      const status = statusValue?.name ?? "No Status";
-      const content = item.content;
-      const projectItem = {
-        id: item.id,
-        title: content?.title ?? "Draft Issue",
-        url: content?.url ?? "",
-        type: item.type,
-        status,
-        number: content?.number,
-        labels: content?.labels?.nodes.map((l) => l.name) ?? [],
-        assignees: content?.assignees?.nodes.map((a) => a.login) ?? [],
-        createdAt: item.createdAt,
-        updatedAt: item.updatedAt
-      };
-      const column = columnMap.get(status);
-      if (column) {
-        column.push(projectItem);
-      } else {
-        columnMap.get("No Status")?.push(projectItem);
-      }
-    }
-    const columns = [];
-    for (const opt of statusOptions) {
-      const items = columnMap.get(opt.name) ?? [];
-      columns.push({
-        status: opt.name,
-        statusOptionId: opt.id,
-        items
-      });
-    }
-    const noStatusItems = columnMap.get("No Status") ?? [];
-    if (noStatusItems.length > 0) {
-      columns.push({
-        status: "No Status",
-        statusOptionId: "",
-        items: noStatusItems
-      });
-    }
-    const totalItems = project.items.nodes.length;
-    logger.info("Fetched Kanban board", {
-      module: "GitHub",
-      entityId: projectNumber,
-      context: { columns: columns.length, items: totalItems, source }
-    });
-    return {
-      projectId: project.id,
-      projectNumber,
-      projectTitle: project.title,
-      statusFieldId: statusField.id,
-      statusOptions,
-      columns,
-      totalItems
-    };
-  }
-  async moveProjectItem(projectId, itemId, statusFieldId, statusOptionId) {
-    if (!this.client.graphqlWithAuth) {
-      return { success: false, error: "GraphQL not available - no token" };
-    }
-    try {
-      const mutation = `
-                mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
-                    updateProjectV2ItemFieldValue(
-                        input: {
-                            projectId: $projectId
-                            itemId: $itemId
-                            fieldId: $fieldId
-                            value: { singleSelectOptionId: $optionId }
-                        }
-                    ) {
-                        projectV2Item {
-                            id
-                        }
-                    }
-                }
-            `;
-      await this.client.graphqlWithAuth(mutation, {
-        projectId,
-        itemId,
-        fieldId: statusFieldId,
-        optionId: statusOptionId
-      });
-      logger.info("Moved project item", {
-        module: "GitHub",
-        entityId: itemId,
-        context: { targetStatus: statusOptionId }
-      });
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Failed to move project item", {
-        module: "GitHub",
-        entityId: itemId,
-        error: errorMessage
-      });
-      return { success: false, error: errorMessage };
-    } finally {
-      this.client.invalidateCache("kanban:");
-    }
-  }
-  async addProjectItem(projectId, contentId) {
-    if (!this.client.graphqlWithAuth) {
-      return { success: false, error: "GraphQL not available - no token" };
-    }
-    try {
-      const mutation = `
-                mutation($projectId: ID!, $contentId: ID!) {
-                    addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
-                        item {
-                            id
-                        }
-                    }
-                }
-            `;
-      const response = await this.client.graphqlWithAuth(mutation, {
-        projectId,
-        contentId
-      });
-      const itemId = response.addProjectV2ItemById?.item?.id;
-      logger.info("Added item to project", {
-        module: "GitHub",
-        context: { projectId, contentId, itemId }
-      });
-      return { success: true, itemId };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Failed to add item to project", {
-        module: "GitHub",
-        context: { projectId, contentId },
-        error: errorMessage
-      });
-      return { success: false, error: errorMessage };
-    } finally {
-      this.client.invalidateCache("kanban:");
-    }
-  }
-};
-
-// src/github/github-integration/milestones.ts
-var MilestonesManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getMilestones(owner, repo, state = "open", limit = 20) {
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `milestones:${owner}:${repo}:${state}:${String(limit)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.issues.listMilestones({
-        owner,
-        repo,
-        state,
-        per_page: limit,
-        sort: "due_on",
-        direction: "asc"
-      });
-      const result = response.data.map((ms) => ({
-        number: ms.number,
-        title: ms.title,
-        description: ms.description ?? null,
-        state: ms.state === "open" ? "open" : "closed",
-        url: ms.html_url,
-        dueOn: ms.due_on ?? null,
-        openIssues: ms.open_issues,
-        closedIssues: ms.closed_issues,
-        createdAt: ms.created_at,
-        updatedAt: ms.updated_at,
-        creator: ms.creator?.login ?? null
-      }));
-      this.client.setCache(cacheKey, result);
-      return result;
-    } catch (error) {
-      logger.error("Failed to get milestones", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    }
-  }
-  async getMilestone(owner, repo, milestoneNumber) {
-    if (!this.client.octokit) {
-      return null;
-    }
-    const cacheKey = `milestone:${owner}:${repo}:${String(milestoneNumber)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached !== void 0) return cached;
-    try {
-      const response = await this.client.octokit.issues.getMilestone({
-        owner,
-        repo,
-        milestone_number: milestoneNumber
-      });
-      const ms = response.data;
-      const milestone = {
-        number: ms.number,
-        title: ms.title,
-        description: ms.description ?? null,
-        state: ms.state === "open" ? "open" : "closed",
-        url: ms.html_url,
-        dueOn: ms.due_on ?? null,
-        openIssues: ms.open_issues,
-        closedIssues: ms.closed_issues,
-        createdAt: ms.created_at,
-        updatedAt: ms.updated_at,
-        creator: ms.creator?.login ?? null
-      };
-      this.client.setCache(cacheKey, milestone);
-      return milestone;
-    } catch (error) {
-      logger.error("Failed to get milestone", {
-        module: "GitHub",
-        entityId: milestoneNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-  async createMilestone(owner, repo, title, description, dueOn) {
-    if (!this.client.octokit) {
-      logger.error("Cannot create milestone: GitHub API not available", {
-        module: "GitHub"
-      });
-      return null;
-    }
-    try {
-      const response = await this.client.octokit.issues.createMilestone({
-        owner,
-        repo,
-        title,
-        description,
-        due_on: dueOn
-      });
-      const ms = response.data;
-      logger.info("Created GitHub milestone", {
-        module: "GitHub",
-        entityId: ms.number,
-        context: { title, owner, repo }
-      });
-      return {
-        number: ms.number,
-        title: ms.title,
-        description: ms.description ?? null,
-        state: ms.state === "open" ? "open" : "closed",
-        url: ms.html_url,
-        dueOn: ms.due_on ?? null,
-        openIssues: ms.open_issues,
-        closedIssues: ms.closed_issues,
-        createdAt: ms.created_at,
-        updatedAt: ms.updated_at,
-        creator: ms.creator?.login ?? null
-      };
-    } catch (error) {
-      logger.error("Failed to create milestone", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { title, owner, repo }
-      });
-      return null;
-    } finally {
-      this.client.invalidateCache(`milestones:${owner}:${repo}`);
-      this.client.invalidateCache("context:");
-    }
-  }
-  async updateMilestone(owner, repo, milestoneNumber, updates) {
-    if (!this.client.octokit) {
-      logger.error("Cannot update milestone: GitHub API not available", {
-        module: "GitHub"
-      });
-      return null;
-    }
-    try {
-      const response = await this.client.octokit.issues.updateMilestone({
-        owner,
-        repo,
-        milestone_number: milestoneNumber,
-        title: updates.title,
-        description: updates.description,
-        due_on: updates.dueOn === null ? void 0 : updates.dueOn,
-        state: updates.state
-      });
-      const ms = response.data;
-      logger.info("Updated GitHub milestone", {
-        module: "GitHub",
-        entityId: milestoneNumber,
-        context: { owner, repo, updates: Object.keys(updates) }
-      });
-      return {
-        number: ms.number,
-        title: ms.title,
-        description: ms.description ?? null,
-        state: ms.state === "open" ? "open" : "closed",
-        url: ms.html_url,
-        dueOn: ms.due_on ?? null,
-        openIssues: ms.open_issues,
-        closedIssues: ms.closed_issues,
-        createdAt: ms.created_at,
-        updatedAt: ms.updated_at,
-        creator: ms.creator?.login ?? null
-      };
-    } catch (error) {
-      logger.error("Failed to update milestone", {
-        module: "GitHub",
-        entityId: milestoneNumber,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    } finally {
-      this.client.invalidateCache(`milestones:${owner}:${repo}`);
-      this.client.invalidateCache(`milestone:${owner}:${repo}:${String(milestoneNumber)}`);
-      this.client.invalidateCache("context:");
-    }
-  }
-  async deleteMilestone(owner, repo, milestoneNumber) {
-    if (!this.client.octokit) {
-      return { success: false, error: "GitHub API not available" };
-    }
-    try {
-      await this.client.octokit.issues.deleteMilestone({
-        owner,
-        repo,
-        milestone_number: milestoneNumber
-      });
-      logger.info("Deleted GitHub milestone", {
-        module: "GitHub",
-        entityId: milestoneNumber,
-        context: { owner, repo }
-      });
-      return { success: true };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error("Failed to delete milestone", {
-        module: "GitHub",
-        entityId: milestoneNumber,
-        error: errorMessage
-      });
-      return { success: false, error: errorMessage };
-    } finally {
-      this.client.invalidateCache(`milestones:${owner}:${repo}`);
-      this.client.invalidateCache(`milestone:${owner}:${repo}:${String(milestoneNumber)}`);
-      this.client.invalidateCache("context:");
-    }
-  }
-};
-
-// src/github/github-integration/insights.ts
-var InsightsManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getRepoStats(owner, repo) {
-    if (!this.client.octokit) {
-      return null;
-    }
-    const cacheKey = `repostats:${owner}:${repo}`;
-    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
-    if (cached) return cached;
-    try {
-      const response = await this.client.octokit.repos.get({ owner, repo });
-      const data = response.data;
-      const result = {
-        stars: data.stargazers_count,
-        forks: data.forks_count,
-        watchers: data.subscribers_count,
-        openIssues: data.open_issues_count,
-        size: data.size,
-        defaultBranch: data.default_branch
-      };
-      this.client.setCache(cacheKey, result);
-      return result;
-    } catch (error) {
-      logger.error("Failed to get repo stats", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { owner, repo }
-      });
-      return null;
-    }
-  }
-  async getTrafficData(owner, repo) {
-    if (!this.client.octokit) {
-      return null;
-    }
-    const cacheKey = `traffic:${owner}:${repo}`;
-    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
-    if (cached) return cached;
-    try {
-      const [clonesRes, viewsRes] = await Promise.all([
-        this.client.octokit.rest.repos.getClones({ owner, repo }),
-        this.client.octokit.rest.repos.getViews({ owner, repo })
-      ]);
-      const clonesDays = clonesRes.data.clones?.length ?? 0;
-      const viewsDays = viewsRes.data.views?.length ?? 0;
-      const result = {
-        clones: {
-          total: clonesRes.data.count,
-          unique: clonesRes.data.uniques,
-          dailyAvg: clonesDays > 0 ? Math.round(clonesRes.data.count / clonesDays) : 0
-        },
-        views: {
-          total: viewsRes.data.count,
-          unique: viewsRes.data.uniques,
-          dailyAvg: viewsDays > 0 ? Math.round(viewsRes.data.count / viewsDays) : 0
-        },
-        period: "14 days"
-      };
-      this.client.setCache(cacheKey, result);
-      return result;
-    } catch (error) {
-      logger.error("Failed to get traffic data", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { owner, repo }
-      });
-      return null;
-    }
-  }
-  async getTopReferrers(owner, repo, limit = 5) {
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `referrers:${owner}:${repo}`;
-    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
-    if (cached) return cached.slice(0, limit);
-    try {
-      const response = await this.client.octokit.rest.repos.getTopReferrers({ owner, repo });
-      const result = response.data.map((r) => ({
-        referrer: r.referrer,
-        count: r.count,
-        uniques: r.uniques
-      }));
-      this.client.setCache(cacheKey, result);
-      return result.slice(0, limit);
-    } catch (error) {
-      logger.error("Failed to get top referrers", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { owner, repo }
-      });
-      return [];
-    }
-  }
-  async getPopularPaths(owner, repo, limit = 5) {
-    if (!this.client.octokit) {
-      return [];
-    }
-    const cacheKey = `paths:${owner}:${repo}`;
-    const cached = this.client.getCachedWithTtl(cacheKey, TRAFFIC_CACHE_TTL_MS);
-    if (cached) return cached.slice(0, limit);
-    try {
-      const response = await this.client.octokit.rest.repos.getTopPaths({ owner, repo });
-      const result = response.data.map((p) => ({
-        path: p.path,
-        title: p.title,
-        count: p.count,
-        uniques: p.uniques
-      }));
-      this.client.setCache(cacheKey, result);
-      return result.slice(0, limit);
-    } catch (error) {
-      logger.error("Failed to get popular paths", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error),
-        context: { owner, repo }
-      });
-      return [];
-    }
-  }
-};
-
-// src/github/github-integration/repository.ts
-var RepositoryManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getRepoInfo() {
-    try {
-      const branchResult = await this.client.git.branch();
-      const branch = branchResult.current || null;
-      const remotes = await this.client.git.getRemotes(true);
-      const origin = remotes.find((r) => r.name === "origin");
-      const remoteUrl = origin?.refs?.fetch || null;
-      const { owner, repo } = this.parseRemoteUrl(remoteUrl);
-      const repoInfo = { owner, repo, branch, remoteUrl };
-      this.client.cachedRepoInfo = repoInfo;
-      return repoInfo;
-    } catch (error) {
-      logger.debug("Failed to get repo info (may not be a git repo)", {
-        module: "GitHub",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return { owner: null, repo: null, branch: null, remoteUrl: null };
-    }
-  }
-  getCachedRepoInfo() {
-    return this.client.cachedRepoInfo;
-  }
-  parseRemoteUrl(remoteUrl) {
-    if (!remoteUrl) return { owner: null, repo: null };
-    if (remoteUrl.startsWith("git@github.com:")) {
-      const pathPart = remoteUrl.replace("git@github.com:", "").replace(".git", "");
-      const parts = pathPart.split("/");
-      if (parts.length >= 2) {
-        return { owner: parts[0] ?? null, repo: parts[1] ?? null };
+          }
+        }
+        if (indexed % 10 === 0 || indexed === totalEntries) {
+          await sendProgress(
+            progress,
+            indexed,
+            totalEntries,
+            `Indexed ${String(indexed)} of ${String(totalEntries)} entries`
+          );
+        }
       }
     }
-    try {
-      const url = new URL(remoteUrl);
-      if (url.hostname === "github.com") {
-        const path5 = url.pathname.replace(".git", "").replace(/^\//, "");
-        const parts = path5.split("/");
-        if (parts.length >= 2) {
-          return { owner: parts[0] ?? null, repo: parts[1] ?? null };
+    await sendProgress(progress, indexed, totalEntries, "Vector index rebuild complete");
+    if (failed > 0) {
+      logger.warning(
+        `Vector index rebuild: ${String(indexed)} indexed, ${String(failed)} failed`,
+        {
+          module: "VectorSearch"
         }
-      }
-    } catch {
+      );
+    } else {
+      logger.info(`Rebuilt vector index with ${String(indexed)} entries`, {
+        module: "VectorSearch"
+      });
     }
-    return { owner: null, repo: null };
+    return { indexed, failed, firstError };
   }
-  async getWorkflowRuns(owner, repo, limit = 10) {
-    if (!this.client.octokit) {
-      logger.debug("GitHub API not available - no token", { module: "GitHub" });
-      return [];
+  /**
+   * Get index statistics
+   */
+  getStats() {
+    if (!this.db) {
+      return { itemCount: 0, modelName: this.modelName, dimensions: EMBEDDING_DIMENSIONS };
     }
-    const cacheKey = `workflows:${owner}:${repo}:${String(limit)}`;
-    const cached = this.client.getCached(cacheKey);
-    if (cached) return cached;
     try {
-      const response = await this.client.octokit.rest.actions.listWorkflowRunsForRepo({
-        owner,
-        repo,
-        per_page: limit
-      });
-      const result = response.data.workflow_runs.map((run) => ({
-        id: run.id,
-        name: run.name ?? "Unknown Workflow",
-        status: run.status,
-        conclusion: run.conclusion,
-        url: run.html_url,
-        headBranch: run.head_branch ?? "",
-        headSha: run.head_sha,
-        createdAt: run.created_at,
-        updatedAt: run.updated_at
-      }));
-      this.client.setCache(cacheKey, result);
-      return result;
+      const result = this.db.prepare("SELECT COUNT(*) as count FROM vec_embeddings").get();
+      return {
+        itemCount: result?.count ?? 0,
+        modelName: this.modelName,
+        dimensions: EMBEDDING_DIMENSIONS
+      };
     } catch (error) {
-      logger.error("Failed to get workflow runs", {
-        module: "GitHub",
+      logger.debug("Failed to get vector index stats", {
+        module: "VectorSearch",
         error: error instanceof Error ? error.message : String(error)
       });
-      return [];
-    }
-  }
-};
-
-// src/github/github-integration/index.ts
-var GitHubIntegration = class {
-  client;
-  issuesManager;
-  pullRequestsManager;
-  projectsManager;
-  milestonesManager;
-  insightsManager;
-  repositoryManager;
-  constructor(workingDir = ".") {
-    this.client = new GitHubClient(workingDir);
-    this.issuesManager = new IssuesManager(this.client);
-    this.pullRequestsManager = new PullRequestsManager(this.client);
-    this.projectsManager = new ProjectsManager(this.client);
-    this.milestonesManager = new MilestonesManager(this.client);
-    this.insightsManager = new InsightsManager(this.client);
-    this.repositoryManager = new RepositoryManager(this.client);
-  }
-  isApiAvailable() {
-    return this.client.isApiAvailable();
-  }
-  clearCache() {
-    this.client.clearCache();
-  }
-  async getRepoInfo() {
-    return this.repositoryManager.getRepoInfo();
-  }
-  getCachedRepoInfo() {
-    return this.repositoryManager.getCachedRepoInfo();
-  }
-  async getIssues(owner, repo, state = "open", limit = 20) {
-    return this.issuesManager.getIssues(owner, repo, state, limit);
-  }
-  async getIssue(owner, repo, issueNumber) {
-    return this.issuesManager.getIssue(owner, repo, issueNumber);
-  }
-  async createIssue(owner, repo, title, body, labels, assignees, milestone) {
-    return this.issuesManager.createIssue(
-      owner,
-      repo,
-      title,
-      body,
-      labels,
-      assignees,
-      milestone
-    );
-  }
-  async closeIssue(owner, repo, issueNumber, comment) {
-    return this.issuesManager.closeIssue(owner, repo, issueNumber, comment);
-  }
-  async getPullRequests(owner, repo, state = "open", limit = 20) {
-    return this.pullRequestsManager.getPullRequests(owner, repo, state, limit);
-  }
-  async getPullRequest(owner, repo, prNumber) {
-    return this.pullRequestsManager.getPullRequest(owner, repo, prNumber);
-  }
-  async getReviews(owner, repo, prNumber) {
-    return this.pullRequestsManager.getReviews(owner, repo, prNumber);
-  }
-  async getReviewComments(owner, repo, prNumber) {
-    return this.pullRequestsManager.getReviewComments(owner, repo, prNumber);
-  }
-  async getCopilotReviewSummary(owner, repo, prNumber) {
-    return this.pullRequestsManager.getCopilotReviewSummary(owner, repo, prNumber);
-  }
-  async getWorkflowRuns(owner, repo, limit = 10) {
-    return this.repositoryManager.getWorkflowRuns(owner, repo, limit);
-  }
-  async getRepoContext() {
-    const cached = this.client.getCached("context:repo");
-    if (cached) return cached;
-    const repoInfo = await this.repositoryManager.getRepoInfo();
-    const context = {
-      repoName: repoInfo.repo,
-      branch: repoInfo.branch,
-      commit: null,
-      remoteUrl: repoInfo.remoteUrl,
-      projects: [],
-      issues: [],
-      pullRequests: [],
-      workflowRuns: [],
-      milestones: []
-    };
-    try {
-      const log = await this.client.git.log({ maxCount: 1 });
-      context.commit = log.latest?.hash ?? null;
-    } catch {
-    }
-    if (repoInfo.owner && repoInfo.repo) {
-      context.issues = await this.issuesManager.getIssues(
-        repoInfo.owner,
-        repoInfo.repo,
-        "open",
-        10
-      );
-      context.pullRequests = await this.pullRequestsManager.getPullRequests(
-        repoInfo.owner,
-        repoInfo.repo,
-        "open",
-        10
-      );
-      context.workflowRuns = await this.repositoryManager.getWorkflowRuns(
-        repoInfo.owner,
-        repoInfo.repo,
-        10
-      );
-      context.milestones = await this.milestonesManager.getMilestones(
-        repoInfo.owner,
-        repoInfo.repo,
-        "open",
-        10
-      );
+      return { itemCount: 0, modelName: this.modelName, dimensions: EMBEDDING_DIMENSIONS };
     }
-    this.client.setCache("context:repo", context);
-    return context;
-  }
-  async getProjectKanban(owner, projectNumber, repo) {
-    return this.projectsManager.getProjectKanban(owner, projectNumber, repo);
-  }
-  async moveProjectItem(projectId, itemId, statusFieldId, statusOptionId) {
-    return this.projectsManager.moveProjectItem(
-      projectId,
-      itemId,
-      statusFieldId,
-      statusOptionId
-    );
-  }
-  async addProjectItem(projectId, contentId) {
-    return this.projectsManager.addProjectItem(projectId, contentId);
-  }
-  async getMilestones(owner, repo, state = "open", limit = 20) {
-    return this.milestonesManager.getMilestones(owner, repo, state, limit);
-  }
-  async getMilestone(owner, repo, milestoneNumber) {
-    return this.milestonesManager.getMilestone(owner, repo, milestoneNumber);
-  }
-  async createMilestone(owner, repo, title, description, dueOn) {
-    return this.milestonesManager.createMilestone(owner, repo, title, description, dueOn);
-  }
-  async updateMilestone(owner, repo, milestoneNumber, updates) {
-    return this.milestonesManager.updateMilestone(owner, repo, milestoneNumber, updates);
-  }
-  async deleteMilestone(owner, repo, milestoneNumber) {
-    return this.milestonesManager.deleteMilestone(owner, repo, milestoneNumber);
-  }
-  async getRepoStats(owner, repo) {
-    return this.insightsManager.getRepoStats(owner, repo);
-  }
-  async getTrafficData(owner, repo) {
-    return this.insightsManager.getTrafficData(owner, repo);
-  }
-  async getTopReferrers(owner, repo, limit = 5) {
-    return this.insightsManager.getTopReferrers(owner, repo, limit);
-  }
-  async getPopularPaths(owner, repo, limit = 5) {
-    return this.insightsManager.getPopularPaths(owner, repo, limit);
   }
 };
 
@@ -3264,35 +1818,11 @@ 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;
   try {
-    const resolved = await resolveGitHubRepo(github);
+    const resolved = await resolveGitHubRepo(github, config);
     if (isResourceError(resolved)) return null;
     const { owner, repo } = resolved;
     const [ciStatus, issuesAndPrs, milestones, insights, copilotReviews] = await Promise.all([
@@ -3338,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";
@@ -3699,92 +2232,129 @@ var briefingResource = {
     autoRead: true
   },
   handler: async (_uri, context) => {
-    const config = context.briefingConfig ?? DEFAULT_BRIEFING_CONFIG;
-    const journal = buildJournalContext(context, config);
-    const github = await buildGitHubSection(context.github, config);
-    const team = buildTeamContext(context, config);
-    const rulesFile = buildRulesFileInfo(config.rulesFilePath);
-    const skillsDir = buildSkillsDirInfo(config.skillsDirPath);
-    const latestPreview = journal.latestEntries[0] ? `#${journal.latestEntries[0].id} (${journal.latestEntries[0].type}): ${journal.latestEntries[0].preview}` : "No entries yet";
-    const userMessage = formatUserMessage({
-      repoName: github?.repo ?? "local",
-      branchName: github?.branch ?? "unknown",
-      ciStatus: github?.ci ?? "unknown",
-      totalEntries: journal.totalEntries,
-      latestPreview,
-      github,
-      teamTotalEntries: team?.teamInfo.totalEntries,
-      rulesFile,
-      skillsDir
-    });
-    return {
-      data: {
-        version: VERSION,
-        serverTime: (/* @__PURE__ */ new Date()).toISOString(),
-        journal: {
-          totalEntries: journal.totalEntries,
-          latestEntries: journal.latestEntries
-        },
-        github,
-        teamContext: team?.teamInfo,
-        ...team?.teamLatestEntries ? { teamLatestEntries: team.teamLatestEntries } : {},
-        ...rulesFile ? { rulesFile } : {},
-        ...skillsDir ? { skillsDir } : {},
-        behaviors: {
-          create: "implementations, decisions, bug-fixes, milestones",
-          search: "before decisions, referencing prior work",
-          link: "implementation\u2192spec, bugfix\u2192issue"
-        },
-        templateResources: [
-          "memory://projects/{number}/timeline",
-          "memory://issues/{issue_number}/entries",
-          "memory://prs/{pr_number}/entries",
-          "memory://prs/{pr_number}/timeline",
-          "memory://kanban/{project_number}",
-          "memory://kanban/{project_number}/diagram",
-          "memory://milestones/{number}"
-        ],
-        more: {
-          fullHealth: "memory://health",
-          allRecent: "memory://recent",
-          githubStatus: "memory://github/status",
-          repoInsights: "memory://github/insights",
-          contextBundle: "get-context-bundle prompt"
-        },
-        userMessage,
-        clientNote: "For full tool reference and field notes, read memory://instructions \u2014 only if your client did NOT auto-inject server instructions at session start (most modern clients including AntiGravity do this automatically)."
-      },
-      annotations: { lastModified: journal.lastModified }
-    };
+    return buildBriefingData(context);
+  }
+};
+var dynamicBriefingResource = {
+  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.",
+  mimeType: "application/json",
+  icons: [ICON_BRIEFING],
+  annotations: {
+    ...withPriority(0.8, ASSISTANT_FOCUSED)
+  },
+  handler: async (uri, context) => {
+    const match = /memory:\/\/briefing\/(.+)/.exec(uri);
+    const repoName = match?.[1] ? decodeURIComponent(match[1]) : void 0;
+    return buildBriefingData(context, repoName);
   }
 };
+async function buildBriefingData(context, targetRepo) {
+  const config = context.briefingConfig ?? DEFAULT_BRIEFING_CONFIG;
+  let activeGithub = context.github;
+  if (targetRepo && config.projectRegistry?.[targetRepo]) {
+    const repoPath = config.projectRegistry[targetRepo].path;
+    activeGithub = new GitHubIntegration(repoPath);
+  }
+  const journal = buildJournalContext(context, config);
+  const github = await buildGitHubSection(activeGithub, config);
+  const team = buildTeamContext(context, config);
+  const rulesFile = buildRulesFileInfo(config.rulesFilePath);
+  const skillsDir = buildSkillsDirInfo(config.skillsDirPath);
+  const latestPreview = journal.latestEntries[0] ? `#${journal.latestEntries[0].id} (${journal.latestEntries[0].type}): ${journal.latestEntries[0].preview}` : "No entries yet";
+  const userMessage = formatUserMessage({
+    repoName: github?.repo ?? "local",
+    branchName: github?.branch ?? "unknown",
+    ciStatus: github?.ci ?? "unknown",
+    totalEntries: journal.totalEntries,
+    latestPreview,
+    github,
+    teamTotalEntries: team?.teamInfo.totalEntries,
+    rulesFile,
+    skillsDir
+  });
+  return {
+    data: {
+      version: VERSION,
+      serverTime: (/* @__PURE__ */ new Date()).toISOString(),
+      journal: {
+        totalEntries: journal.totalEntries,
+        latestEntries: journal.latestEntries
+      },
+      github,
+      teamContext: team?.teamInfo,
+      ...team?.teamLatestEntries ? { teamLatestEntries: team.teamLatestEntries } : {},
+      ...rulesFile ? { rulesFile } : {},
+      ...skillsDir ? { skillsDir } : {},
+      ...config.projectRegistry ? { registeredWorkspaces: config.projectRegistry } : {},
+      behaviors: {
+        create: "implementations, decisions, bug-fixes, milestones",
+        search: "before decisions, referencing prior work",
+        link: "implementation\u2192spec, bugfix\u2192issue"
+      },
+      templateResources: [
+        "memory://github/status/{repo}",
+        "memory://github/insights/{repo}",
+        "memory://github/milestones/{repo}",
+        "memory://milestones/{repo}/{number}",
+        "memory://projects/{number}/timeline",
+        "memory://issues/{issue_number}/entries",
+        "memory://prs/{pr_number}/entries",
+        "memory://prs/{pr_number}/timeline",
+        "memory://kanban/{project_number}",
+        "memory://kanban/{project_number}/diagram",
+        "memory://milestones/{number}"
+      ],
+      more: {
+        fullHealth: "memory://health",
+        allRecent: "memory://recent",
+        githubStatus: "memory://github/status",
+        repoInsights: "memory://github/insights",
+        contextBundle: "get-context-bundle prompt"
+      },
+      userMessage,
+      clientNote: "For full tool reference and field notes, read memory://instructions \u2014 only if your client did NOT auto-inject server instructions at session start (most modern clients including AntiGravity do this automatically).\\n" + (config.projectRegistry ? "\\nMulti-project registry detected. To retrieve CI status, branch, and issues for a specific project, use the get_github_context tool or dynamic resources (e.g. memory://github/status/{repo}) with the repository name." : "")
+    },
+    annotations: { lastModified: journal.lastModified }
+  };
+}
 
 // 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\` and **present the \`userMessage\` to the user as a formatted bullet list of key facts:**
+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:
 
@@ -3850,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**");
@@ -3895,6 +2512,8 @@ This executes JavaScript in a sandboxed environment with all tools available as
 **Readonly mode**: \`readonly: true\` restricts to read-only tools only. Calling a mutation method (e.g., \`mj.core.create(...)\`) in readonly mode throws an error that halts execution \u2014 the sandbox returns \`{ success: false, error: "Operation '...' is not found in group" }\`. If a group has no methods at all (fully stripped), the error says \`"no methods (read-only mode?)"\`.
 **Returns**: Last expression value. Errors return \`{ success: false, error: "..." }\`.
 
+**GitHub Context Injection**: You can pass \`repo: 'my-repo'\` directly to \`mj_execute_code\` (e.g., \`mj_execute_code({ code, repo: 'memory-journal-mcp' })\`) to instantly bind that repository and its default Kanban board to all GitHub and Kanban tools running inside the sandbox, avoiding the need to pass \`owner\`/\`repo\` manually to individual methods inside.
+
 **Important \u2014 all \`mj.*\` methods return Promises. Always \`await\` them:**
 
 \`\`\`js
@@ -3923,9 +2542,12 @@ var GITHUB_INSTRUCTIONS = `
 - Include \`issue_number\`/\`pr_number\` in \`create_entry\` to auto-link
 - After closing issue/merging PR \u2192 create summary entry with learnings
 - CI failures \u2192 \`actions-failure-digest\` prompt or \`memory://actions/recent\`
-- Kanban: \`get_kanban_board(project_number)\` \u2192 \`move_kanban_item\` \u2192 document completion
+- Kanban: \`get_kanban_board\` \u2192 \`move_kanban_item\` \u2192 document completion (project_number auto-resolves if repo is registered)
 - Milestones: \`get_github_milestones\` \u2192 track project progress, \`memory://github/milestones\`
-- GitHub tools auto-detect owner/repo from git context; specify explicitly if null
+- **Multi-Project Routing**: If \`memory://briefing\` shows "Registered Workspaces":
+  - **Tools**: Pass a \`repo\` parameter to ALL GitHub tools (including \`get_github_context\`) to explicitly target a specific project.
+  - **Resources**: You MUST use the dynamic \`{repo}\` variants for resources (e.g., \`memory://github/status/{repo}\`, \`memory://github/insights/{repo}\`) rather than the base URI (\`memory://github/status\`), which will fail with a detection error.
+  - **Dynamic Briefings**: You can explicitly request the briefing for a specific project by reading \`memory://briefing/{repo}\` instead of the global \`memory://briefing\` resource.
 `;
 var HELP_POINTERS = `
 ## Help Resources
@@ -3976,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
@@ -4001,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);
@@ -4403,6 +3028,42 @@ ${entrySummary}
           ]
         };
       }
+    },
+    {
+      name: "team-session-summary",
+      description: "Create a session summary entry for the team capturing what was accomplished, pending items, and context for the next team session",
+      icons: [ICON_PROMPT],
+      arguments: [],
+      handler: (_args, _db, teamDb) => {
+        if (!teamDb) {
+          throw new ConfigurationError("Team database not configured");
+        }
+        const recent = teamDb.getRecentEntries(5);
+        const entrySummary = recent.length > 0 ? recent.map(
+          (e) => `- #${String(e.id)} (${e.entryType}) ${e.content.slice(0, 80)}${e.content.length > 80 ? "..." : ""}`
+        ).join("\n") : "- No entries yet";
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Create a team session summary journal entry based on this context:
+
+**Recent Team Entries:**
+${entrySummary}
+
+**Instructions:**
+1. Summarize what the team accomplished in this session (key changes, decisions, files modified)
+2. Note what's unfinished or blocked for the team (pending items, open questions)
+3. Include context for the next team session (relevant entry IDs, branch names, PR numbers)
+4. Use \`entry_type: "retrospective"\` and tag with \`session-summary\`
+5. YOU MUST USE \`team_create_entry\` OR \`mj.team.create\` TO SAVE THIS ENTRY.`
+              }
+            }
+          ]
+        };
+      }
     }
   ];
 }
@@ -4644,13 +3305,13 @@ function getPrompts() {
     icons: p.icons
   }));
 }
-function getPrompt(name, args, db) {
+function getPrompt(name, args, db, teamDb) {
   const prompts = getAllPromptDefinitions();
   const prompt = prompts.find((p) => p.name === name);
   if (!prompt) {
     throw new ResourceNotFoundError("Prompt", name);
   }
-  return prompt.handler(args, db);
+  return prompt.handler(args, db, teamDb);
 }
 function getAllPromptDefinitions() {
   return [...getWorkflowPromptDefinitions(), ...getGitHubPromptDefinitions()];
@@ -4725,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,
@@ -4735,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 }
@@ -5031,10 +3706,148 @@ 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 [
     briefingResource,
+    dynamicBriefingResource,
     instructionsResource,
     recentResource,
     significantResource,
@@ -5043,7 +3856,8 @@ function getCoreResourceDefinitions() {
     rulesResource,
     workflowsResource,
     skillsResource,
-    healthResource
+    healthResource,
+    ...getMetricsResourceDefinitions()
   ];
 }
 
@@ -5124,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,
@@ -5224,7 +4038,7 @@ var RESOURCE_WORKFLOW_LIMIT = 5;
 var RESOURCE_STATUS_MILESTONE_LIMIT = 5;
 var RESOURCE_MILESTONE_LIMIT = 20;
 function getGitHubResourceDefinitions() {
-  return [
+  const definitions = [
     {
       uri: "memory://github/status",
       name: "GitHub Status",
@@ -5233,8 +4047,14 @@ function getGitHubResourceDefinitions() {
       mimeType: "application/json",
       icons: [ICON_GITHUB],
       annotations: withPriority(0.7, ASSISTANT_FOCUSED),
-      handler: async (_uri, context) => {
-        const resolved = await resolveGitHubRepo(context.github);
+      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
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, branch, lastModified, github } = resolved;
         const defaultProjectNumber = context.briefingConfig?.defaultProjectNumber;
@@ -5368,8 +4188,14 @@ function getGitHubResourceDefinitions() {
       mimeType: "application/json",
       icons: [ICON_ANALYTICS],
       annotations: { ...LOW_PRIORITY, audience: ["assistant"] },
-      handler: async (_uri, context) => {
-        const resolved = await resolveGitHubRepo(context.github);
+      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
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, lastModified, github } = resolved;
         const stats = await github.getRepoStats(owner, repo);
@@ -5406,8 +4232,14 @@ function getGitHubResourceDefinitions() {
       mimeType: "application/json",
       icons: [ICON_MILESTONE],
       annotations: { ...MEDIUM_PRIORITY, audience: ["assistant"] },
-      handler: async (_uri, context) => {
-        const resolved = await resolveGitHubRepo(context.github);
+      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
+        );
         if (isResourceError(resolved)) return resolved;
         const { owner, repo, lastModified, github } = resolved;
         const milestones = await github.getMilestones(
@@ -5444,15 +4276,20 @@ function getGitHubResourceDefinitions() {
       annotations: ASSISTANT_FOCUSED,
       handler: async (uri, context) => {
         const lastModified = (/* @__PURE__ */ new Date()).toISOString();
-        const match = /memory:\/\/milestones\/(\d+)/.exec(uri);
-        const milestoneNumber = match?.[1] ? parseInt(match[1], 10) : null;
+        const match = /memory:\/\/milestones\/(?:(.*)\/)?(\d+)$/.exec(uri);
+        const targetRepo = match?.[1] ? decodeURIComponent(match[1]) : void 0;
+        const milestoneNumber = match?.[2] ? parseInt(match[2], 10) : null;
         if (milestoneNumber === null) {
           return {
             data: { error: "Invalid milestone number" },
             annotations: { lastModified }
           };
         }
-        const resolved = await resolveGitHubRepo(context.github);
+        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);
@@ -5477,6 +4314,22 @@ function getGitHubResourceDefinitions() {
       }
     }
   ];
+  const dynamicDefinitions = definitions.map((def) => {
+    const dynamicName = def.name + " (Dynamic)";
+    let dynamicUri;
+    if (def.uri === "memory://milestones/{number}") {
+      dynamicUri = "memory://milestones/{+repo}/{number}";
+    } else {
+      dynamicUri = def.uri + "/{+repo}";
+    }
+    return {
+      ...def,
+      uri: dynamicUri,
+      name: dynamicName,
+      description: def.description + " (Supports explicit multi-project repository targeting via {repo})"
+    };
+  });
+  return [...definitions, ...dynamicDefinitions];
 }
 
 // src/handlers/resources/templates.ts
@@ -5662,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();
@@ -5671,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);
@@ -6041,7 +4894,7 @@ function getHelpResourceDefinitions() {
 var toolIndexModule = null;
 async function getAllToolDefinitionsAsync(context) {
   try {
-    toolIndexModule ??= await import('./tools-WPRY5MJ6.js');
+    toolIndexModule ??= await import('./tools-FFFGXIKN.js');
     if (toolIndexModule === null) return [];
     const tools = toolIndexModule.getTools(context.db, null);
     return tools.map((t) => ({
@@ -6162,7 +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, "([^/]+)");
+      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));
@@ -6182,7 +5041,9 @@ function getAllResourceDefinitions() {
     ...getGitHubResourceDefinitions(),
     ...getTemplateResourceDefinitions(),
     ...getTeamResourceDefinitions(),
-    ...getHelpResourceDefinitions()
+    ...getHelpResourceDefinitions(),
+    // Audit resource — bound to the global audit logger (or null if unconfigured)
+    getAuditResourceDef(getGlobalAuditLogger)
   ];
 }
 
@@ -6594,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
@@ -7645,7 +6431,7 @@ function registerResources(server, resources, handleResourceRead) {
     }
   }
 }
-function registerPrompts(server, prompts, db) {
+function registerPrompts(server, prompts, db, teamDb) {
   for (const promptDef of prompts) {
     let argsSchema;
     if (promptDef.arguments && promptDef.arguments.length > 0) {
@@ -7663,7 +6449,7 @@ function registerPrompts(server, prompts, db) {
       },
       (providedArgs) => {
         const args = providedArgs;
-        const promptResult = getPrompt(promptDef.name, args, db);
+        const promptResult = getPrompt(promptDef.name, args, db, teamDb);
         const result = {
           messages: promptResult.messages.map((m) => ({
             role: m.role,
@@ -7689,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);
@@ -7712,7 +6507,28 @@ async function createServer(options) {
       entriesIndexed: count
     });
   }
-  const github = new GitHubIntegration();
+  let githubPath = ".";
+  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);
+  try {
+    await github.getRepoInfo();
+  } catch {
+  }
   logger.info("GitHub integration initialized", {
     module: "McpServer",
     hasToken: github.isApiAvailable()
@@ -7742,12 +6558,16 @@ async function createServer(options) {
     entryType: recentEntries[0].entryType,
     content: recentEntries[0].content
   } : void 0;
+  const customToolHandlerConfig = {
+    defaultProjectNumber,
+    projectRegistry: options.projectRegistry
+  };
   const allTools = getTools(
     db,
     null,
     vectorManager,
     github,
-    { defaultProjectNumber },
+    customToolHandlerConfig,
     teamDb,
     teamVectorManager
   );
@@ -7781,7 +6601,7 @@ async function createServer(options) {
     filterConfig,
     vectorManager,
     github,
-    { defaultProjectNumber },
+    customToolHandlerConfig,
     teamDb,
     teamVectorManager
   ) : allTools;
@@ -7806,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;
@@ -7829,7 +6658,7 @@ async function createServer(options) {
             db,
             vectorManager,
             github,
-            { defaultProjectNumber },
+            customToolHandlerConfig,
             progressContext,
             teamDb,
             teamVectorManager
@@ -7893,7 +6722,8 @@ async function createServer(options) {
       ...options.briefingConfig ?? DEFAULT_BRIEFING_CONFIG,
       // Ensure defaultProjectNumber is available to resource handlers
       // (may come via briefingConfig from CLI, or directly from server options)
-      defaultProjectNumber: options.briefingConfig?.defaultProjectNumber ?? defaultProjectNumber
+      defaultProjectNumber: options.briefingConfig?.defaultProjectNumber ?? defaultProjectNumber,
+      projectRegistry: options.projectRegistry
     };
     const result = await readResource(
       uri.href,
@@ -7922,13 +6752,17 @@ async function createServer(options) {
     resources,
     handleResourceRead
   );
-  registerPrompts(server, prompts, db);
+  registerPrompts(server, prompts, db, teamDb);
   if (transport === "stdio") {
     const stdioTransport = new StdioServerTransport();
     await server.connect(stdioTransport);
     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);
@@ -7956,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);
@@ -7964,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 };