frinus-mcp 3.6.3 → 3.6.4

package/dist/index.js

@@ -64,7 +64,7 @@ async function main() {
     }
     const server = new Server({
         name: "frinus",
-        version: "3.6.3",
+        version: "3.6.4",
     }, {
         capabilities: {
             tools: {},

package/dist/tools/definitions.js

@@ -9,16 +9,19 @@ export const TOOLS = [
 Use this to record important information, learnings, decisions, or procedures
 that should be remembered for future reference.
 
-The backend classifies the memory by content at write time and returns a
-SUGGESTION (status "proposed"/"universe_only") of which universe/context node it
-belongs to — nothing is moved automatically. Review pending suggestions with
-memory_classification_pending and apply them with memory_classification_approve.
+The backend classifies the memory by content at write time and proposes which
+universe/context node it belongs to. When the tenant has auto-classification
+enabled and the proposal's confidence meets the tenant threshold (the platform
+target is 0.60), the backend ANCHORS the memory on that node automatically — it
+is moved without review. Below the threshold (or with auto-classification off)
+the proposal stays a PENDING suggestion: review it with
+memory_classification_pending and apply with memory_classification_approve.
 
 Passing universe_id or context_id anchors the memory THERE directly (status
 "manual"): auto-classification is skipped entirely, so no suggestion is returned
 and nothing may later move it. The response always reports the destination the
-memory actually landed in — a suggestion, when present, is labelled as pending
-and not applied.
+memory actually landed in — a suggestion that is still pending is labelled as
+such and has NOT been applied.
 
 Memory types:
 - episodic: Specific experiences and events (what happened)
@@ -678,8 +681,15 @@ Useful for maintaining consistency in the knowledge base.`,
         inputSchema: {
             type: "object",
             properties: {
-                similarity_threshold: { type: "number", description: "Similarity threshold 0-1 (default: 0.9)" },
-                limit: { type: "integer", description: "Maximum results (default: 50)" },
+                // NOTE: the backend (POST /consolidation/detect-conflicts →
+                // ConflictDetectionRequest) does NOT accept similarity_threshold for
+                // conflict detection — conflict pairs are found by the forgetting
+                // manager's own analysis, and the field is silently ignored (the
+                // request model inherits _IgnoreExtra). It is kept here only for
+                // forward compatibility; it currently has no effect. Redundant
+                // detection (consolidation_detect_redundant) DOES honour it.
+                similarity_threshold: { type: "number", description: "Currently IGNORED by the backend for conflict detection (kept for forward compatibility). Use consolidation_detect_redundant to tune a similarity threshold." },
+                limit: { type: "integer", description: "Maximum memories to analyze (default: 50)" },
             },
             required: [],
         },

package/dist/tools/handlers.js

@@ -365,14 +365,17 @@ const handlers = {
         const userId = args.user_id || resolvedUserId || undefined;
         const meta = args.metadata || {};
         const universeId = args.universe_id || meta.universe_id || undefined;
-        // Human-in-the-loop classification: the backend classifies the memory by
-        // content at write time and returns a SUGGESTION (classification_status
-        // "proposed"). Nothing is moved automatically — the user reviews via
-        // memory_classification_pending and approves with
-        // memory_classification_approve. The MCP layer no longer injects an
-        // implicit "universe" scope nor surfaces "available universes"; scope,
-        // universe_id and context_id are forwarded ONLY when the caller sets them
-        // (explicit overrides → classification_status "manual").
+        // Write-time classification: the backend classifies the memory by content
+        // and, when the tenant's `auto_classify` setting is enabled and the
+        // proposal confidence meets the tenant threshold, anchors it automatically
+        // (classification_status "proposed"/"universe_only" become real FK columns);
+        // below the threshold it stays a pending SUGGESTION the user reviews via
+        // memory_classification_pending / memory_classification_approve. See
+        // memory/src/api/routers/memories.py (classification/settings). The MCP
+        // layer no longer injects an implicit "universe" scope nor surfaces
+        // "available universes"; scope, universe_id and context_id are forwarded
+        // ONLY when the caller sets them (explicit overrides → status "manual",
+        // which anchors there directly and skips classification).
         try {
             const result = await memoryClient.storeMemory({
                 agent_id: args.agent_id,
@@ -890,7 +893,18 @@ const handlers = {
         }
         formatted += `\n`;
         results.memories.forEach((mem, i) => {
-            formatted += `${i + 1}. [${mem.memory_type}] (id: ${mem.id}) (score: ${mem.weighted_score?.toFixed(2) || mem.similarity?.toFixed(2)})\n`;
+            // Q-MEM-02: /memories/search-with-attention returns `attention_score`
+            // (re-ranked) + `base_similarity` (see memory/src/api/schemas.py
+            // MemoryWithAttentionScore). The legacy field `weighted_score` and the
+            // plain /memories/search field `similarity` are kept as fallbacks so the
+            // same renderer works across endpoints. `?? ` (not `||`) so a real 0 score
+            // is not swallowed.
+            const score = mem.attention_score ??
+                mem.weighted_score ??
+                mem.base_similarity ??
+                mem.similarity;
+            const scoreTxt = typeof score === "number" ? score.toFixed(2) : "n/a";
+            formatted += `${i + 1}. [${mem.memory_type}] (id: ${mem.id}) (score: ${scoreTxt})\n`;
             formatted += `   ${mem.content?.slice(0, 200)}...\n\n`;
         });
         return { content: [{ type: "text", text: formatted }] };
@@ -1035,11 +1049,27 @@ const handlers = {
         if (!conflicts || conflicts.length === 0) {
             return { content: [{ type: "text", text: "No conflicts detected." }] };
         }
-        let formatted = `Detected ${result.conflicts_found || conflicts.length} potential conflicts:\n\n`;
+        let formatted = `Detected ${result.conflicts_found ?? conflicts.length} potential conflicts:\n\n`;
         conflicts.forEach((conflict, i) => {
-            formatted += `${i + 1}. Similarity: ${conflict.similarity?.toFixed(2)}\n`;
-            formatted += `   Memory 1: ${conflict.memory1?.content?.slice(0, 100)}...\n`;
-            formatted += `   Memory 2: ${conflict.memory2?.content?.slice(0, 100)}...\n\n`;
+            // Q-MEM-03: the backend emits `memory_1` / `memory_2` (ConflictPair in
+            // memory/src/api/schemas.py), each with id/content, plus `conflict_type`
+            // and `suggested_action`. The old code read `memory1`/`memory2` (no
+            // underscore) so content printed as "undefined" and the type/action were
+            // dropped. Keep the snake-less variants as a defensive fallback.
+            const m1 = conflict.memory_1 ?? conflict.memory1;
+            const m2 = conflict.memory_2 ?? conflict.memory2;
+            const simTxt = typeof conflict.similarity === "number"
+                ? conflict.similarity.toFixed(2)
+                : "n/a";
+            formatted += `${i + 1}. Similarity: ${simTxt}`;
+            if (conflict.conflict_type)
+                formatted += ` · type: ${conflict.conflict_type}`;
+            formatted += `\n`;
+            formatted += `   Memory 1 (${m1?.id ?? "?"}): ${m1?.content?.slice(0, 100) ?? "(no content)"}...\n`;
+            formatted += `   Memory 2 (${m2?.id ?? "?"}): ${m2?.content?.slice(0, 100) ?? "(no content)"}...\n`;
+            if (conflict.suggested_action)
+                formatted += `   Suggested action: ${conflict.suggested_action}\n`;
+            formatted += `\n`;
         });
         return { content: [{ type: "text", text: formatted }] };
     },
@@ -1062,12 +1092,19 @@ const handlers = {
         if (!groups || groups.length === 0) {
             return { content: [{ type: "text", text: "No redundant memories detected." }] };
         }
-        let formatted = `Detected ${result.groups_found || groups.length} redundant memory groups (${result.total_redundant || 0} total memories):\n\n`;
+        let formatted = `Detected ${result.groups_found ?? groups.length} redundant memory groups (${result.total_redundant ?? 0} redundant memories):\n\n`;
         groups.forEach((group, i) => {
-            formatted += `${i + 1}. Group similarity: ${group.avg_similarity?.toFixed(2) || 'N/A'}\n`;
-            formatted += `   Memories: ${group.memory_ids?.length || 0}\n`;
-            if (group.memories && group.memories.length > 0) {
-                formatted += `   Preview: ${group.memories[0]?.content?.slice(0, 100)}...\n`;
+            // Q-MEM-04: the backend emits `keep` (the memory to retain), `redundant`
+            // (the duplicates) and `total_in_group` (RedundantGroup in
+            // memory/src/api/schemas.py). The old code read `avg_similarity`,
+            // `memory_ids` and `memories`, none of which exist, so every group showed
+            // "N/A" and 0 memories.
+            const redundantCount = Array.isArray(group.redundant) ? group.redundant.length : 0;
+            const total = group.total_in_group ?? (redundantCount + (group.keep ? 1 : 0));
+            formatted += `${i + 1}. Memories in group: ${total} (keep 1, redundant ${redundantCount})\n`;
+            const keepPreview = group.keep?.content?.slice(0, 100);
+            if (keepPreview) {
+                formatted += `   Keep (${group.keep?.id ?? "?"}): ${keepPreview}...\n`;
             }
             formatted += `\n`;
         });

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "frinus",
   "display_name": "Frinus — Memória Cognitiva",
-  "version": "3.6.3",
+  "version": "3.6.4",
   "description": "Memória cognitiva de longo prazo para o Claude (φρήν + νοῦς). 83 ferramentas de memória, sessões, agentes e conhecimento.",
   "long_description": "O Frinus dá ao Claude memória de longo prazo, identidade e inteligência persistente entre conversas. Conecta o Claude Desktop à plataforma Frinus (Memory Engine, Control Plane e Agent Service) via MCP. Basta colar sua chave de API pessoal — nada para instalar ou compilar.",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frinus-mcp",
-  "version": "3.6.3",
+  "version": "3.6.4",
   "description": "Frinus - MCP Server for Cognitive Memory (φρήν + νοῦς). Long-term memory, sessions, agents and knowledge for Claude and any MCP client.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,6 +17,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "node --import tsx --test tests/*.test.ts",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
     "pack:mcpb": "./scripts/pack-mcpb.sh",