@neruva/mcp 0.16.3 → 0.18.0

package/dist/server.js

@@ -394,363 +394,17 @@ const TOOLS = [
         },
     },
     // ==================================================================
-    // Memory index (legacy vector layer) -- migration on-ramp; records_* preferred.
+    // ===== REMOVED in MCP 0.18.0 =====
+    // memory_* (vector-index legacy surface) -- REST still serves them at
+    // /v1/indexes/* for back-compat; not surfaced via MCP because records_*
+    // is strictly better (typed kinds + tags + semantic query in one call).
+    //
+    // agent_plan_cache_save/lookup + agent_postmortem -- dead Computer/Code
+    // agent wedge per pivot 23373 (2026-05-18).
+    //
+    // hd_kg_add_fact -- strictly dominated by hd_kg_add_facts (batch). Use
+    // the batch version for both single + multi-fact writes.
     // ==================================================================
-    {
-        name: "memory_embed",
-        description: "Encode one or more texts to L2-normalized D=1024 float vectors " +
-            "using the server-side static-MRL encoder. Use this for memory_upsert " +
-            "and memory_query when you don't have a local encoder. ~7000 texts/sec " +
-            "on the hosted instance; first call adds ~5s for model load.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                texts: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Texts to embed (any length; truncated at ~512 tokens internally)",
-                },
-            },
-            required: ["texts"],
-        },
-    },
-    {
-        name: "memory_upsert_text",
-        description: "Embed and upsert text in a single call -- the all-in-one for new " +
-            "users. Server runs static-MRL D=1024 internally; you don't need " +
-            "an embedder. Each item: {id, text, metadata?}. The original text " +
-            "is auto-stored into metadata.text for round-trip.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                items: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "string" },
-                            text: { type: "string" },
-                            metadata: { type: "object" },
-                        },
-                        required: ["id", "text"],
-                    },
-                },
-            },
-            required: ["index", "items"],
-        },
-    },
-    {
-        name: "memory_query_text",
-        description: "Embed a text query and search the namespace in a single call. " +
-            "Returns top-K matches by cosine; metadata included by default so " +
-            "you can read the stored text back. Pass `tags: ['foo','bar']` for a " +
-            "convenient AND-filter on metadata.tags.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                text: { type: "string" },
-                topK: { type: "integer", default: 10 },
-                includeMetadata: { type: "boolean", default: true },
-                includeValues: { type: "boolean", default: false },
-                filter: { type: "object", description: "Metadata filter ({field: value} or {field: {$eq|$gte|$lte|$in: ...}})" },
-                tags: {
-                    type: "array", items: { type: "string" },
-                    description: "Convenience: AND-match on metadata.tags (every tag must be present)",
-                },
-                tagsAny: {
-                    type: "array", items: { type: "string" },
-                    description: "Convenience: ANY-match on metadata.tags (record matches if any one tag is present)",
-                },
-            },
-            required: ["index", "text"],
-        },
-    },
-    {
-        name: "memory_replace_text",
-        description: "Re-encode a new text and overwrite the existing vector + " +
-            "metadata.text in one call. Surgical: bipolar prefilter row, " +
-            "float rerank vector, and metadata all updated atomically. Use " +
-            "for refactor tracking, deploy state edits, or any existing " +
-            "memory whose content changed.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                id: { type: "string" },
-                newText: { type: "string" },
-            },
-            required: ["index", "id", "newText"],
-        },
-    },
-    {
-        name: "memory_forget_where",
-        description: "Bulk-delete vectors whose metadata matches a filter. " +
-            "Filter: {field: value} or {field: {$eq|$gte|$lte|$in: ...}}. " +
-            "GDPR Article 17 in one call -- forget every vector tagged " +
-            "{user_id: 'alice'} for example.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                filter: { type: "object", description: "Metadata filter ({field: value} or operator-syntax)" },
-            },
-            required: ["index", "filter"],
-        },
-    },
-    {
-        name: "memory_bind_role",
-        description: "Bind a named role atom onto a stored vector's bipolar prefilter " +
-            "row. Lets you narrow future queries by compound roles like " +
-            "[\"user\", \"from_alice\"] without a secondary index. Mutates the " +
-            "row's prefilter; the float rerank is unchanged.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                id: { type: "string", description: "Vector id to bind" },
-                role: { type: "string", description: "Role atom name (e.g. 'user')" },
-            },
-            required: ["index", "id", "role"],
-        },
-    },
-    {
-        name: "memory_read_roles",
-        description: "Approximate-unbind introspection: given a stored vector's id and " +
-            "its original encoder vector, recover which role atoms it was " +
-            "bound under. Pass a role_dict mapping axis names to candidate " +
-            "role names; returns axis -> [best_role, score]. If the row was " +
-            "bound under multiple atoms, peel known ones via the `known` arg.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                id: { type: "string" },
-                queryVector: { type: "array", items: { type: "number" } },
-                roleDict: {
-                    type: "object",
-                    description: "Map axis_name -> list of candidate role names.",
-                },
-                known: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Already-known bound roles to peel off first",
-                },
-            },
-            required: ["index", "id", "queryVector", "roleDict"],
-        },
-    },
-    {
-        name: "memory_create_index",
-        description: "Create a vector index. Required once before " +
-            "memory_upsert / memory_query / memory_delete can be used. Idempotent " +
-            "on existing indexes (returns the existing description).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Index name" },
-                dimension: {
-                    type: "integer",
-                    description: "Vector dimension (matches your encoder, e.g. 1024 for static-MRL)",
-                },
-                metric: {
-                    type: "string",
-                    enum: ["cosine", "dotproduct", "euclidean"],
-                    default: "cosine",
-                },
-            },
-            required: ["name", "dimension"],
-        },
-    },
-    {
-        name: "memory_list_indexes",
-        description: "List all indexes for your account.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
-    {
-        name: "memory_describe_index",
-        description: "Describe one index (dimension, metric, host, status).",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-        },
-    },
-    {
-        name: "memory_stats",
-        description: "Per-namespace vector counts and total vector count for an index.",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-        },
-    },
-    {
-        name: "memory_fetch",
-        description: "Fetch one or more vectors by id from a namespace.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                ids: { type: "array", items: { type: "string" } },
-                namespace: { type: "string", default: "" },
-            },
-            required: ["index", "ids"],
-        },
-    },
-    {
-        name: "memory_update",
-        description: "Update one vector in a namespace -- replace its values and/or " +
-            "metadata without re-upserting. ID must already exist.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                id: { type: "string" },
-                values: { type: "array", items: { type: "number" } },
-                metadata: { type: "object" },
-                namespace: { type: "string", default: "" },
-            },
-            required: ["index", "id"],
-        },
-    },
-    {
-        name: "memory_export",
-        description: "Export an index (or one namespace) to the portable .nmm format. " +
-            "Returns base64-encoded bytes. Take your memory with you between " +
-            "providers, environments, agents.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: {
-                    type: "string",
-                    description: "Optional namespace; omit to export the whole index.",
-                },
-            },
-            required: ["index"],
-        },
-    },
-    {
-        name: "memory_import",
-        description: "Import a previously-exported .nmm blob into an index. " +
-            "Index must already exist with matching dimension. Pass base64-encoded " +
-            "bytes via the `nmm_base64` field.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                nmm_base64: { type: "string" },
-            },
-            required: ["index", "nmm_base64"],
-        },
-    },
-    {
-        name: "memory_upsert",
-        description: "Insert or update vectors in a Neruva Memory namespace. The index " +
-            "must exist (create it once with memory_create_index).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string", description: "Index name" },
-                namespace: {
-                    type: "string",
-                    description: "Namespace (one per agent or context); defaults to ''",
-                    default: "",
-                },
-                vectors: {
-                    type: "array",
-                    description: "Vectors: {id, values, metadata?}",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "string" },
-                            values: { type: "array", items: { type: "number" } },
-                            metadata: { type: "object" },
-                        },
-                        required: ["id", "values"],
-                    },
-                },
-            },
-            required: ["index", "vectors"],
-        },
-    },
-    {
-        name: "memory_query",
-        description: "Cosine-search a namespace by vector. Returns top-K matches with " +
-            "metadata. The index must exist. Pass `tags: ['foo','bar']` for a " +
-            "convenient AND-filter on metadata.tags (combines with `filter` if " +
-            "both given).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                vector: { type: "array", items: { type: "number" } },
-                topK: { type: "integer", default: 10 },
-                includeMetadata: { type: "boolean", default: true },
-                includeValues: { type: "boolean", default: false },
-                filter: { type: "object", description: "Metadata filter ({field: value} or {field: {$eq|$gte|$lte|$in: ...}})" },
-                tags: {
-                    type: "array", items: { type: "string" },
-                    description: "Convenience: AND-match on metadata.tags (every tag must be present)",
-                },
-                tagsAny: {
-                    type: "array", items: { type: "string" },
-                    description: "Convenience: ANY-match on metadata.tags (record matches if any one tag is present)",
-                },
-            },
-            required: ["index", "vector"],
-        },
-    },
-    {
-        name: "memory_delete",
-        description: "Delete vectors by id from a namespace. The index must exist.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                ids: { type: "array", items: { type: "string" } },
-            },
-            required: ["index", "ids"],
-        },
-    },
-    {
-        name: "hd_kg_add_fact",
-        description: "Add a (subject, relation, object) fact to a knowledge graph. The KG " +
-            "is auto-created on first add. Persists across restarts.\n\n" +
-            "engine (FRESH KGs only; ignored if KG exists):\n" +
-            "  hadamard       -- default; <10k facts, latency-critical.\n" +
-            "  opb            -- recommended for >10k facts; 250k facts in single " +
-            "matrix at 100% recall; supports hd_kg_derive_relation matrix-power.\n" +
-            "  multishard     -- 250k-1M+ facts; auto-routes via stable hash.\n" +
-            "  quorum         -- 3-shard redundant write; adversarial-resistant.\n" +
-            "  feature_bundle -- bundled-feature atoms; zero-shot generalization " +
-            "to unseen concepts (84% on UNSEEN, requires hd_kg_assign_features).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                kg: { type: "string", description: "Knowledge-graph name" },
-                subject: { type: "string" },
-                relation: { type: "string" },
-                object: { type: "string" },
-                engine: {
-                    type: "string",
-                    enum: ["hadamard", "opb", "multishard", "quorum", "feature_bundle"],
-                    description: "Fresh-KG engine selector (see tool description).",
-                },
-            },
-            required: ["kg", "subject", "relation", "object"],
-        },
-    },
     {
         name: "hd_kg_extraction_prompt",
         description: "Return the canonical system prompt agents should run with their " +
@@ -900,36 +554,6 @@ const TOOLS = [
             required: ["namespace", "id", "tag"],
         },
     },
