frinus-mcp 3.4.0 → 3.4.1

package/README.md

@@ -11,7 +11,7 @@ It does **not** run on its own. It stores nothing locally: every tool call is fo
 
 With those in place, the server exposes **70 tools** spanning cognitive memory, working memory, sessions, agents, the L0–L3 knowledge hierarchy, orchestration tasks, and training pipelines. It speaks stdio and works with any MCP-aware client.
 
-- **Version:** 3.3.0
+- **Version:** 3.4.1
 - **Tools:** 70 (see [Tools Reference](#tools-reference))
 - **Platform:** https://frinus.rdxsec.com.br (hosted SaaS — the backend this server talks to)
 - **npm package:** [`frinus-mcp`](https://www.npmjs.com/package/frinus-mcp)

package/dist/tools/definitions.js

@@ -10,11 +10,15 @@ 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") of which universe/context node it belongs to —
-nothing is moved automatically. Review pending suggestions with
+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.
-Passing scope/universe_id/context_id explicitly sets the destination directly
-(no suggestion needed).
+
+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 types:
 - episodic: Specific experiences and events (what happened)
@@ -45,7 +49,7 @@ Scopes:
                 scope: {
                     type: "string",
                     enum: ["user", "agent", "universe", "organization"],
-                    description: "Optional explicit visibility scope. Omit to let the backend auto-classify and return a suggestion (status 'proposed'). When set, it overrides classification (status 'manual'): 'organization' (org-wide), 'user' (private), 'universe' (department-shared), 'agent' (agent-only).",
+                    description: "Optional explicit visibility scope — WHO can see the memory, independent of WHERE it is filed in the hierarchy (that is universe_id/context_id). 'organization' (org-wide), 'user' (private), 'universe' (department-shared — requires a universe, via universe_id/context_id or the agent's own), 'agent' (agent-only). Default: 'user'.",
                 },
                 importance: {
                     type: "number",
@@ -65,7 +69,7 @@ Scopes:
                 },
                 universe_id: {
                     type: "string",
-                    description: "Optional UUID of a universe to associate the memory with explicitly (overrides auto-classification → status 'manual'). Omit to let the backend suggest one.",
+                    description: "Optional UUID of a universe to file the memory under explicitly. Anchors it there as ground-truth (status 'manual'): auto-classification is skipped and nothing may later move it. Omit to let the backend suggest one.",
                 },
                 context_id: {
                     type: "string",

package/dist/tools/handlers.js

@@ -269,39 +269,67 @@ function destinationLabel(result) {
     return "";
 }
 /**
- * Render the memory_store response. New backend: shows the auto-classification
- * suggestion (proposed) or final destination (manual/approved) enxuto, no
- * intrusive "Dica/Universos disponíveis" block. Old backend (no classification
- * fields): minimal ID/Type/Scope, also WITHOUT any hint.
+ * Breadcrumb for a hierarchy chain returned by the backend as a list of nodes
+ * ({ id, level, name, context_path }), e.g. "Operacoes › Contratos › Gain-share".
+ * Falls back to the raw id for legacy FK-only nodes with no contexts row.
+ */
+function hierarchyLabel(nodes) {
+    if (!Array.isArray(nodes) || nodes.length === 0)
+        return "";
+    return nodes
+        .map((n) => (typeof n?.name === "string" && n.name ? n.name : n?.id))
+        .filter((s) => typeof s === "string" && s)
+        .join(" › ");
+}
+/** Where the memory ACTUALLY landed — never the classifier's suggestion. */
+function appliedLabel(result) {
+    const fromChain = hierarchyLabel(result?.hierarchy);
+    if (fromChain)
+        return fromChain;
+    // Older backend without `hierarchy`: fall back to the real FK column. Still
+    // the applied destination — NOT classified_universe (that is a proposal).
+    const uni = result?.universe_id;
+    return typeof uni === "string" && uni ? uni : "";
+}
+/**
+ * Render the memory_store response.
+ *
+ * Hard rule: the ONLY thing reported as the destination is where the memory was
+ * actually written (`hierarchy` / `universe_id`). `classified_*` and
+ * `proposed_hierarchy` are the auto-classifier's SUGGESTION and are always
+ * labelled as such — never as the destination. Reporting a pending suggestion
+ * as the destination is what made an explicit `universe_id` look ignored when
+ * the write had in fact honoured it.
  */
 function renderStoreResult(result) {
     const id = result?.id;
     const status = result?.classification_status;
     const head = `✓ Salva`;
-    // Defensive: older backend without classification fields.
-    if (!status) {
-        return `Memory stored successfully.\nID: ${id}\nType: ${result?.memory_type}\nScope: ${result?.scope}`;
+    const applied = appliedLabel(result);
+    const pending = status === "proposed" || status === "universe_only";
+    // Anchored: a real destination exists. Report it, and only then mention a
+    // still-pending suggestion (which cannot have been applied, by definition).
+    if (applied) {
+        let out = `${head} em: ${applied}`;
+        if (pending) {
+            const sug = hierarchyLabel(result?.proposed_hierarchy) || suggestionLabel(result);
+            if (sug && sug !== applied) {
+                out += `\n  ↳ sugestão pendente (NÃO aplicada): ${sug} — revise com memory_classification_pending`;
+            }
+        }
+        return out;
     }
-    if (status === "proposed") {
-        const uni = universeName(result?.classified_universe);
-        const ctx = contextName(result?.classified_context);
-        const conf = confidenceLabel(result?.confidence);
-        // High/medium-confidence node identified.
-        if (uni && ctx) {
+    // Not anchored anywhere: the suggestion is all we have to offer.
+    if (pending) {
+        const sug = hierarchyLabel(result?.proposed_hierarchy) || suggestionLabel(result);
+        const conf = confidenceLabel(result?.classification_confidence);
+        if (sug) {
             const confTxt = conf ? `, confiança ${conf}` : "";
-            return `${head} · sugestão: ${suggestionLabel(result)} (auto${confTxt}) — aprove com memory_classification_approve`;
-        }
-        // Universe-only suggestion (no specific node).
-        if (uni) {
-            return `${head} · sugestão de universo: ${uni} (nó específico não identificado) — aprove com memory_classification_approve`;
+            return `${head} · sem destino aplicado · sugestão: ${sug} (auto${confTxt}) — aprove com memory_classification_approve`;
         }
-        // Low / no confidence: no reliable suggestion.
-        return `${head} · sem sugestão confiável — use memory_classification_pending para revisar`;
+        return `${head} · sem destino aplicado e sem sugestão confiável — use memory_classification_pending para revisar`;
     }
-    // manual / approved: show final destination without "sugestão".
-    const dest = destinationLabel(result);
-    if (dest)
-        return `${head} · classificada em: ${dest}`;
+    // Defensive: older backend without classification fields, or no hierarchy at all.
     return `${head}\nID: ${id}\nType: ${result?.memory_type}\nScope: ${result?.scope}`;
 }
 const handlers = {

package/manifest.json

@@ -2,8 +2,8 @@
   "manifest_version": "0.3",
   "name": "frinus",
   "display_name": "Frinus — Memória Cognitiva",
-  "version": "3.1.0",
-  "description": "Memória cognitiva de longo prazo para o Claude (φρήν + νοῦς). 70 ferramentas de memória, sessões, agentes e conhecimento.",
+  "version": "3.4.1",
+  "description": "Memória cognitiva de longo prazo para o Claude (φρήν + νοῦς). 80 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": {
     "name": "Frinus",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frinus-mcp",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "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",