ruflo

What changed

Changed 2026-10-18 11:10 UTC

1 schema or annotation change with the description left byte-identical.

--- pinned/policy_status
+++ observed/policy_status
  {
    "description": "Inspect policy mode, migration state, rules, budgets, approvals, and ledger integrity. Use when diagnosing whether an installation is in compatibility, observation, or enforcement mode.",
    "inputSchema": {
-     "properties": {},
+     "properties": {
+       "full": {
+         "description": "Also replay the archived receipts to verify the complete historical ledger, not just the retained hot tail (#3164)",
+         "type": "boolean"
+       }
+     },
      "type": "object"
    },
    "name": "policy_status"

Changed 2026-10-15 11:39 UTC

7 descriptions rewritten, 3 schema or annotation changes with the description left byte-identical.

--- pinned/agent_health
+++ observed/agent_health
  {
-   "description": "Compute an agent's rolling health score (0-1) from recent task success ratio + response-latency p50/p95 + error rate. Use when native Task tool is wrong because you're running a long-lived agent (autonomous loop / hive-mind worker / federation peer) and need to detect degradation before the breaker trips it. For one-shot Task invocations there is no history to score. Pair with hooks_post-task so the scores stay current.",
+   "description": "Report measured agent_execute provider-call outcomes over the last 20 calls: API success-ratio health (0-1), error rate, and response-latency p50/p95. This does not measure task correctness. Agents with no observed calls have unknown health; registration is not proof of a running process. Native Task and hooks_post-task outcomes are not recorded here. Use when you need measured reliability for agents driven through agent_execute; native Task results are invisible to this tool, so inspect those directly.",
    "inputSchema": {
      "properties": {
        "agentId": {

--- pinned/analyze_diff
+++ observed/analyze_diff
  {
-   "description": "Analyze git diff for change risk assessment and classification Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Heuristically analyze git diff paths, changed lines, and one-commit subjects for risk and classification. Use when preparing a review that needs a quick evidence-based summary; inspect the diff for final judgment.",
    "inputSchema": {
      "properties": {
        "includeFileRisks": {

--- pinned/analyze_diff-classify
+++ observed/analyze_diff-classify
  {
-   "description": "Classify git diff change type Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Heuristically classify a git diff from changed lines, file paths, and a single-commit subject when available. Use when you need a coarse change category; inspect the diff to confirm.",
    "inputSchema": {
      "properties": {
        "ref": {

--- pinned/analyze_diff-reviewers
+++ observed/analyze_diff-reviewers
  {
-   "description": "Suggest reviewers for git diff changes Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Suggest reviewer roles from git diff paths and risk; does not identify people or read CODEOWNERS. Use when triaging expertise for a change, then consult CODEOWNERS to assign people.",
    "inputSchema": {
      "properties": {
        "limit": {

--- pinned/analyze_diff-risk
+++ observed/analyze_diff-risk
  {
-   "description": "Quick risk assessment for git diff Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Heuristically assess git diff risk from changed file paths, sizes, and status. Use when triaging which files merit closer human review; this is not a security guarantee.",
    "inputSchema": {
      "properties": {
        "ref": {

--- pinned/analyze_diff-stats
+++ observed/analyze_diff-stats
  {
-   "description": "Get quick statistics for git diff Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Count changed files, additions, and deletions in a git diff. Use when you need a quick size summary before inspecting the full patch.",
    "inputSchema": {
      "properties": {
        "ref": {

--- pinned/analyze_file-risk
+++ observed/analyze_file-risk
  {
-   "description": "Assess risk for a specific file change Use when native `git diff` / `grep` / static analysis is wrong because you want LLM-graded change classification, reviewer recommendations, or risk scoring. For literal-text inspection, native tools are fine.",
+   "description": "Heuristically assess risk for a file path and optional change metadata. Use when triaging a changed file for focused review; inspect the source for final judgment.",
    "inputSchema": {
      "properties": {
        "additions": {

--- pinned/memory_search
+++ observed/memory_search
  {
    "description": "Find stored memories by meaning (vector similarity), not by literal text — finds \"JWT auth pattern\" when you query \"token-based login flow\". Use when native Grep is wrong because Grep matches characters and you need to find conceptually-related entries across past sessions. Returns top-k with similarity: raw retrieval relevance, which may include lexical scoring and is not guaranteed to be cosine similarity. With smart=true, similarity is the highest raw score across query variants; rankingScore is the composite relevance score used by the ranking pipeline, not cosine similarity, probability, or confidence. Diversity can change result order.",
    "inputSchema": {
-         "description": "Minimum raw retrieval relevance 0-1 for candidate admission, applied per query before SmartRetrieval ranking; not a floor on rankingScore (default: 0.3)",
+         "description": "Minimum raw retrieval relevance 0-1 for candidate admission, applied per query before SmartRetrieval ranking; not a floor on rankingScore (default: 0.2; calibrated for the bundled embedding model, pass 0 to see every match)",
          "type": "number"
        }
      },

--- pinned/neural_predict
+++ observed/neural_predict
  {
    "description": "Make predictions using a neural model Use when nothing native trains on your workflow — Claude Code has no learning loop. Use to train SONA/MoE/EWC patterns from successful task outcomes; query via neural_predict before spawning agents. Off-path for one-shot work.",
    "inputSchema": {
+       "minSimilarity": {
+         "description": "Minimum cosine similarity for a stored pattern to count as a match (default 0.5). A softmax over a single candidate is always 1.0, so without a floor any input matched the only stored pattern with confidence 1",
+         "type": "number"
+       },
        "modelId": {
          "description": "Model ID to use",
          "type": "string"

--- pinned/workflow_create
+++ observed/workflow_create
  {
    "description": "Create a new workflow Use when native TodoWrite + sequential Bash is wrong because the work has a real dependency graph that needs persistence, retry policy, pause/resume, and step-output binding across LLM-driven steps. For a single linear todo list, native TodoWrite is fine.",
    "inputSchema": {
+               "description": "Condition steps require config.when; parallel and loop steps are not yet supported",
                "type": "object"
              },
              "name": {
-                 "parallel",
-                 "loop",
                  "wait"
                ],
                "type": "string"

Changed 2026-10-11 12:56 UTC

1 description rewritten, 1 schema or annotation change with the description left byte-identical.

--- pinned/task_update
+++ observed/task_update
  {
    "description": "Update task status or progress Use when native TodoWrite is wrong because you need cross-session task persistence, agent assignment, dependency tracking, or completion analytics in the .swarm/memory.db. For in-session checklists native TodoWrite is simpler and faster.",
    "inputSchema": {
-         "description": "New status",
+         "description": "New status: pending, in_progress, completed, failed or cancelled",
          "type": "string"
        },
        "taskId": {

--- pinned/workflow_validate
+++ observed/workflow_validate
  {
-   "description": "Structurally validate a workflow definition file (JSON) — checks it has a steps/stages/tasks array and that each step names an agent. Use when native Read is wrong because you want a parsed, structured pass/fail with error/warning lists and step/agent counts rather than eyeballing the file. For just reading the file, native Read is fine. (Basic checks today — a full workflow-schema validator is a tracked follow-up.)",
+   "description": "Structurally validate a workflow definition file (JSON) — checks it has a steps/stages/tasks array and that task steps resolve an agent. Use when native Read is wrong because you want a parsed, structured pass/fail with error/warning lists and step/agent counts rather than eyeballing the file. For just reading the file, native Read is fine. (Basic checks today — a full workflow-schema validator is a tracked follow-up.)",
    "inputSchema": {
      "properties": {
        "file": {

Changed 2026-10-09 13:33 UTC

1 schema or annotation change with the description left byte-identical.

--- pinned/session_save
+++ observed/session_save
  {
    "description": "Save current session state Use when native conversation memory is wrong because you need durable cross-session state — restoring agent definitions, swarm topology, memory store, breaker history. For in-session continuation only, no tool needed. Pair with session_save before exiting and session_restore on resume.",
    "inputSchema": {
+         "default": true,
          "description": "Include agents in session",
          "type": "boolean"
        },
+         "default": true,
          "description": "Include memory in session",
          "type": "boolean"
        },
+         "default": true,
          "description": "Include tasks in session",
          "type": "boolean"
        },

Changed 2026-10-08 13:45 UTC

9 schema or annotation changes with the description left byte-identical.

--- pinned/hive-mind_broadcast
+++ observed/hive-mind_broadcast
  {
    "description": "Broadcast message to all workers Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "fromId": {
          "description": "Sender agent ID",
          "type": "string"
+       "hiveToken": {
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
+       },
        "message": {
          "description": "Message to broadcast",
          "type": "string"

--- pinned/hive-mind_consensus
+++ observed/hive-mind_consensus
  {
    "description": "Propose or vote on consensus with BFT, Raft, or Quorum strategies Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "hiveToken": {
-         "description": "Capability token minted by hive-mind_init (required to vote)",
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
          "type": "string"
        },
        "proposalId": {

--- pinned/hive-mind_init
+++ observed/hive-mind_init
  {
    "description": "Initialize the hive-mind collective Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Operator secret (RUFLO_HIVE_BOOTSTRAP_SECRET or .claude-flow/hive-mind/bootstrap.secret). Only needed by remote/HTTP callers; local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
+       },
        "consensus": {
          "description": "Consensus strategy. Default: raft (anti-drift). Use byzantine for f<n/3 fault tolerance.",
          "enum": [

--- pinned/hive-mind_join
+++ observed/hive-mind_join
  {
    "description": "Join an agent to the hive-mind Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "hiveToken": {
-         "description": "Capability token minted by hive-mind_init",
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
          "type": "string"
        },
        "role": {
-       "agentId",
-       "hiveToken"
+       "agentId"
      ],
      "type": "object"
    },

--- pinned/hive-mind_leave
+++ observed/hive-mind_leave
  {
    "description": "Remove an agent from the hive-mind Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "hiveToken": {
-         "description": "Capability token minted by hive-mind_init",
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
          "type": "string"
        }
      },
-       "agentId",
-       "hiveToken"
+       "agentId"
      ],
      "type": "object"
    },

--- pinned/hive-mind_memory
+++ observed/hive-mind_memory
  {
    "description": "Access hive shared memory Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
+       "hiveToken": {
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
+       },
        "key": {
          "description": "Memory key",
          "type": "string"

--- pinned/hive-mind_optimize-memory
+++ observed/hive-mind_optimize-memory
  {
    "description": "Compact the hive-mind shared-memory store (drops null/empty keys) and report before/after pattern counts. Use when native conversation memory is wrong because you need the queen-led collective's persisted shared state cleaned up between phases. For one-shot scratch state, no tool needed. (Pattern-quality consolidation is delegated to the intelligence pipeline — this only does the cheap structural pass for now.)",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
+       "hiveToken": {
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
+       },
        "qualityThreshold": {
          "description": "Quality threshold for pattern retention (advisory — not enforced yet)",
          "type": "number"

--- pinned/hive-mind_shutdown
+++ observed/hive-mind_shutdown
  {
    "description": "Shutdown the hive-mind and terminate all workers Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "force": {
          "default": false,
          "description": "Force immediate shutdown",
+       },
+       "hiveToken": {
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
        }
      },
      "type": "object"

--- pinned/hive-mind_spawn
+++ observed/hive-mind_spawn
  {
    "description": "Spawn workers and automatically join them to the hive-mind (combines agent/spawn + hive-mind/join) Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "bootstrapSecret": {
+         "description": "Remote/HTTP callers only: operator secret (alternative to hiveToken). See ADR-476.",
+         "type": "string"
+       },
        "count": {
          "default": 1,
          "description": "Number of workers to spawn (default: 1)",
+       "hiveToken": {
+         "description": "Remote/HTTP callers only: hive capability token (read from the server, never returned by tools). Local stdio/CLI callers omit it. See ADR-476.",
+         "type": "string"
+       },
        "prefix": {
          "default": "hive-worker",
          "description": "Prefix for worker IDs",

Changed 2026-10-05 14:46 UTC

4 descriptions rewritten, 12 schema or annotation changes with the description left byte-identical, 25 tools added.

--- pinned/agentdb_consolidate
+++ observed/agentdb_consolidate
  {
-   "description": "Run memory consolidation to promote entries across tiers and compress old data Use when generic memory_* tools are wrong because you need AgentDB-specific controllers (HNSW vector search, hierarchical tiers, causal-graph links, pattern store/recall, RaBitQ quantization). For simple key-value persistence, memory_store/memory_retrieve are simpler. For unrelated file work, native Read/Write are fine.",
+   "description": "Request memory consolidation. Use when checking whether AgentDB can consolidate retained memories; native file edits cannot perform controller consolidation. Currently returns unsupported when the installed controller is a no-op stub; no entries are promoted or compressed in that case.",
    "inputSchema": {
-     "properties": {
-       "maxEntries": {
-         "description": "Maximum entries to consolidate (optional)",
-         "type": "number"
-       },
-       "minAge": {
-         "description": "Minimum age in hours since store (optional)",
-         "type": "number"
-       }
-     },
+     "properties": {},
      "type": "object"
    },
    "name": "agentdb_consolidate"

--- pinned/agentdb_feedback
+++ observed/agentdb_feedback
  {
    "description": "Record task feedback for learning via LearningSystem + ReasoningBank controllers Use when generic memory_* tools are wrong because you need AgentDB-specific controllers (HNSW vector search, hierarchical tiers, causal-graph links, pattern store/recall, RaBitQ quantization). For simple key-value persistence, memory_store/memory_retrieve are simpler. For unrelated file work, native Read/Write are fine.",
    "inputSchema": {
+       "patterns": {
+         "description": "Learned patterns to retain; successful tasks with quality >= 0.9 may create reusable skills",
+         "items": {
+           "maxLength": 10000,
+           "minLength": 1,
+           "type": "string"
+         },
+         "maxItems": 100,
+         "type": "array"
+       },
        "quality": {
          "description": "Quality score (0-1)",
          "type": "number"

--- pinned/agentdb_graph-query
+++ observed/agentdb_graph-query
  {
-   "description": "Unified graph traversal across the knowledge graph (ADR-130). Dispatches to the most capable backend: graph-node native for k-hop, sql.js CTE for fallback, HNSW cosine for semantic, ruflo-graph-intelligence PageRank for pagerank mode. Use when you need structured graph traversal beyond flat memory search.",
+   "description": "Unified graph traversal across the knowledge graph (ADR-130). K-hop queries read committed graph_edges relationships through SQL; a separately populated native graph is not evidence of retained-history coverage. Inspect appliedDepth/truncated because SQL is bounded at 3 hops. maxNodesVisited bounds returned rows, not traversal work or elapsed time. Semantic and PageRank modes use their own backends. Use when you need relationship traversal beyond flat memory search.",
    "inputSchema": {
      "properties": {
        "complexityBudget": {
-         "description": "Hop depth for k-hop mode (default 2, max 5)",
+         "description": "Requested k-hop depth (default 2, max 5); SQL responses report appliedDepth and truncated when limited to 3",
          "type": "number"
        },
        "mode": {

+ tool added: federation_bbs_identity

+ tool added: federation_bbs_peer_add

+ tool added: federation_bbs_peers

+ tool added: federation_bbs_serve

+ tool added: federation_bbs_sync

--- pinned/hive-mind_consensus
+++ observed/hive-mind_consensus
  {
    "description": "Propose or vote on consensus with BFT, Raft, or Quorum strategies Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "hiveToken": {
+         "description": "Capability token minted by hive-mind_init (required to vote)",
+         "type": "string"
+       },
        "proposalId": {
          "description": "Proposal ID (for vote/status)",
          "type": "string"

--- pinned/hive-mind_join
+++ observed/hive-mind_join
  {
    "description": "Join an agent to the hive-mind Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       "hiveToken": {
+         "description": "Capability token minted by hive-mind_init",
+         "type": "string"
+       },
        "role": {
          "description": "Agent role in hive",
          "enum": [
-       "agentId"
+       "agentId",
+       "hiveToken"
      ],
      "type": "object"
    },

--- pinned/hive-mind_leave
+++ observed/hive-mind_leave
  {
    "description": "Remove an agent from the hive-mind Use when native Task is wrong because you need queen-led collective intelligence — Byzantine-FT consensus, broadcast across many worker agents, shared memory with bounded conflict. For a single subagent, native Task is fine. Pair with swarm_init first to set topology.",
    "inputSchema": {
+       },
+       "hiveToken": {
+         "description": "Capability token minted by hive-mind_init",
+         "type": "string"
        }
      },
      "required": [
-       "agentId"
+       "agentId",
+       "hiveToken"
      ],
      "type": "object"
    },

--- pinned/hooks_intelligence_trajectory-step
+++ observed/hooks_intelligence_trajectory-step
  {
    "description": "Record step in trajectory for reinforcement learning Use when native Bash hooks (via Claude Code's settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.",
    "inputSchema": {
+         "maximum": 1,
+         "minimum": 0,
          "type": "number"
        },
        "result": {

--- pinned/hooks_post-command
+++ observed/hooks_post-command
  {
    "description": "Record command execution outcome Use when native Bash hooks (via Claude Code's settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.",
    "inputSchema": {
+       },
+       "success": {
+         "description": "Explicit execution outcome; false records a failure even without a nonzero exit code",
+         "type": "boolean"
+       },
+       "ttl": {
+         "description": "Command history lifetime in seconds (default: 30 days)",
+         "maximum": 2147483647,
+         "minimum": 1,
+         "type": "integer"
        }
      },
      "required": [

--- pinned/hooks_post-task
+++ observed/hooks_post-task
  {
    "description": "Record task completion for learning Use when native Bash hooks (via Claude Code's settings.json) are wrong because you need Ruflo-side state — pattern persistence, neural training signals, model-routing learning, cost tracking, audit chain. For one-off shell commands, plain Bash hooks are fine.",
    "inputSchema": {
+       "patterns": {
+         "description": "Learned patterns to retain; successful tasks with quality >= 0.9 may create reusable skills",
+         "items": {
+           "maxLength": 10000,
+           "minLength": 1,
+           "type": "string"
+         },
+         "maxItems": 100,
+         "type": "array"
+       },
        "quality": {
          "description": "Quality score (0-1)",
+         "maximum": 1,
+         "minimum": 0,
          "type": "number"
        },
        "storeDecisions": {

--- pinned/memory_import
+++ observed/memory_import
  {
    "description": "Import memory entries from a JSON export file (produced by memory_export) into .swarm/memory.db, re-embedding values. Use when native Read is wrong because the data must be re-stored as memory rows (with new embeddings), not just read. For importing Claude Code's own memory files use memory_import_claude. Pair with memory_export on the source.",
    "inputSchema": {
+       "dbPath": {
+         "description": "Database file to import into (defaults to the MCP memory store)",
+         "type": "string"
+       },
        "inputPath": {
          "description": "Path to the JSON export file",
          "type": "string"

--- pinned/memory_search
+++ observed/memory_search
  {
-   "description": "Find stored memories by meaning (vector similarity), not by literal text — finds \"JWT auth pattern\" when you query \"token-based login flow\". Use when native Grep is wrong because Grep matches characters and you need to find conceptually-related entries across past sessions. Backed by HNSW index over ONNX embeddings; returns top-k with similarity scores. Pair with smart=true for query expansion + MMR diversity.",
+   "description": "Find stored memories by meaning (vector similarity), not by literal text — finds \"JWT auth pattern\" when you query \"token-based login flow\". Use when native Grep is wrong because Grep matches characters and you need to find conceptually-related entries across past sessions. Returns top-k with similarity: raw retrieval relevance, which may include lexical scoring and is not guaranteed to be cosine similarity. With smart=true, similarity is the highest raw score across query variants; rankingScore is the composite relevance score used by the ranking pipeline, not cosine similarity, probability, or confidence. Diversity can change result order.",
    "inputSchema": {
      "properties": {
        "limit": {
-         "description": "Enable SmartRetrieval pipeline — query expansion, RRF fusion, recency boost, MMR diversity (default: false)",
+         "description": "Enable SmartRetrieval — query expansion, RRF fusion, recency boost, MMR diversity; preserves raw similarity and adds rankingScore (default: false)",
          "type": "boolean"
        },
        "threshold": {
-         "description": "Minimum similarity threshold 0-1 (default: 0.3)",
+         "description": "Minimum raw retrieval relevance 0-1 for candidate admission, applied per query before SmartRetrieval ranking; not a floor on rankingScore (default: 0.3)",
          "type": "number"
        }
      },

--- pinned/memory_stats
+++ observed/memory_stats
  {
    "description": "Get memory storage statistics including HNSW index status Use when native Read/Write is wrong because you need (a) cross-session retrieval by semantic similarity (vector embeddings) not by file path, (b) namespacing across projects without managing directory layout, or (c) the .swarm/memory.db audit trail. For one-shot file I/O, native Read/Write is fine.",
    "inputSchema": {
-     "properties": {},
+     "properties": {
+       "dbPath": {
+         "description": "Database file to inspect; omitted uses the MCP store default",
+         "type": "string"
+       }
+     },
      "type": "object"
    },
    "name": "memory_stats"

+ tool added: mission_create

+ tool added: mission_events

+ tool added: mission_get

+ tool added: mission_plan

+ tool added: mission_request_action

+ tool added: seraphina_guidance

--- pinned/session_export
+++ observed/session_export
  {
    "description": "Export a saved session (agents, tasks, memory snapshot) to a JSON file and/or return the payload. Use when native Write is wrong because the data is the structured session record (not a freeform file) and you want it serialized consistently for transfer/backup. For writing arbitrary content, native Write is fine. Pair with session_import on the other end.",
    "inputSchema": {
-         "description": "Include the memory snapshot (advisory — already in the saved record)",
+         "description": "Include the memory snapshot (default true)",
          "type": "boolean"
        },
        "outputPath": {

--- pinned/session_import
+++ observed/session_import
  {
-   "description": "Import a session JSON file (produced by session_export) into the local session store and optionally activate it. Use when native Read is wrong because the file is a structured session record that must be re-registered (new id, stats recomputed) rather than just read. For reading the file, native Read is fine. Pair with session_export on the source.",
+   "description": "Import a session (produced by session_export) into the local session store and optionally activate it. Pass either inputPath (a session JSON file) or data (the session record itself). Use when native Read is wrong because the file is a structured session record that must be re-registered (new id, stats recomputed) rather than just read. For reading the file, native Read is fine. Pair with session_export on the source.",
    "inputSchema": {
      "properties": {
        "activate": {
-         "description": "Make the imported session the current one (advisory)",
+         "description": "Restore the imported session into the active stores",
          "type": "boolean"
        },
+       "data": {
+         "description": "The session record itself, as written by session_export (or pass inputPath)",
+         "type": "object"
+       },
        "inputPath": {
-         "description": "Path to the session JSON file to import",
+         "description": "Path to the session JSON file to import (or pass data)",
          "type": "string"
        },
        "name": {
-     "required": [
-       "inputPath"
-     ],
      "type": "object"
    },
    "name": "session_import"

--- pinned/session_restore
+++ observed/session_restore
  {
    "description": "Restore a saved session Use when native conversation memory is wrong because you need durable cross-session state — restoring agent definitions, swarm topology, memory store, breaker history. For in-session continuation only, no tool needed. Pair with session_save before exiting and session_restore on resume.",
    "inputSchema": {
+       "restoreAgents": {
+         "description": "Restore agents (default true)",
+         "type": "boolean"
+       },
+       "restoreMemory": {
+         "description": "Restore memory (default true)",
+         "type": "boolean"
+       },
+       "restoreTasks": {
+         "description": "Restore tasks (default true)",
+         "type": "boolean"
+       },
        "sessionId": {
          "description": "Session ID to restore",
          "type": "string"

--- pinned/task_update
+++ observed/task_update
  {
    "description": "Update task status or progress Use when native TodoWrite is wrong because you need cross-session task persistence, agent assignment, dependency tracking, or completion analytics in the .swarm/memory.db. For in-session checklists native TodoWrite is simpler and faster.",
    "inputSchema": {
+       "result": {
+         "description": "Result data (e.g. the failure of a failed task)",
+         "type": "object"
+       },
        "status": {
          "description": "New status",
          "type": "string"

+ tool added: x_federation_admit

+ tool added: x_federation_channel_accept

+ tool added: x_federation_channel_create

+ tool added: x_federation_channel_grant

+ tool added: x_federation_channel_list

+ tool added: x_federation_channel_publish

+ tool added: x_federation_channel_read

+ tool added: x_federation_claims

+ tool added: x_federation_invite_mint

+ tool added: x_federation_join

+ tool added: x_federation_publish

+ tool added: x_federation_registry

+ tool added: x_federation_roster

+ tool added: x_federation_sync

Current tools

Watch this server yourself

If you run this server, put the proxy in front of it. It pins these exact fingerprints on first connect and stops the session if they move.

npx -y mcp-pin@0.2.3 -- <your ruflo command>

Or subscribe to this page's RSS feed to be told when it changes.

Badge

The badge states one fact about time and nothing else. It never claims a server is safe.

[![mcp-pin](https://mcp-pin.gautamkhosla.com/badge/64e9436dfbd00fb5.svg)](https://mcp-pin.gautamkhosla.com/servers/64e9436dfbd00fb5.html)