-    {
-        name: "memory_timeline",
-        description: "Chronological scan of a vector index namespace by metadata.ts " +
-            "(descending). Records without a ts in metadata are skipped " +
-            "(use the Records substrate for universal timeline). Page back " +
-            "in time by passing until=<nextCursor> from the previous response.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                index: { type: "string" },
-                namespace: { type: "string", default: "" },
-                since: { type: "integer", description: "ts lower bound (inclusive)" },
-                until: { type: "integer", description: "ts upper bound (exclusive); pass nextCursor to page back" },
-                limit: { type: "integer", default: 50, minimum: 1, maximum: 500 },
-                includeValues: { type: "boolean", default: false },
-            },
-            required: ["index"],
-        },
-    },
-    {
-        name: "memory_delete_index",
-        description: "Delete a vector index AND all its namespaces. Hard delete -- " +
-            "blobs are removed from GCS, in-memory cache evicted. Use this to " +
-            "clean up zombie indexes from old tests / probes / abandoned namespaces.",
-        inputSchema: {
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-        },
-    },
     {
         name: "hd_kg_context",
         description: "Return a customizable context block ready to drop into an LLM prompt. " +
@@ -1423,52 +1047,6 @@ const TOOLS = [
             required: ["snapshot_id", "target_namespace"],
         },
     },
