memory-journal-mcp 7.2.0 → 7.4.0

package/dist/{chunk-GR4T3SRW.js → chunk-5ZA77VUW.js}

@@ -1,5 +1,5 @@
-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-ORV7ZZOE.js';
-import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-IWKLHSPU.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-P5V2VY6N.js';
+import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-WXDEVIFL.js';
 import { createRequire } from 'module';
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -99,6 +99,17 @@ CREATE INDEX IF NOT EXISTS idx_relationships_to ON relationships(to_entry_id);
 -- Composite covering index for getRecentEntries (WHERE deleted_at IS NULL ORDER BY timestamp DESC, id DESC)
 CREATE INDEX IF NOT EXISTS idx_memory_journal_recent ON memory_journal(deleted_at, timestamp DESC, id DESC);
 
+-- Analytics snapshots for persisted digest data across server restarts
+CREATE TABLE IF NOT EXISTS analytics_snapshots (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    snapshot_type TEXT NOT NULL DEFAULT 'digest',
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    data TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_analytics_snapshots_type_created
+    ON analytics_snapshots(snapshot_type, created_at DESC);
+
 -- FTS5 full-text search index (content-sync: reads from source table, no duplicate storage)
 CREATE VIRTUAL TABLE IF NOT EXISTS fts_content USING fts5(
     content,
@@ -481,12 +492,16 @@ function rowsToEntries(tagsMgr, rows) {
   if (rows.length === 0) return [];
   const entries = rows.map((r) => {
     const p = r;
-    return {
-      ...p,
+    const { importanceScore, ...rest } = p;
+    const entry = {
+      ...rest,
       isPersonal: Boolean(p.isPersonal),
       // SQLite uses 0/1
-      tags: []
+      tags: [],
+      // Attach importanceScore if the query computed it (importance-sorted results)
+      ...importanceScore !== void 0 ? { importanceScore: Math.round(importanceScore * 100) / 100 } : {}
     };
+    return entry;
   });
   const ids = entries.map((e) => e.id);
   const tagsMap = tagsMgr.batchGetTagsForEntries(ids);
@@ -500,6 +515,12 @@ function rowToObject(row) {
   if (typeof row !== "object") return void 0;
   return row;
 }
+function queryRow(db, sql, ...params) {
+  return db.prepare(sql).get(...params);
+}
+function queryRows(db, sql, ...params) {
+  return db.prepare(sql).all(...params);
+}
 
 // src/database/sqlite-adapter/entries/crud.ts
 function createEntry(context, input) {
@@ -671,9 +692,92 @@ function deleteEntry(context, id, permanent = false) {
   return result.changes > 0;
 }
 
+// src/database/sqlite-adapter/entries/importance.ts
+var IMPORTANCE_WEIGHTS = {
+  significance: 0.3,
+  relationships: 0.35,
+  causal: 0.2,
+  recency: 0.15
+};
+var MAX_RELATIONSHIP_SCORE_AT = 5;
+var MAX_CAUSAL_SCORE_AT = 3;
+var RECENCY_WINDOW_DAYS = 90;
+function buildImportanceSqlExpression() {
+  const w = IMPORTANCE_WEIGHTS;
+  return `(
+    CASE WHEN e.significance_type IS NOT NULL THEN ${String(w.significance)} ELSE 0.0 END
+    + MIN(
+        COALESCE((SELECT COUNT(*) FROM relationships
+                  WHERE from_entry_id = e.id OR to_entry_id = e.id), 0) * 1.0 / ${String(MAX_RELATIONSHIP_SCORE_AT)},
+        1.0
+      ) * ${String(w.relationships)}
+    + MIN(
+        COALESCE((SELECT COUNT(*) FROM relationships
+                  WHERE (from_entry_id = e.id OR to_entry_id = e.id)
+                  AND relationship_type IN ('blocked_by', 'resolved', 'caused')), 0) * 1.0 / ${String(MAX_CAUSAL_SCORE_AT)},
+        1.0
+      ) * ${String(w.causal)}
+    + MAX(0, 1.0 - (julianday('now') - julianday(e.timestamp)) / ${String(RECENCY_WINDOW_DAYS)}.0) * ${String(w.recency)}
+  )`;
+}
+function calculateImportance(context, entryId) {
+  const { db } = context;
+  const round2 = (n) => Math.round(n * 100) / 100;
+  const stmt = db.prepare(`SELECT
+        m.significance_type as significanceType,
+        m.timestamp,
+        (SELECT COUNT(*) FROM relationships
+         WHERE from_entry_id = ? OR to_entry_id = ?) AS rel_count,
+        (SELECT COUNT(*) FROM relationships
+         WHERE (from_entry_id = ? OR to_entry_id = ?)
+         AND relationship_type IN ('blocked_by', 'resolved', 'caused')) AS causal_count
+    FROM memory_journal m
+    WHERE m.id = ? AND m.deleted_at IS NULL`);
+  const row = rowToObject(stmt.get(entryId, entryId, entryId, entryId, entryId));
+  if (!row) {
+    return {
+      score: 0,
+      breakdown: { significance: 0, relationships: 0, causal: 0, recency: 0 }
+    };
+  }
+  const significanceType = row["significanceType"];
+  const timestamp = row["timestamp"];
+  const relCount = row["rel_count"] ?? 0;
+  const causalCount = row["causal_count"] ?? 0;
+  const significanceRaw = significanceType ? 1 : 0;
+  const relationshipsRaw = Math.min(relCount / MAX_RELATIONSHIP_SCORE_AT, 1);
+  const causalRaw = Math.min(causalCount / MAX_CAUSAL_SCORE_AT, 1);
+  const entryDate = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const daysSince = Math.floor((now.getTime() - entryDate.getTime()) / (1e3 * 60 * 60 * 24));
+  const recencyRaw = Math.max(0, 1 - daysSince / RECENCY_WINDOW_DAYS);
+  const w = IMPORTANCE_WEIGHTS;
+  const breakdown = {
+    significance: round2(significanceRaw * w.significance),
+    relationships: round2(relationshipsRaw * w.relationships),
+    causal: round2(causalRaw * w.causal),
+    recency: round2(recencyRaw * w.recency)
+  };
+  const score = round2(
+    significanceRaw * w.significance + relationshipsRaw * w.relationships + causalRaw * w.causal + recencyRaw * w.recency
+  );
+  return { score, breakdown };
+}
+
 // src/database/sqlite-adapter/entries/search.ts
-function getRecentEntries(context, limit) {
+function getRecentEntries(context, limit, sortBy = "timestamp") {
   const { db, tagsMgr } = context;
+  if (sortBy === "importance") {
+    const importanceExpr = buildImportanceSqlExpression();
+    const stmt2 = db.prepare(`
+            SELECT ${ALIASED_ENTRY_COLUMNS}, ${importanceExpr} AS importanceScore
+            FROM memory_journal e
+            WHERE e.deleted_at IS NULL
+            ORDER BY importanceScore DESC, e.timestamp DESC, e.id DESC LIMIT ?
+        `);
+    const rows2 = stmt2.all([limit]);
+    return rowsToEntries(tagsMgr, rows2);
+  }
   const stmt = db.prepare(`
         SELECT ${ENTRY_COLUMNS} FROM memory_journal 
         WHERE deleted_at IS NULL 
@@ -712,15 +816,17 @@ function searchEntries(context, queryStr, options) {
 }
 function buildSearchQuery(queryStr, options, useFts) {
   let query;
+  const useImportance = options?.sortBy === "importance";
+  const importanceCol = useImportance ? `, ${buildImportanceSqlExpression()} AS importanceScore` : "";
   if (useFts) {
     query = `
-            SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS}
+            SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS}${importanceCol}
             FROM memory_journal e
             JOIN fts_content fts ON fts.rowid = e.id
         `;
   } else {
     query = `
-            SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS} 
+            SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS}${importanceCol}
             FROM memory_journal e
         `;
   }
@@ -789,7 +895,9 @@ function buildSearchQuery(queryStr, options, useFts) {
   if (conditions.length > 0) {
     query += ` WHERE ${conditions.join(" AND ")}`;
   }
-  if (useFts) {
+  if (useImportance) {
+    query += ` ORDER BY importanceScore DESC, e.timestamp DESC, e.id DESC`;
+  } else if (useFts) {
     query += ` ORDER BY rank, e.timestamp DESC, e.id DESC`;
   } else {
     query += ` ORDER BY e.timestamp DESC, e.id DESC`;
@@ -810,8 +918,10 @@ function searchByDateRange(context, startDate, endDate, options) {
     if (!end.includes("T")) end += "T23:59:59.999Z";
     params.push(end);
   }
+  const useImportance = options?.sortBy === "importance";
+  const importanceCol = useImportance ? `, ${buildImportanceSqlExpression()} AS importanceScore` : "";
   let query = `
-        SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS} FROM memory_journal e
+        SELECT DISTINCT ${ALIASED_ENTRY_COLUMNS}${importanceCol} FROM memory_journal e
     `;
   if (options?.tags && options.tags.length > 0) {
     query += `
@@ -846,7 +956,11 @@ function searchByDateRange(context, startDate, endDate, options) {
     conditions.push(`e.workflow_run_id = ?`);
     params.push(options.workflowRunId);
   }
-  query += ` WHERE ${conditions.join(" AND ")} ORDER BY e.timestamp DESC, e.id DESC`;
+  if (useImportance) {
+    query += ` WHERE ${conditions.join(" AND ")} ORDER BY importanceScore DESC, e.timestamp DESC, e.id DESC`;
+  } else {
+    query += ` WHERE ${conditions.join(" AND ")} ORDER BY e.timestamp DESC, e.id DESC`;
+  }
   query += ` LIMIT ?`;
   params.push(options?.limit ?? 500);
   const stmt = db.prepare(query);
@@ -866,60 +980,6 @@ function sanitizeFtsQuery(query) {
   return query;
 }
 
-// src/database/sqlite-adapter/entries/importance.ts
-var IMPORTANCE_WEIGHTS = {
-  significance: 0.3,
-  relationships: 0.35,
-  causal: 0.2,
-  recency: 0.15
-};
-var MAX_RELATIONSHIP_SCORE_AT = 5;
-var MAX_CAUSAL_SCORE_AT = 3;
-var RECENCY_WINDOW_DAYS = 90;
-function calculateImportance(context, entryId) {
-  const { db } = context;
-  const round2 = (n) => Math.round(n * 100) / 100;
-  const stmt = db.prepare(`SELECT
-        m.significance_type as significanceType,
-        m.timestamp,
-        (SELECT COUNT(*) FROM relationships
-         WHERE from_entry_id = ? OR to_entry_id = ?) AS rel_count,
-        (SELECT COUNT(*) FROM relationships
-         WHERE (from_entry_id = ? OR to_entry_id = ?)
-         AND relationship_type IN ('blocked_by', 'resolved', 'caused')) AS causal_count
-    FROM memory_journal m
-    WHERE m.id = ? AND m.deleted_at IS NULL`);
-  const row = rowToObject(stmt.get(entryId, entryId, entryId, entryId, entryId));
-  if (!row) {
-    return {
-      score: 0,
-      breakdown: { significance: 0, relationships: 0, causal: 0, recency: 0 }
-    };
-  }
-  const significanceType = row["significanceType"];
-  const timestamp = row["timestamp"];
-  const relCount = row["rel_count"] ?? 0;
-  const causalCount = row["causal_count"] ?? 0;
-  const significanceRaw = significanceType ? 1 : 0;
-  const relationshipsRaw = Math.min(relCount / MAX_RELATIONSHIP_SCORE_AT, 1);
-  const causalRaw = Math.min(causalCount / MAX_CAUSAL_SCORE_AT, 1);
-  const entryDate = new Date(timestamp);
-  const now = /* @__PURE__ */ new Date();
-  const daysSince = Math.floor((now.getTime() - entryDate.getTime()) / (1e3 * 60 * 60 * 24));
-  const recencyRaw = Math.max(0, 1 - daysSince / RECENCY_WINDOW_DAYS);
-  const w = IMPORTANCE_WEIGHTS;
-  const breakdown = {
-    significance: round2(significanceRaw * w.significance),
-    relationships: round2(relationshipsRaw * w.relationships),
-    causal: round2(causalRaw * w.causal),
-    recency: round2(recencyRaw * w.recency)
-  };
-  const score = round2(
-    significanceRaw * w.significance + relationshipsRaw * w.relationships + causalRaw * w.causal + recencyRaw * w.recency
-  );
-  return { score, breakdown };
-}
-
 // src/database/sqlite-adapter/entries/statistics.ts
 var MAX_PERIOD_ROWS = 52;
 function getStatistics(context, groupBy = "week", startDate, endDate, projectBreakdown) {
@@ -1068,11 +1128,11 @@ var EntriesManager = class {
   deleteEntry(id, permanent = false) {
     return deleteEntry(this.sharedContext, id, permanent);
   }
-  getRecentEntries(limit = 10, isPersonal) {
+  getRecentEntries(limit = 10, isPersonal, sortBy) {
     if (isPersonal !== void 0) {
-      return searchEntries(this.sharedContext, "", { limit, isPersonal });
+      return searchEntries(this.sharedContext, "", { limit, isPersonal, sortBy });
     }
-    return getRecentEntries(this.sharedContext, limit);
+    return getRecentEntries(this.sharedContext, limit, sortBy);
   }
   getEntriesPage(offset, limit, order = "desc") {
     return getEntriesPage(this.sharedContext, offset, limit, order);
@@ -1242,6 +1302,143 @@ var BackupManager = class {
     return { restoredFrom: filename, previousEntryCount, newEntryCount };
   }
 };
+
+// src/database/sqlite-adapter/entries/digest.ts
+var STALE_PROJECT_THRESHOLD_DAYS = 14;
+var PREVIEW_LENGTH = 80;
+var TOP_IMPORTANCE_COUNT = 3;
+function computeDigest(db) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const activityRow = queryRow(
+    db,
+    `SELECT
+            COALESCE(SUM(CASE WHEN strftime('%Y-%m', timestamp) = strftime('%Y-%m', 'now') THEN 1 ELSE 0 END), 0) AS current_count,
+            COALESCE(SUM(CASE WHEN strftime('%Y-%m', timestamp) = strftime('%Y-%m', 'now', '-1 month') THEN 1 ELSE 0 END), 0) AS previous_count
+        FROM memory_journal
+        WHERE deleted_at IS NULL`
+  );
+  const currentPeriodEntries = activityRow?.["current_count"] ?? 0;
+  const previousPeriodEntries = activityRow?.["previous_count"] ?? 0;
+  const activityGrowthPercent = previousPeriodEntries > 0 ? Math.round(
+    (currentPeriodEntries - previousPeriodEntries) / previousPeriodEntries * 100
+  ) : null;
+  const sigRow = queryRow(
+    db,
+    `SELECT
+            COALESCE(SUM(CASE
+                WHEN significance_type IS NOT NULL AND strftime('%Y-%m', timestamp) = strftime('%Y-%m', 'now')
+                THEN 1 ELSE 0 END), 0) AS current_significant,
+            COUNT(DISTINCT strftime('%Y-%m', timestamp)) AS total_periods,
+            COALESCE(SUM(CASE WHEN significance_type IS NOT NULL THEN 1 ELSE 0 END), 0) AS total_significant
+        FROM memory_journal
+        WHERE deleted_at IS NULL`
+  );
+  const currentPeriodSignificant = sigRow?.["current_significant"] ?? 0;
+  const totalPeriods = sigRow?.["total_periods"] ?? 1;
+  const totalSignificant = sigRow?.["total_significant"] ?? 0;
+  const historicalAvgSignificant = totalPeriods > 0 ? Math.round(totalSignificant / totalPeriods * 10) / 10 : 0;
+  const significanceMultiplier = historicalAvgSignificant > 0 ? Math.round(currentPeriodSignificant / historicalAvgSignificant * 10) / 10 : null;
+  const staleRows = queryRows(
+    db,
+    `SELECT
+            project_number,
+            MAX(timestamp) AS last_entry_date,
+            CAST(julianday('now') - julianday(MAX(timestamp)) AS INTEGER) AS days_silent
+        FROM memory_journal
+        WHERE deleted_at IS NULL AND project_number IS NOT NULL
+        GROUP BY project_number
+        HAVING days_silent > ?`,
+    STALE_PROJECT_THRESHOLD_DAYS
+  );
+  const staleProjects = staleRows.map((r) => ({
+    projectNumber: r["project_number"],
+    lastEntryDate: r["last_entry_date"],
+    daysSilent: r["days_silent"]
+  }));
+  const relDensityRow = queryRow(
+    db,
+    `SELECT
+            COALESCE((SELECT COUNT(*) FROM relationships r
+                JOIN memory_journal m ON r.from_entry_id = m.id
+                WHERE strftime('%Y-%m', m.timestamp) = strftime('%Y-%m', 'now')
+            ), 0) AS current_rels,
+            COALESCE((SELECT COUNT(*) FROM relationships r
+                JOIN memory_journal m ON r.from_entry_id = m.id
+                WHERE strftime('%Y-%m', m.timestamp) = strftime('%Y-%m', 'now', '-1 month')
+            ), 0) AS previous_rels`
+  );
+  const currentRels = relDensityRow?.["current_rels"] ?? 0;
+  const previousRels = relDensityRow?.["previous_rels"] ?? 0;
+  const currentRelDensity = currentPeriodEntries > 0 ? Math.round(currentRels / currentPeriodEntries * 100) / 100 : 0;
+  const previousRelDensity = previousPeriodEntries > 0 ? Math.round(previousRels / previousPeriodEntries * 100) / 100 : 0;
+  const importanceExpr = buildImportanceSqlExpression();
+  const topRows = queryRows(
+    db,
+    `SELECT
+            e.id,
+            ${importanceExpr} AS importance_score,
+            SUBSTR(e.content, 1, ${String(PREVIEW_LENGTH)}) AS preview
+        FROM memory_journal e
+        WHERE e.deleted_at IS NULL
+        ORDER BY importance_score DESC
+        LIMIT ${String(TOP_IMPORTANCE_COUNT)}`
+  );
+  const topImportanceEntries = topRows.map((r) => ({
+    id: r["id"],
+    score: Math.round(r["importance_score"] * 100) / 100,
+    preview: r["preview"]
+  }));
+  return {
+    computedAt: now,
+    currentPeriodEntries,
+    previousPeriodEntries,
+    activityGrowthPercent,
+    currentPeriodSignificant,
+    historicalAvgSignificant,
+    significanceMultiplier,
+    staleProjects,
+    currentRelDensity,
+    previousRelDensity,
+    topImportanceEntries
+  };
+}
+function saveAnalyticsSnapshot(db, type, data) {
+  const stmt = db.prepare(`INSERT INTO analytics_snapshots (snapshot_type, data) VALUES (?, ?)`);
+  const result = stmt.run(type, JSON.stringify(data));
+  return Number(result.lastInsertRowid);
+}
+function getLatestAnalyticsSnapshot(db, type) {
+  const row = queryRow(
+    db,
+    `SELECT id, created_at, data FROM analytics_snapshots
+         WHERE snapshot_type = ?
+         ORDER BY created_at DESC
+         LIMIT 1`,
+    type
+  );
+  if (!row) return null;
+  return {
+    id: row["id"],
+    createdAt: row["created_at"],
+    data: JSON.parse(row["data"])
+  };
+}
+function getAnalyticsSnapshots(db, type, limit = 10) {
+  const rows = queryRows(
+    db,
+    `SELECT id, created_at, data FROM analytics_snapshots
+         WHERE snapshot_type = ?
+         ORDER BY created_at DESC
+         LIMIT ?`,
+    type,
+    limit
+  );
+  return rows.map((r) => ({
+    id: r["id"],
+    createdAt: r["created_at"],
+    data: JSON.parse(r["data"])
+  }));
+}
 var DatabaseAdapter2 = class {
   connection;
   tagsMgr;
@@ -1282,8 +1479,8 @@ var DatabaseAdapter2 = class {
   calculateImportance(entryId) {
     return this.entriesMgr.calculateImportance(entryId);
   }
-  getRecentEntries(limit, isPersonal) {
-    return this.entriesMgr.getRecentEntries(limit ?? 10, isPersonal);
+  getRecentEntries(limit, isPersonal, sortBy) {
+    return this.entriesMgr.getRecentEntries(limit ?? 10, isPersonal, sortBy);
   }
   getEntriesPage(offset, limit) {
     return this.entriesMgr.getEntriesPage(offset, limit);
@@ -1392,6 +1589,15 @@ var DatabaseAdapter2 = class {
   executeRawQuery(sql, params) {
     return this.connection.exec(sql, params);
   }
+  saveAnalyticsSnapshot(type, data) {
+    return saveAnalyticsSnapshot(this.connection.getRawDb(), type, data);
+  }
+  getLatestAnalyticsSnapshot(type) {
+    return getLatestAnalyticsSnapshot(this.connection.getRawDb(), type);
+  }
+  getAnalyticsSnapshots(type, limit) {
+    return getAnalyticsSnapshots(this.connection.getRawDb(), type, limit);
+  }
 };
 
 // src/database/adapter-factory.ts
@@ -1540,7 +1746,7 @@ var VectorSearchManager = class {
                      WHERE embedding MATCH ?
                      ORDER BY distance
                      LIMIT ?`
-      ).all(queryVec, limit * 2);
+      ).all(queryVec, limit);
       const filteredResults = results.map((r) => ({
         entryId: r.entry_id,
         score: 1 / (1 + r.distance)
@@ -1593,7 +1799,7 @@ var VectorSearchManager = class {
                      WHERE embedding MATCH ?
                      ORDER BY distance
                      LIMIT ?`
-      ).all(queryVec, (limit + 1) * 2);
+      ).all(queryVec, limit + 1);
       const filteredResults = results.filter((r) => r.entry_id !== entryId).map((r) => ({
         entryId: r.entry_id,
         score: 1 / (1 + r.distance)
@@ -2039,7 +2245,7 @@ async function fetchCopilotReviews(github, owner, repo) {
     return void 0;
   }
 }
-var PREVIEW_LENGTH = 80;
+var PREVIEW_LENGTH2 = 80;
 function buildJournalContext(context, config, projectNumber) {
   const recentEntries = typeof projectNumber === "number" ? context.db.searchEntries("", { limit: config.entryCount, projectNumber }) : context.db.getRecentEntries(config.entryCount);
   const latestEntries = recentEntries.map((e) => {
@@ -2048,7 +2254,7 @@ function buildJournalContext(context, config, projectNumber) {
       id: e.id,
       timestamp: e.timestamp,
       type: e.entryType,
-      preview: content.slice(0, PREVIEW_LENGTH) + (content.length > PREVIEW_LENGTH ? "..." : "")
+      preview: content.slice(0, PREVIEW_LENGTH2) + (content.length > PREVIEW_LENGTH2 ? "..." : "")
     };
   });
   const summaryEntries = typeof projectNumber === "number" ? context.db.searchEntries("", {
@@ -2077,7 +2283,7 @@ function buildJournalContext(context, config, projectNumber) {
         id: entry.id,
         timestamp: entry.timestamp,
         type: entry.entryType,
-        preview: c.slice(0, PREVIEW_LENGTH) + (c.length > PREVIEW_LENGTH ? "..." : "")
+        preview: c.slice(0, PREVIEW_LENGTH2) + (c.length > PREVIEW_LENGTH2 ? "..." : "")
       };
     });
     latestSessionSummary = sessionSummaries[0];
@@ -2178,7 +2384,8 @@ function formatUserMessage(opts) {
     summaryPreviews,
     github,
     rulesFile,
-    skillsDir
+    skillsDir,
+    analyticsInsights
   } = opts;
   let ciDisplay = opts.ciStatus;
   if (github?.workflowSummary) {
@@ -2248,6 +2455,19 @@ function formatUserMessage(opts) {
   }
   const copilotRow = github?.copilotReviews ? `
 | **Copilot** | ${String(github.copilotReviews.reviewed)} reviewed \xB7 ${String(github.copilotReviews.approved)} approved${github.copilotReviews.changesRequested > 0 ? ` \xB7 ${String(github.copilotReviews.changesRequested)} changes requested` : ""}${github.copilotReviews.totalComments > 0 ? ` (${String(github.copilotReviews.totalComments)} comments)` : ""} |` : "";
+  let analyticsRow = "";
+  if (analyticsInsights) {
+    const parts = [];
+    parts.push(`\u{1F4C8} ${analyticsInsights.activityTrend}`);
+    if (analyticsInsights.significanceSpike !== null)
+      parts.push(`\u{1F525} ${analyticsInsights.significanceSpike}`);
+    if (analyticsInsights.relationshipDensity !== void 0 && analyticsInsights.relationshipDensity >= 0)
+      parts.push(`\u{1F517} Matrix Density: ${analyticsInsights.relationshipDensity}`);
+    if (analyticsInsights.staleProjects.length > 0)
+      parts.push(`\u{1F4A4} ${analyticsInsights.staleProjects.length} stale projects`);
+    analyticsRow = `
+| **Analytics** | ${escapeTableCell(parts.join(" \xB7 "))} |`;
+  }
   const summariesOutput = summaryPreviews && summaryPreviews.length > 0 ? summaryPreviews.map((s) => `
 | **Summary** | ${escapeTableCell(s)} |`).join("") : "";
   return `\u{1F4CB} **Session Context Loaded**
@@ -2258,11 +2478,56 @@ function formatUserMessage(opts) {
 | **CI** | ${escapeTableCell(ciDisplay)} |
 | **Journal** | ${totalEntries} entries |${opts.teamTotalEntries !== void 0 ? `
 | **Team DB** | ${opts.teamTotalEntries} entries |` : ""}
-| **Latest** | ${escapeTableCell(latestPreview)} |${summariesOutput}${issuesRow}${prsRow}${milestoneRow}${insightsRow}${copilotRow}${rulesFile ? `
+| **Latest** | ${escapeTableCell(latestPreview)} |${summariesOutput}${issuesRow}${prsRow}${milestoneRow}${insightsRow}${copilotRow}${analyticsRow}${rulesFile ? `
 | **Rules** | ${escapeTableCell(rulesFile.name)} (${String(rulesFile.sizeKB)} KB, updated ${rulesFile.lastModified}) |` : ""}${skillsDir ? `
 | **Skills** | ${String(skillsDir.count)} skill${skillsDir.count !== 1 ? "s" : ""} available |` : ""}`;
 }
 
+// src/handlers/resources/core/briefing/insights-section.ts
+function buildInsightsSection(context) {
+  const snapshot = resolveDigestSnapshot(context);
+  if (!snapshot) return null;
+  return formatDigest(snapshot);
+}
+function resolveDigestSnapshot(context) {
+  const schedulerDigest = context.scheduler?.getLatestDigest?.();
+  if (schedulerDigest) return schedulerDigest;
+  const dbSnapshot = context.db?.getLatestAnalyticsSnapshot?.("digest");
+  if (dbSnapshot) return dbSnapshot.data;
+  return null;
+}
+function formatDigest(snapshot) {
+  let activityTrend;
+  if (snapshot.activityGrowthPercent !== null) {
+    const sign = snapshot.activityGrowthPercent >= 0 ? "+" : "";
+    activityTrend = `${sign}${String(snapshot.activityGrowthPercent)}% vs. last period (${String(snapshot.currentPeriodEntries)} entries)`;
+  } else {
+    activityTrend = `${String(snapshot.currentPeriodEntries)} entries this period (no previous data)`;
+  }
+  let significanceSpike = null;
+  if (snapshot.currentPeriodSignificant > 0) {
+    if (snapshot.significanceMultiplier !== null && snapshot.significanceMultiplier > 1.5) {
+      significanceSpike = `${String(snapshot.currentPeriodSignificant)} significant entries (${String(snapshot.significanceMultiplier)}\xD7 avg)`;
+    } else {
+      significanceSpike = `${String(snapshot.currentPeriodSignificant)} significant entries this period`;
+    }
+  }
+  return {
+    activityTrend,
+    significanceSpike,
+    staleProjects: snapshot.staleProjects.map((p) => ({
+      projectNumber: p.projectNumber,
+      daysSilent: p.daysSilent
+    })),
+    topImportance: snapshot.topImportanceEntries.map((e) => ({
+      id: e.id,
+      score: e.score,
+      preview: e.preview
+    })),
+    ...snapshot.currentRelDensity > 0 ? { relationshipDensity: snapshot.currentRelDensity } : {}
+  };
+}
+
 // src/handlers/resources/core/briefing/index.ts
 var briefingResource = {
   uri: "memory://briefing",
@@ -2309,6 +2574,7 @@ async function buildBriefingData(context, targetRepo) {
   const team = buildTeamContext(context, config, activeProjectNumber);
   const rulesFile = buildRulesFileInfo(config.rulesFilePath);
   const skillsDir = buildSkillsDirInfo(config.skillsDirPath);
+  const insights = buildInsightsSection(context);
   const latestPreview = journal.latestEntries[0] ? `#${journal.latestEntries[0].id} (${journal.latestEntries[0].type}): ${journal.latestEntries[0].preview}` : "No entries yet";
   const summaryPreviews = journal.sessionSummaries ? journal.sessionSummaries.map((s) => `#${s.id} (${s.type}): ${s.preview}`) : null;
   const userMessage = formatUserMessage({
@@ -2321,7 +2587,8 @@ async function buildBriefingData(context, targetRepo) {
     github,
     teamTotalEntries: team?.teamInfo.totalEntries,
     rulesFile,
-    skillsDir
+    skillsDir,
+    analyticsInsights: insights ?? void 0
   });
   return {
     data: {
@@ -2337,6 +2604,7 @@ async function buildBriefingData(context, targetRepo) {
       ...team?.teamLatestEntries ? { teamLatestEntries: team.teamLatestEntries } : {},
       ...rulesFile ? { rulesFile } : {},
       ...skillsDir ? { skillsDir } : {},
+      ...insights ? { insights } : {},
       ...config.projectRegistry ? { registeredWorkspaces: config.projectRegistry } : {},
       behaviors: {
         create: "implementations, decisions, bug-fixes, milestones",
@@ -2387,7 +2655,7 @@ var CORE_INSTRUCTIONS = `# memory-journal-mcp
 - 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)
+- Optional metadata present (rulesFile, skillsDir, workflowSummary, copilotReviews, Team DB, insights)
 
 - **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\`
@@ -2399,8 +2667,8 @@ var CORE_INSTRUCTIONS = `# memory-journal-mcp
 
 - **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.
+- **Search before**: major decisions, referencing prior work, understanding project context. Use \`sort_by: "importance"\` on \`search_entries\`, \`get_recent_entries\`, or \`search_by_date_range\` to surface structurally significant entries (decisions, milestones, highly-connected nodes) over simply recent ones.
+- **Analyze insights**: Use cross-project insights (\`get_cross_project_insights\`) before defining architectures. Use \`team_get_collaboration_matrix\` to evaluate team health, cross-author activity patterns, and collaboration impact. Use repo insights (\`memory://github/insights\`) to gauge traction. View \`memory://insights/digest\` and \`memory://insights/team-collaboration\` for automated analytics snapshots.
 - **Link entries**: implementation\u2192spec, bugfix\u2192issue, followup\u2192prior work
 
 ### Rule & Skill Suggestions
@@ -2436,7 +2704,7 @@ When you notice the user consistently applies patterns, preferences, or workflow
 
 ### Native Agent Skills (NPM Distribution)
 
-This server leverages the \`neverinfamous-agent-skills\` package. If the user's \`SKILLS_DIR_PATH\` environment variable targets these, you have native access to foundational frameworks (\`mastering-typescript\`, \`react-best-practices\`, \`playwright-standard\`, \`golang\`, \`rust\`, \`shadcn-ui\`) and the \`github-commander\` DevOps workflows (\`issue-triage\`, \`pr-review\`, etc.).
+This server leverages the \`neverinfamous-agent-skills\` package. If the user's \`SKILLS_DIR_PATH\` environment variable targets these, you have native access to foundational frameworks (\`mastering-typescript\`, \`react-best-practices\`, \`playwright-standard\`, \`golang\`, \`rust\`, \`python\`, \`docker\`, \`tailwind-css\`, \`shadcn-ui\`) and the \`github-commander\` DevOps workflows (\`issue-triage\`, \`pr-review\`, \`github-actions\`, etc.).
 
 - The user can distribute or update these skills across their repositories by running \`npx neverinfamous-agent-skills@latest\`.
 - If you need to create a new skill, reference the bundled \`skill-builder\` instructions!
@@ -2476,18 +2744,71 @@ 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: "io", label: "IO", namespace: "`mj.io.*`", example: '`mj.io.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: "io",
+    label: "IO",
+    namespace: "`mj.io.*`",
+    example: '`mj.io.importMarkdown("content")`'
+  },
+  {
+    group: "io",
+    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**");
@@ -2511,7 +2832,8 @@ This executes JavaScript in a sandboxed environment with all tools available as
 | Search        | \`mj.search.*\`        | \`mj.search.searchEntries("performance")\`           |
 | Analytics     | \`mj.analytics.*\`     | \`mj.analytics.getStatistics()\`                     |
 | Relationships | \`mj.relationships.*\` | \`mj.relationships.linkEntries(1, 2, "implements")\` |
-| IO            | \`mj.io.*\`            | \`mj.io.exportEntries("json")\`                      |
+| IO            | \`mj.io.*\`            | \`mj.io.importMarkdown("content")\`                  |
+| Export        | \`mj.export.*\`        | \`mj.export.exportEntries("json")\`                  |
 | Admin         | \`mj.admin.*\`         | \`mj.admin.rebuildVectorIndex()\`                    |
 | GitHub        | \`mj.github.*\`        | \`mj.github.getGithubIssues({ state: "open" })\`     |
 | Backup        | \`mj.backup.*\`        | \`mj.backup.backupJournal()\`                        |
@@ -2635,7 +2957,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 22 team tools return \`{ success: false, error: "Team collaboration is not configured..." }\` \u2014 no crash, no partial results.
+- **Team tools without \`TEAM_DB_PATH\`**: All 23 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);
@@ -2743,13 +3065,14 @@ ${entries.map((e) => `- [${String(e.id)}] ${e.content.slice(0, 100)}...`).join("
         const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "";
         const yesterday = new Date(Date.now() - MS_PER_DAY2).toISOString().split("T")[0] ?? "";
         const entries = db.searchByDateRange(yesterday, today);
+        const digestSignal = buildDigestSignalForPrompt(db);
         return {
           messages: [
             {
               role: "user",
               content: {
                 type: "text",
-                text: `Prepare a standup summary based on these recent entries:
+                text: `${digestSignal}Prepare a standup summary based on these recent entries:
 
 ${entries.map((e) => `[${e.timestamp}] ${e.entryType}: ${e.content}`).join("\n\n")}
 
@@ -2779,13 +3102,14 @@ Format as:
         const endDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "";
         const startDate = new Date(Date.now() - days * MS_PER_DAY2).toISOString().split("T")[0] ?? "";
         const entries = db.searchByDateRange(startDate, endDate);
+        const digestSignal = buildDigestSignalForPrompt(db);
         return {
           messages: [
             {
               role: "user",
               content: {
                 type: "text",
-                text: `Prepare a retrospective for the last ${String(days)} days based on these entries:
+                text: `${digestSignal}Prepare a retrospective for the last ${String(days)} days based on these entries:
 
 ${entries.slice(0, 20).map(
                   (e) => `[${e.timestamp}] ${e.entryType}: ${e.content.slice(0, 200)}`
@@ -3082,6 +3406,34 @@ ${entrySummary}
     }
   ];
 }
+function buildDigestSignalForPrompt(db) {
+  const snapshot = db.getLatestAnalyticsSnapshot?.("digest");
+  if (!snapshot) return "";
+  const data = snapshot.data;
+  const lines = ["[Analytics Context]"];
+  const growth = data["activityGrowthPercent"];
+  const currentEntries = data["currentPeriodEntries"];
+  if (growth !== null && growth !== void 0) {
+    const sign = growth >= 0 ? "+" : "";
+    lines.push(
+      `Activity: ${sign}${String(growth)}% vs. last period (${String(currentEntries)} entries)`
+    );
+  }
+  const sigMultiplier = data["significanceMultiplier"];
+  const sigCount = data["currentPeriodSignificant"];
+  if (sigMultiplier !== null && sigMultiplier !== void 0 && sigMultiplier > 1.5) {
+    lines.push(
+      `Significance: ${String(sigCount)} significant entries (${String(sigMultiplier)}\xD7 historical avg)`
+    );
+  }
+  const stale = data["staleProjects"];
+  if (stale && stale.length > 0) {
+    const staleStr = stale.map((p) => `P${String(p.projectNumber)} (${String(p.daysSilent)}d silent)`).join(", ");
+    lines.push(`\u26A0 Stale: ${staleStr}`);
+  }
+  if (lines.length <= 1) return "";
+  return lines.join("\\n") + "\\n\\n";
+}
 
 // src/handlers/prompts/github.ts
 function formatPromptEntries(entries, maxCount = 50) {
@@ -4173,21 +4525,25 @@ function getGitHubResourceDefinitions() {
             error: kanbanResult.reason
           });
         }
-        let milestoneSummary = null;
-        if (milestoneResult.status === "fulfilled" && milestoneResult.value.length > 0) {
-          milestoneSummary = milestoneResult.value.map((ms) => {
-            const pct = milestoneCompletionPct(ms.openIssues, ms.closedIssues);
-            return {
-              number: ms.number,
-              title: ms.title,
-              state: ms.state,
-              openIssues: ms.openIssues,
-              closedIssues: ms.closedIssues,
-              completionPercentage: pct,
-              dueOn: ms.dueOn
-            };
-          });
+        let milestoneSummary = { openCount: 0, items: [] };
+        if (milestoneResult.status === "fulfilled") {
+          milestoneSummary = {
+            openCount: milestoneResult.value.length,
+            items: milestoneResult.value.map((ms) => {
+              const pct = milestoneCompletionPct(ms.openIssues, ms.closedIssues);
+              return {
+                number: ms.number,
+                title: ms.title,
+                state: ms.state,
+                openIssues: ms.openIssues,
+                closedIssues: ms.closedIssues,
+                completionPercentage: pct,
+                dueOn: ms.dueOn
+              };
+            })
+          };
         } else if (milestoneResult.status === "rejected") {
+          milestoneSummary = null;
           logger.debug("Failed to fetch milestones", {
             module: "RESOURCE",
             operation: "github-status",
@@ -4933,7 +5289,7 @@ function getHelpResourceDefinitions() {
 var toolIndexModule = null;
 async function getAllToolDefinitionsAsync(context) {
   try {
-    toolIndexModule ??= await import('./tools-CXR2FEB2.js');
+    toolIndexModule ??= await import('./tools-WZUENKJ6.js');
     if (toolIndexModule === null) return [];
     const tools = toolIndexModule.getTools(context.db, null);
     return tools.map((t) => ({
@@ -5010,6 +5366,163 @@ function inferGroupFromName(name) {
   return groupMap[name] ?? "core";
 }
 
+// src/handlers/resources/insights.ts
+var digestInsightsResource = {
+  uri: "memory://insights/digest",
+  name: "Analytics Digest",
+  title: "Latest Analytics Digest Snapshot",
+  description: "Full pre-computed analytics digest with activity trends, significance spikes, stale projects, relationship density, and top importance entries. Updated by the scheduled digest job.",
+  mimeType: "application/json",
+  icons: [ICON_ANALYTICS],
+  annotations: {
+    ...withPriority(0.5, ASSISTANT_FOCUSED)
+  },
+  handler: (_uri, context) => {
+    const lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    const schedulerDigest = context.scheduler?.getLatestDigest?.();
+    if (schedulerDigest) {
+      return {
+        data: { success: true, snapshot: schedulerDigest },
+        annotations: { lastModified }
+      };
+    }
+    const dbSnapshot = context.db?.getLatestAnalyticsSnapshot?.("digest");
+    if (dbSnapshot) {
+      return {
+        data: {
+          success: true,
+          snapshot: dbSnapshot.data,
+          computedAt: dbSnapshot.createdAt,
+          source: "persisted"
+        },
+        annotations: { lastModified: dbSnapshot.createdAt }
+      };
+    }
+    return {
+      data: {
+        success: true,
+        snapshot: null,
+        message: "No digest available \u2014 enable with --digest-interval <minutes> (HTTP transport only)"
+      },
+      annotations: { lastModified }
+    };
+  }
+};
+var teamCollaborationResource = {
+  uri: "memory://insights/team-collaboration",
+  name: "Team Collaboration Matrix",
+  title: "Team Collaboration Insights",
+  description: "Cross-author collaboration metrics: activity heatmap, cross-linking patterns, and impact factor per contributor. Requires TEAM_DB_PATH.",
+  mimeType: "application/json",
+  icons: [ICON_ANALYTICS],
+  annotations: {
+    ...withPriority(0.4, ASSISTANT_FOCUSED)
+  },
+  handler: (_uri, context) => {
+    const lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    if (!context.teamDb) {
+      return {
+        data: {
+          success: true,
+          matrix: null,
+          message: "Team database not configured \u2014 set TEAM_DB_PATH to enable."
+        },
+        annotations: { lastModified }
+      };
+    }
+    try {
+      const matrix = computeTeamCollaborationMatrix(context.teamDb);
+      return {
+        data: { success: true, ...matrix },
+        annotations: { lastModified }
+      };
+    } catch (error) {
+      return {
+        data: {
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        annotations: { lastModified }
+      };
+    }
+  }
+};
+function computeTeamCollaborationMatrix(teamDb) {
+  const activityRows = execQuery(
+    teamDb,
+    `SELECT
+            COALESCE(author, 'unknown') AS author,
+            strftime('%Y-%m', timestamp) AS period,
+            COUNT(*) AS entry_count
+        FROM memory_journal
+        WHERE deleted_at IS NULL
+        GROUP BY author, period
+        ORDER BY period DESC, entry_count DESC
+        LIMIT 100`
+  );
+  const authorActivity = activityRows.map((r) => ({
+    author: r["author"],
+    period: r["period"],
+    entryCount: r["entry_count"]
+  }));
+  const crossLinkRows = execQuery(
+    teamDb,
+    `SELECT
+            COALESCE(m1.author, 'unknown') AS from_author,
+            COALESCE(m2.author, 'unknown') AS to_author,
+            COUNT(*) AS link_count
+        FROM relationships r
+        JOIN memory_journal m1 ON r.from_entry_id = m1.id
+        JOIN memory_journal m2 ON r.to_entry_id = m2.id
+        WHERE m1.deleted_at IS NULL AND m2.deleted_at IS NULL
+            AND COALESCE(m1.author, 'unknown') != COALESCE(m2.author, 'unknown')
+        GROUP BY from_author, to_author
+        ORDER BY link_count DESC
+        LIMIT 50`
+  );
+  const crossAuthorLinks = crossLinkRows.map((r) => ({
+    fromAuthor: r["from_author"],
+    toAuthor: r["to_author"],
+    linkCount: r["link_count"]
+  }));
+  const impactRows = execQuery(
+    teamDb,
+    `SELECT
+            COALESCE(m2.author, 'unknown') AS author,
+            COUNT(*) AS inbound_links
+        FROM relationships r
+        JOIN memory_journal m2 ON r.to_entry_id = m2.id
+        WHERE m2.deleted_at IS NULL
+        GROUP BY author
+        ORDER BY inbound_links DESC
+        LIMIT 20`
+  );
+  const impactFactor = impactRows.map((r) => ({
+    author: r["author"],
+    inboundLinks: r["inbound_links"]
+  }));
+  const totalsRow = execQuery(
+    teamDb,
+    `SELECT
+            COUNT(DISTINCT COALESCE(author, 'unknown')) AS total_authors,
+            COUNT(*) AS total_entries
+        FROM memory_journal
+        WHERE deleted_at IS NULL`
+  );
+  const totalAuthors = totalsRow[0]?.["total_authors"] ?? 0;
+  const totalEntries = totalsRow[0]?.["total_entries"] ?? 0;
+  return {
+    authorActivity,
+    crossAuthorLinks,
+    impactFactor,
+    totalAuthors,
+    totalEntries
+  };
+}
+function getInsightResourceDefinitions() {
+  return [digestInsightsResource, teamCollaborationResource];
+}
+
 // src/handlers/resources/index.ts
 function getResources() {
   const resources = getAllResourceDefinitions();
@@ -5083,6 +5596,7 @@ function getAllResourceDefinitions() {
     ...getTemplateResourceDefinitions(),
     ...getTeamResourceDefinitions(),
     ...getHelpResourceDefinitions(),
+    ...getInsightResourceDefinitions(),
     // Audit resource — bound to the global audit logger (or null if unconfigured)
     getAuditResourceDef(getGlobalAuditLogger)
   ];
@@ -5136,6 +5650,12 @@ var Scheduler = class {
         );
       }
     }
+    if (this.options.digestIntervalMinutes > 0) {
+      this.scheduleJob("digest", this.options.digestIntervalMinutes, () => {
+        this.runDigest();
+        return Promise.resolve();
+      });
+    }
     if (this.timers.length > 0) {
       const summary = this.timers.map(
         (t) => `${t.name} (${String(t.intervalMinutes)}min)`
@@ -5277,6 +5797,38 @@ var Scheduler = class {
       context: { entriesIndexed: count }
     });
   }
+  // ========================================================================
+  // Private — Digest job
+  // ========================================================================
+  /**
+   * Digest job: compute analytics snapshot and persist to database.
+   */
+  runDigest() {
+    const rawDb = this.db.getRawDb();
+    const snapshot = computeDigest(rawDb);
+    this.db.saveAnalyticsSnapshot("digest", snapshot);
+    logger.info("Scheduled analytics digest computed", {
+      module: "Scheduler",
+      operation: "digest",
+      context: {
+        currentPeriodEntries: snapshot.currentPeriodEntries,
+        activityGrowthPercent: snapshot.activityGrowthPercent,
+        topImportanceCount: snapshot.topImportanceEntries.length
+      }
+    });
+  }
+  // ========================================================================
+  // Public — Digest accessor
+  // ========================================================================
+  /**
+   * Get the latest digest snapshot from the database.
+   * Returns null if no digest has been computed yet.
+   */
+  getLatestDigest() {
+    const snapshot = this.db.getLatestAnalyticsSnapshot("digest");
+    if (!snapshot) return null;
+    return snapshot.data;
+  }
 };
 
 // src/transports/http/types.ts
@@ -6489,15 +7041,30 @@ function registerPrompts(server, prompts, db, teamDb) {
         ...promptDef.icons ? { icons: promptDef.icons } : {}
       },
       (providedArgs) => {
-        const args = providedArgs;
-        const promptResult = getPrompt(promptDef.name, args, db, teamDb);
-        const result = {
-          messages: promptResult.messages.map((m) => ({
-            role: m.role,
-            content: m.content
-          }))
-        };
-        return Promise.resolve(result);
+        try {
+          const args = providedArgs;
+          const promptResult = getPrompt(promptDef.name, args, db, teamDb);
+          const result = {
+            messages: promptResult.messages.map((m) => ({
+              role: m.role,
+              content: m.content
+            }))
+          };
+          return Promise.resolve(result);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return Promise.resolve({
+            messages: [
+              {
+                role: "user",
+                content: {
+                  type: "text",
+                  text: `[Prompt handler error] ${message}`
+                }
+              }
+            ]
+          });
+        }
       }
     );
   }
@@ -6748,7 +7315,7 @@ async function createServer(options) {
   }
   let scheduler = null;
   if (options.scheduler) {
-    const hasAnyJob = options.scheduler.backupIntervalMinutes > 0 || options.scheduler.vacuumIntervalMinutes > 0 || options.scheduler.rebuildIndexIntervalMinutes > 0;
+    const hasAnyJob = options.scheduler.backupIntervalMinutes > 0 || options.scheduler.vacuumIntervalMinutes > 0 || options.scheduler.rebuildIndexIntervalMinutes > 0 || options.scheduler.digestIntervalMinutes > 0;
     if (hasAnyJob && transport === "stdio") {
       logger.warning(
         "Scheduler options ignored for stdio transport (session is ephemeral). Use HTTP/SSE transport for automated scheduling.",