-    {
-        name: "agent_postmortem",
-        description: "Distill a failed agent run into a structured lesson + corrected " +
-            "plan via Magistral reasoning. Returns " +
-            "{failure_class, lesson, corrected_plan}. Pair with agent_remember " +
-            "to store the lesson back into substrate so future similar tasks " +
-            "see it as `LEARNED:` context. The recursive-intelligence loop: " +
-            "agent fails -> postmortem distills -> remember stores -> " +
-            "recall surfaces it on the next run, no human in the loop. " +
-            "failure_class is one of: tool_arg_missing | primitive_mismatch | " +
-            "context_drift | wrong_target | timeout | captcha_blocked | unknown.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agent: {
-                    type: "string",
-                    enum: ["computer", "code"],
-                    description: "Which agent failed (computer | code).",
-                },
-                task_text: { type: "string", description: "Original task." },
-                plan: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Plan steps that were attempted (string repr).",
-                },
-                history: {
-                    type: "array",
-                    items: { type: "object" },
-                    description: "Execution trace: [{step, result}, ...].",
-                },
-                error: {
-                    type: "string",
-                    description: "Final error message, if any.",
-                },
-                task_class: {
-                    type: "string",
-                    description: "Optional tag: web_search | calc | file_edit | ...",
-                },
-                app: {
-                    type: "string",
-                    description: "Optional tag: chrome | notepad | calculator | ...",
-                },
-            },
-            required: ["agent", "task_text"],
-        },
-    },
     {
         name: "agent_check_consistency",
         description: "Anomaly detection on Quorum KGs. Scans every (subject, relation) " +
@@ -1532,6 +1110,263 @@ const TOOLS = [
             },
         },
     },
+    // ==================================================================
+    // Cognitive primitives (substrate v0.4.0): counterfactual rollouts,
+    // theory-of-mind, schema lifting, EFE planning, continual K-gram,
+    // hierarchical chunking, few-shot rule induction + persistence.
+    // ==================================================================
+    {
+        name: "agent_counterfactual_rollout",
+        description: "Replay an action sequence with one action substituted at step_k. " +
+            "Returns the predicted final factored state. Stateless. " +
+            "Use when you need 'what if at step k the agent had taken action " +
+            "a' instead?'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                initial_state: { type: "array", items: { type: "integer" } },
+                action_seq: { type: "array", items: { type: "integer" } },
+                step_k: { type: "integer", description: "Index in action_seq to substitute." },
+                alternate_action: { type: "integer" },
+                n_axes: { type: "integer", default: 3, minimum: 1, maximum: 16 },
+                n_values: { type: "integer", default: 8, minimum: 2, maximum: 32 },
+                seed: { type: "integer", default: 2047 },
+            },
+            required: ["initial_state", "action_seq", "step_k", "alternate_action"],
+        },
+    },
+    {
+        name: "agent_model_belief_add",
+        description: "Store a nested belief in the namespace's Theory-of-Mind store. " +
+            "`chain` is outer-to-inner person indices: [0,1,2] means person 0 " +
+            "believes person 1 believes person 2 believes prop=val. " +
+            "Per-tenant stateful (keyed by tenant_id+namespace).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "tom" },
+                chain: { type: "array", items: { type: "integer" } },
+                prop: { type: "integer" },
+                val: { type: "integer" },
+                n_people: { type: "integer", default: 10 },
+                n_props: { type: "integer", default: 50 },
+                n_vals: { type: "integer", default: 20 },
+                max_depth: { type: "integer", default: 4 },
+                seed: { type: "integer", default: 2048 },
+            },
+            required: ["chain", "prop", "val"],
+        },
+    },
+    {
+        name: "agent_model_belief",
+        description: "Recall what the nested `chain` believes about prop. Returns " +
+            "{val, confidence}. 404 if no beliefs stored in this namespace yet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "tom" },
+                chain: { type: "array", items: { type: "integer" } },
+                prop: { type: "integer" },
+            },
+            required: ["chain", "prop"],
+        },
+    },
+    {
+        name: "agent_extract_schema",
+        description: "Given (role_idx, filler_idx) pairs for one instance, return the " +
+            "per-role signature score vector and the inferred role indices " +
+            "above the noise threshold. Use for analogical pattern matching: " +
+            "'which roles are bound in this instance?'. Per-tenant stateful.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "schema" },
+                role_filler_pairs: {
+                    type: "array",
+                    items: { type: "array", items: { type: "integer" }, minItems: 2, maxItems: 2 },
+                },
+                n_roles: { type: "integer", default: 10 },
+                n_fillers_per_role: { type: "integer", default: 100 },
+                seed: { type: "integer", default: 2049 },
+            },
+            required: ["role_filler_pairs"],
+        },
+    },
+    {
+        name: "agent_register_action",
+        description: "Register an action's add/del effects with the planner. " +
+            "add_effects/del_effects are {attr_idx: probability_in_[0,1]}. " +
+            "Call once per available action before agent_plan_efe. " +
+            "Per-tenant stateful.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "planner" },
+                action_id: { type: "integer" },
+                add_effects: { type: "object", additionalProperties: { type: "number" } },
+                del_effects: { type: "object", additionalProperties: { type: "number" } },
+                n_attrs: { type: "integer", default: 100 },
+                seed: { type: "integer", default: 6001 },
+            },
+            required: ["action_id"],
+        },
+    },
+    {
+        name: "agent_plan_efe",
+        description: "Score candidate action sequences against goal attribute marginals " +
+            "and return the one minimising KL(predicted || goal). Returns " +
+            "{best_plan_index, best_kl, all_kls}. Register actions first via " +
+            "agent_register_action. 400 if no actions registered.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "planner" },
+                state: { type: "array", items: { type: "integer" } },
+                candidate_plans: {
+                    type: "array",
+                    items: { type: "array", items: { type: "integer" } },
+                },
+                want_on: { type: "array", items: { type: "integer" } },
+                want_off: { type: "array", items: { type: "integer" } },
+                p_on: { type: "number", default: 0.95 },
+                p_off: { type: "number", default: 0.05 },
+            },
+            required: ["state", "candidate_plans"],
+        },
+    },
+    {
+        name: "agent_continual_train",
+        description: "Train a sharded K-gram next-token predictor on a token stream. " +
+            "Repeated calls accumulate without forgetting earlier patterns. " +
+            "Per-tenant stateful.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "continual" },
+                token_stream: { type: "array", items: { type: "integer" } },
+                vocab_size: { type: "integer", default: 200 },
+                k: { type: "integer", default: 2, description: "K-gram order." },
+                seed: { type: "integer", default: 7000 },
+            },
+            required: ["token_stream"],
+        },
+    },
+    {
+        name: "agent_continual_predict",
+        description: "Predict the next-token sequence from a primed context using the " +
+            "previously trained K-gram. Returns N-K predicted tokens. 404 if " +
+            "the namespace has not been trained yet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "continual" },
+                token_stream: { type: "array", items: { type: "integer" } },
+            },
+            required: ["token_stream"],
+        },
+    },
+    {
+        name: "agent_hierarchical_add",
+        description: "Encode a tree of L^K leaf ids under top_id (must supply exactly " +
+            "L^K leaf_ids in row-major order). Lets a single top-level id " +
+            "resolve to any leaf via a K-position path. Per-tenant stateful.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "hier" },
+                top_id: { type: "string" },
+                leaf_ids: { type: "array", items: { type: "integer" } },
+                L: { type: "integer", default: 4, description: "Branching factor." },
+                K: { type: "integer", default: 5, description: "Tree depth." },
+                n_leaf_vocab: { type: "integer", default: 1000 },
+                seed: { type: "integer", default: 2050 },
+            },
+            required: ["top_id", "leaf_ids"],
+        },
+    },
+    {
+        name: "agent_hierarchical_decode",
+        description: "Walk a path of K position indices (outer-to-inner, each in " +
+            "[0, L)) from top_id and return the leaf_id at that path. 404 " +
+            "if no tree stored.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "hier" },
+                top_id: { type: "string" },
+                path: { type: "array", items: { type: "integer" } },
+            },
+            required: ["top_id", "path"],
+        },
+    },
+    {
+        name: "agent_induce_rule",
+        description: "Given matched (xs, ys) demo grids, infer which named " +
+            "transformation rule applies (e.g. rot90, color_invert, mirror_h). " +
+            "Returns {rule_name, confidence}. Stateless. xs and ys must be " +
+            "same length.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                xs: {
+                    type: "array",
+                    items: { type: "array", items: { type: "array", items: { type: "integer" } } },
+                },
+                ys: {
+                    type: "array",
+                    items: { type: "array", items: { type: "array", items: { type: "integer" } } },
+                },
+            },
+            required: ["xs", "ys"],
+        },
+    },
+    {
+        name: "agent_persist_rule",
+        description: "Induce a rule from (xs, ys) demos AND store it under rule_id for " +
+            "later recall. Returns {rule_name, confidence, n_rules_stored}. " +
+            "Per-tenant stateful.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "rules" },
+                rule_id: { type: "string" },
+                xs: {
+                    type: "array",
+                    items: { type: "array", items: { type: "array", items: { type: "integer" } } },
+                },
+                ys: {
+                    type: "array",
+                    items: { type: "array", items: { type: "array", items: { type: "integer" } } },
+                },
+            },
+            required: ["rule_id", "xs", "ys"],
+        },
+    },
+    {
+        name: "agent_recall_rule",
+        description: "Recall a previously persisted rule by rule_id. Returns " +
+            "{rule_name, confidence}. 404 if no rules stored in this " +
+            "namespace yet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tenant_id: { type: "string", default: "default" },
+                namespace: { type: "string", default: "rules" },
+                rule_id: { type: "string" },
+            },
+            required: ["rule_id"],
+        },
+    },
 ];
 const HANDLERS = {
     // ----- Records -----
@@ -1618,113 +1453,7 @@ const HANDLERS = {
             return text;
         }
     },
-    // ----- Memory index (legacy vector layer) -----
-    memory_embed: (a) => call("POST", "/v1/memory/embed", { texts: a.texts }),
-    memory_list_indexes: () => call("GET", "/v1/indexes"),
-    memory_describe_index: (a) => call("GET", `/v1/indexes/${enc(a.name)}`),
-    memory_stats: (a) => call("GET", `/v1/indexes/${enc(a.name)}/describe_index_stats`),
-    memory_fetch: (a) => {
-        const ids = a.ids.map(enc).join("&ids=");
-        const ns = a.namespace ? `&namespace=${enc(a.namespace)}` : "";
-        return call("GET", `/v1/indexes/${enc(a.index)}/vectors/fetch?ids=${ids}${ns}`);
-    },
-    memory_update: (a) => {
-        const body = { id: a.id, namespace: a.namespace ?? "" };
-        if (a.values !== undefined)
-            body.values = a.values;
-        // Server expects setMetadata; sending metadata is a silent no-op.
-        if (a.metadata !== undefined)
-            body.setMetadata = a.metadata;
-        return call("POST", `/v1/indexes/${enc(a.index)}/vectors/update`, body);
-    },
-    memory_export: async (a) => {
-        const ns = a.namespace !== undefined ? `?namespace=${enc(a.namespace)}` : "";
-        const r = await fetch(BASE_URL + `/v1/indexes/${enc(a.index)}/export${ns}`, {
-            method: "GET",
-            headers: { "Api-Key": API_KEY },
-        });
-        if (!r.ok) {
-            throw new Error(`GET /v1/indexes/.../export -> ${r.status}: ${await r.text()}`);
-        }
-        const buf = new Uint8Array(await r.arrayBuffer());
-        let bin = "";
-        for (let i = 0; i < buf.length; i++)
-            bin += String.fromCharCode(buf[i]);
-        return { nmm_base64: btoa(bin), bytes: buf.length };
-    },
-    memory_import: async (a) => {
-        const bin = atob(a.nmm_base64);
-        const buf = new Uint8Array(bin.length);
-        for (let i = 0; i < bin.length; i++)
-            buf[i] = bin.charCodeAt(i);
-        const r = await fetch(BASE_URL + `/v1/indexes/${enc(a.index)}/import`, {
-            method: "POST",
-            headers: { "Api-Key": API_KEY, "Content-Type": "application/octet-stream" },
-            body: buf,
-        });
-        if (!r.ok) {
-            throw new Error(`POST /v1/indexes/.../import -> ${r.status}: ${await r.text()}`);
-        }
-        const text = await r.text();
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return text;
-        }
-    },
-    memory_upsert_text: (a) => call("POST", `/v1/indexes/${enc(a.index)}/text/upsert`, {
-        items: a.items, namespace: a.namespace ?? "",
-    }),
-    memory_query_text: (a) => call("POST", `/v1/indexes/${enc(a.index)}/text/query`, {
-        text: a.text,
-        namespace: a.namespace ?? "",
-        topK: a.topK ?? 10,
-        includeMetadata: a.includeMetadata ?? true,
-        includeValues: a.includeValues ?? false,
-        filter: _foldTags(a.filter, a.tags, a.tagsAny),
-    }),
-    memory_replace_text: (a) => call("POST", `/v1/indexes/${enc(a.index)}/text/replace`, {
-        id: a.id, newText: a.newText, namespace: a.namespace ?? "",
-    }),
-    memory_forget_where: (a) => call("POST", `/v1/indexes/${enc(a.index)}/vectors/delete`, {
-        filter: a.filter, namespace: a.namespace ?? "",
-    }),
-    memory_bind_role: (a) => call("POST", `/v1/indexes/${enc(a.index)}/roles/bind`, {
-        id: a.id, role: a.role, namespace: a.namespace ?? "",
-    }),
-    memory_read_roles: (a) => call("POST", `/v1/indexes/${enc(a.index)}/roles/read`, {
-        id: a.id,
-        queryVector: a.queryVector,
-        roleDict: a.roleDict,
-        known: a.known,
-        namespace: a.namespace ?? "",
-    }),
-    memory_create_index: (a) => call("POST", "/v1/indexes", {
-        name: a.name,
-        dimension: a.dimension,
-        metric: a.metric ?? "cosine",
-    }),
-    memory_upsert: (a) => call("POST", `/v1/indexes/${enc(a.index)}/vectors/upsert`, {
-        vectors: a.vectors,
-        namespace: a.namespace ?? "",
-    }),
-    memory_query: (a) => call("POST", `/v1/indexes/${enc(a.index)}/query`, {
-        vector: a.vector,
-        namespace: a.namespace ?? "",
-        topK: a.topK ?? 10,
-        includeMetadata: a.includeMetadata ?? true,
-        includeValues: a.includeValues ?? false,
-        filter: _foldTags(a.filter, a.tags, a.tagsAny),
-    }),
-    memory_delete: (a) => call("POST", `/v1/indexes/${enc(a.index)}/vectors/delete`, {
-        ids: a.ids,
-        namespace: a.namespace ?? "",
-    }),
-    hd_kg_add_fact: (a) => call("POST", `/v1/hd/kg/${enc(a.kg)}/facts`, {
-        facts: [{ subject: a.subject, relation: a.relation, object: a.object }],
-        engine: a.engine,
-    }),
+    // ----- Memory index (legacy vector layer) -- handlers removed in 0.18.0 -----
     hd_kg_extraction_prompt: () => call("GET", "/v1/hd/kg/extraction_prompt"),
     hd_kg_add_facts: (a) => call("POST", `/v1/hd/kg/${enc(a.kg)}/facts`, {
         facts: a.facts, engine: a.engine,
@@ -1738,7 +1467,6 @@ const HANDLERS = {
     hd_scm_describe: (a) => call("GET", `/v1/hd/causal/${enc(a.scm)}/describe`),
     hd_cbr_list: () => call("GET", "/v1/hd/cbr"),
     hd_cbr_describe: (a) => call("GET", `/v1/hd/cbr/${enc(a.cbr)}/describe`),
-    memory_delete_index: (a) => call("DELETE", `/v1/indexes/${enc(a.name)}`),
     records_update: (a) => call("POST", `/v1/records/${enc(a.namespace ?? "")}/${enc(a.id)}/update`, {
         text: a.text,
         setTags: a.setTags,
@@ -1752,21 +1480,6 @@ const HANDLERS = {
     records_bind_tag: (a) => call("POST", `/v1/records/${enc(a.namespace ?? "")}/${enc(a.id)}/bind_tag`, {
         tag: a.tag,
     }),
-    memory_timeline: (a) => {
-        const params = new URLSearchParams();
-        if (a.namespace != null)
-            params.set("namespace", String(a.namespace));
-        if (a.since != null)
-            params.set("since", String(a.since));
-        if (a.until != null)
-            params.set("until", String(a.until));
-        if (a.limit != null)
-            params.set("limit", String(a.limit));
-        if (a.includeValues)
-            params.set("includeValues", "true");
-        const qs = params.toString();
-        return call("GET", `/v1/indexes/${enc(a.index)}/timeline${qs ? `?${qs}` : ""}`);
-    },
     hd_kg_context: (a) => call("POST", `/v1/hd/kg/${enc(a.kg)}/context`, {
         question: a.question,
         top_k: a.top_k ?? 10,
@@ -1933,15 +1646,6 @@ const HANDLERS = {
         snapshot_id: a.snapshot_id,
         target_namespace: a.target_namespace,
     }),
-    agent_postmortem: (a) => call("POST", "/v1/agent/postmortem", {
-        agent: a.agent,
-        task_text: a.task_text,
-        plan: a.plan ?? [],
-        history: a.history ?? [],
-        error: a.error,
-        task_class: a.task_class,
-        app: a.app,
-    }),
     agent_check_consistency: (a) => call("POST", "/v1/agent/check_consistency", {
         kg: a.kg,
         max_anomalies: a.max_anomalies ?? 100,
@@ -1951,8 +1655,108 @@ const HANDLERS = {
     neruva_op_stats: (a) => call("GET", `/v1/me/usage?window=${encodeURIComponent(a?.window ?? "30d")}`),
     neruva_keys_list: () => call("GET", "/v1/me/keys"),
     neruva_op_log: (a) => call("GET", `/v1/me/op_log?limit=${encodeURIComponent(String(a?.limit ?? 50))}`),
+    // ----- Cognitive primitives (substrate v0.4.0) -----
+    agent_counterfactual_rollout: (a) => call("POST", "/v1/agent/counterfactual_rollout", {
+        initial_state: a.initial_state,
+        action_seq: a.action_seq,
+        step_k: a.step_k,
+        alternate_action: a.alternate_action,
+        n_axes: a.n_axes ?? 3,
+        n_values: a.n_values ?? 8,
+        seed: a.seed ?? 2047,
+    }),
+    agent_model_belief_add: (a) => call("POST", "/v1/agent/model_belief_add", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "tom",
+        chain: a.chain,
+        prop: a.prop,
+        val: a.val,
+        n_people: a.n_people ?? 10,
+        n_props: a.n_props ?? 50,
+        n_vals: a.n_vals ?? 20,
+        max_depth: a.max_depth ?? 4,
+        seed: a.seed ?? 2048,
+    }),
+    agent_model_belief: (a) => call("POST", "/v1/agent/model_belief", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "tom",
+        chain: a.chain,
+        prop: a.prop,
+    }),
+    agent_extract_schema: (a) => call("POST", "/v1/agent/extract_schema", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "schema",
+        role_filler_pairs: a.role_filler_pairs,
+        n_roles: a.n_roles ?? 10,
+        n_fillers_per_role: a.n_fillers_per_role ?? 100,
+        seed: a.seed ?? 2049,
+    }),
+    agent_register_action: (a) => call("POST", "/v1/agent/register_action", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "planner",
+        action_id: a.action_id,
+        add_effects: a.add_effects ?? {},
+        del_effects: a.del_effects ?? {},
+        n_attrs: a.n_attrs ?? 100,
+        seed: a.seed ?? 6001,
+    }),
+    agent_plan_efe: (a) => call("POST", "/v1/agent/plan_efe", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "planner",
+        state: a.state,
+        candidate_plans: a.candidate_plans,
+        want_on: a.want_on ?? [],
+        want_off: a.want_off ?? [],
+        p_on: a.p_on ?? 0.95,
+        p_off: a.p_off ?? 0.05,
+    }),
+    agent_continual_train: (a) => call("POST", "/v1/agent/continual_train", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "continual",
+        token_stream: a.token_stream,
+        vocab_size: a.vocab_size ?? 200,
+        k: a.k ?? 2,
+        seed: a.seed ?? 7000,
+    }),
+    agent_continual_predict: (a) => call("POST", "/v1/agent/continual_predict", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "continual",
+        token_stream: a.token_stream,
+    }),
+    agent_hierarchical_add: (a) => call("POST", "/v1/agent/hierarchical_add", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "hier",
+        top_id: a.top_id,
+        leaf_ids: a.leaf_ids,
+        L: a.L ?? 4,
+        K: a.K ?? 5,
+        n_leaf_vocab: a.n_leaf_vocab ?? 1000,
+        seed: a.seed ?? 2050,
+    }),
+    agent_hierarchical_decode: (a) => call("POST", "/v1/agent/hierarchical_decode", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "hier",
+        top_id: a.top_id,
+        path: a.path,
+    }),
+    agent_induce_rule: (a) => call("POST", "/v1/agent/induce_rule", {
+        xs: a.xs,
+        ys: a.ys,
+    }),
+    agent_persist_rule: (a) => call("POST", "/v1/agent/persist_rule", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "rules",
+        rule_id: a.rule_id,
+        xs: a.xs,
+        ys: a.ys,
+    }),
+    agent_recall_rule: (a) => call("POST", "/v1/agent/recall_rule", {
+        tenant_id: a.tenant_id ?? "default",
+        namespace: a.namespace ?? "rules",
+        rule_id: a.rule_id,
+    }),
 };
-const server = new Server({ name: "neruva", version: "0.16.1" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "neruva", version: "0.18.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const name = req.params.name;