ruflo

What changed

Changed 2026-10-30 13:05 UTC

1 tool added.

+ tool added: hooks_intelligence_verified-ingest

Changed 2026-10-29 13:14 UTC

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

--- pinned/agent_pool
+++ observed/agent_pool
  {
    "description": "Manage a fixed-size warm pool of pre-spawned agents to skip cold-start cost on bursty workloads. Use when native Task is wrong because (a) you have a queue of similar tasks and want to amortize spawn latency, (b) cost-tracking wants stable agentIds across requests, or (c) swarm topology requires a known agent count at all times. For one-shot work, just call agent_spawn or native Task. Pool sizes and warm/idle thresholds are set per-pool.",
    "inputSchema": {
-         "description": "Target pool size (for scale action)",
+         "description": "Target pool size (scale: grow or shrink to it; fill: grow to it, never shrink)",
          "type": "number"
        }
      },

--- pinned/agent_spawn
+++ observed/agent_spawn
  {
    "description": "Spawn a Ruflo-tracked agent with cost attribution + memory persistence + swarm coordination. Use when native Task tool is wrong because you need (a) cost tracking per agent in the cost-tracking namespace, (b) cross-session learning via the patterns namespace, or (c) coordination with other agents in a swarm topology (hierarchical / mesh / consensus). For one-shot subtasks with no learning loop, native Task is fine. Pair with hooks_route to pick the right model first.",
    "inputSchema": {
-         "description": "Type of agent to spawn",
+         "description": "Type of agent to spawn (a legacy `type` key is accepted as an alias)",
          "type": "string"
        },
        "config": {

--- pinned/coordination_sync
+++ observed/coordination_sync
  {
    "description": "Synchronize state across nodes Use when native Task is wrong because the work crosses multiple agents that need to vote/sync/load-balance — TodoWrite + a single Task cannot orchestrate consensus. For one-off subtask dispatch, native Task is fine.",
    "inputSchema": {
-         "description": "Action to perform",
+         "description": "Action to perform. `trigger` is unavailable: nodes are local records with no sync backend, so it is refused (#4557)",
          "enum": [
            "status",
            "trigger",
-         "description": "Force synchronization",
+         "description": "Unused: `trigger` is refused regardless (#4557)",
          "type": "boolean"
        }
      },

Changed 2026-10-25 11:39 UTC

2 descriptions rewritten, 1 schema or annotation change with the description left byte-identical, 5 tools added.

+ tool added: managed_agent_capabilities

+ tool added: managed_agent_control

--- pinned/managed_agent_create
+++ observed/managed_agent_create
  {
-   "description": "Spin up an Anthropic-managed cloud agent (Agent + Environment + Session) — the CLOUD counterpart of wasm_agent_create. Use when wasm_agent_create (local WASM sandbox) is wrong because the task is long-running/async (minutes-hours), needs a real cloud container with pre-installed packages + network, or persistent filesystem + transcript across turns. For a fast, free, ephemeral, offline agent use wasm_agent_create (rvagent). Needs ANTHROPIC_API_KEY + Managed Agents beta access. Returns {sessionId, agentId, environmentId}; pair with managed_agent_prompt.",
+   "description": "Spin up an Anthropic-managed cloud agent (Agent + Environment + Session) — the CLOUD counterpart of wasm_agent_create. Use when wasm_agent_create (local WASM sandbox) is wrong because the task is long-running/async (minutes-hours), needs a real cloud container with pre-installed packages + network, or persistent filesystem + transcript across turns. For a fast, free, ephemeral, offline agent use wasm_agent_create (rvagent). Needs ANTHROPIC_API_KEY + Managed Agents beta access. Opt into dynamic workflows with dynamicWorkflows=true and mandatory budgetCents (integer US cents); networking is then limited. Returns {sessionId, agentId, environmentId}; pair with managed_agent_prompt.",
    "inputSchema": {
      "properties": {
+       "allowedHosts": {
+         "description": "Exact allowed hostnames for dynamic workflow limited networking",
+         "items": {
+           "type": "string"
+         },
+         "type": "array"
+       },
+       "budgetCents": {
+         "description": "Positive integer US cents string; 2500 means $25; in-flight requests may overshoot",
+         "pattern": "^[1-9][0-9]{0,8}$",
+         "type": "string"
+       },
+       "dynamicWorkflows": {
+         "description": "Opt in to multiagent_20261001 dynamic workflows (requires budgetCents)",
+         "type": "boolean"
+       },
        "initScript": {
          "description": "Environment init script (bash, run at container start)",
          "type": "string"
-         "description": "Environment networking (default: unrestricted)",
+         "description": "Legacy default unrestricted; dynamic workflows require limited",
          "enum": [
            "unrestricted",
            "restricted",
-           "none"
+           "none",
+           "limited"
          ],
          "type": "string"
        },
+       "predefinedAgents": {
+         "description": "Restrict workflows to these agent IDs; disables inline agents",
+         "items": {
+           "type": "string"
+         },
+         "maxItems": 20,
+         "minItems": 1,
+         "type": "array"
+       },
        "skills": {
          "description": "Skills to attach to the agent",
          "items": {

--- pinned/managed_agent_events
+++ observed/managed_agent_events
  {
    "description": "Fetch the full server-persisted event log of a managed cloud-agent session (user turns, agent thinking, tool_use, tool_result, status) — the transcript/artifact view, the CLOUD counterpart of wasm_agent_files. Use when native Read is wrong because the work happened in Anthropic's cloud container, not on disk. For a local WASM agent's filesystem use wasm_agent_files. Returns the events plus a summary (assistantText, toolUses).",
    "inputSchema": {
+       },
+       "threadId": {
+         "description": "Optional child thread ID from session.thread_created; inspect worker failures",
+         "type": "string"
        }
      },
      "required": [

+ tool added: managed_agent_interrupt

+ tool added: managed_agent_learning

--- pinned/managed_agent_terminate
+++ observed/managed_agent_terminate
  {
-   "description": "Delete a managed cloud-agent session (stops billing for it) — the CLOUD counterpart of wasm_agent_terminate. Use when native nothing applies because a cloud session keeps billing container time + tokens until deleted. For a local WASM agent use wasm_agent_terminate. Optionally also deletes the session's environment. Always call this when done with a managed agent.",
+   "description": "Delete a managed cloud-agent session (stops billing for it) — the CLOUD counterpart of wasm_agent_terminate. Use when native nothing applies because a running cloud session consumes runtime and tokens. For a local WASM agent use wasm_agent_terminate. Optionally also deletes the session's environment. Always call this when done with a managed agent.",
    "inputSchema": {
      "properties": {
        "environmentId": {

+ tool added: rure_cuda_launch_plan

Changed 2026-10-24 11:14 UTC

1 schema or annotation change with the description left byte-identical, 7 tools added.

--- pinned/neural_compress
+++ observed/neural_compress
  {
    "description": "Compress neural model or embeddings 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": {
-         "description": "Target size reduction (0-1)",
+         "description": "Not used: quantize (#4195) and prune (#4423) are unavailable, and distill merges by similarity",
          "type": "number"
        }
      },

+ tool added: rure_analyze_binary

+ tool added: rure_analyze_cuda

+ tool added: rure_analyze_dotnet

+ tool added: rure_analyze_evm

+ tool added: rure_analyze_js_app

+ tool added: rure_extract_asar

+ tool added: rure_find_feature

Changed 2026-10-22 12:06 UTC

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

--- pinned/memory_delete
+++ observed/memory_delete
  {
    "description": "Remove a stored memory entry by exact (namespace, key). Use when a previously stored decision is invalidated or contains stale data. No native equivalent — Write to a file does not affect the .swarm/memory.db SQLite store.",
    "inputSchema": {
+       "dbPath": {
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
+         "type": "string"
+       },
        "key": {
          "description": "Memory key",
          "type": "string"

--- pinned/memory_list
+++ observed/memory_list
  {
    "description": "Enumerate stored memory entries (optionally filtered by namespace/tags) without semantic search. Use when native Glob is wrong because the entries are not files (they live in .swarm/memory.db). For inspection / audit / \"what is in my memory\" — pair with memory_search for retrieval-by-meaning.",
    "inputSchema": {
+       "dbPath": {
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
+         "type": "string"
+       },
        "limit": {
          "description": "Maximum results (default: 50)",
          "type": "number"

--- pinned/memory_retrieve
+++ observed/memory_retrieve
  {
    "description": "Read back a value previously stored via memory_store, by exact (namespace, key) — lossless, includes metadata. Use when native Read is wrong because the value is not a file (it lives in the .swarm/memory.db SQLite store) AND you know the exact key. For semantic lookup by meaning, use memory_search.",
    "inputSchema": {
+       "dbPath": {
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
+         "type": "string"
+       },
        "key": {
          "description": "Memory key",
          "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. 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": {
+       "dbPath": {
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
+         "type": "string"
+       },
        "limit": {
          "description": "Maximum results (default: 10)",
          "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": {
-         "description": "Database file to inspect; omitted uses the MCP store default",
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
          "type": "string"
        }
      },

--- pinned/memory_store
+++ observed/memory_store
  {
    "description": "Persistent key-value store with vector embedding — survives across sessions and is searchable by meaning, not just by file path. Use when native Write is wrong because the data is not a file (e.g. a learned pattern, a decision, a budget config) AND you need to recall it later by semantic query, not by path. Defaults to namespace=\"default\". Upsert semantics: writing an existing key updates it (matching the CLI `memory store` default); pass `upsert: false` to force strict-insert instead.",
    "inputSchema": {
+       "dbPath": {
+         "description": "Explicit SQLite store to read/write; omit to use the MCP default (the native/AgentDB sibling).",
+         "type": "string"
+       },
        "key": {
          "description": "Memory key (unique within namespace)",
          "type": "string"

Changed 2026-10-21 12:00 UTC

14 descriptions rewritten, 5 schema or annotation changes with the description left byte-identical, 9 tools added.

--- pinned/agent_list
+++ observed/agent_list
  {
    "description": "List every Ruflo-tracked agent in the registry with its type, model, status, and taskCount. Use when native Task tool is wrong because you need to see the swarm-wide agent inventory across turns (which agents exist, their roles, their cost-tracking handles) rather than spawn a new one-shot Task. Filter by status/domain/agentType if needed. For starting a fresh single-shot subagent, native Task is fine.",
    "inputSchema": {
+       "agentType": {
+         "description": "Filter by agent type",
+         "type": "string"
+       },
        "domain": {
          "description": "Filter by domain",
          "type": "string"

--- pinned/agent_spawn
+++ observed/agent_spawn
  {
    "description": "Spawn a Ruflo-tracked agent with cost attribution + memory persistence + swarm coordination. Use when native Task tool is wrong because you need (a) cost tracking per agent in the cost-tracking namespace, (b) cross-session learning via the patterns namespace, or (c) coordination with other agents in a swarm topology (hierarchical / mesh / consensus). For one-shot subtasks with no learning loop, native Task is fine. Pair with hooks_route to pick the right model first.",
    "inputSchema": {
+       "name": {
+         "description": "Optional display name for the agent (shown by agent_list, agent_status and ruflo-console)",
+         "type": "string"
+       },
        "swarmId": {
          "description": "Optional swarm to register the agent with (defaults to most-recent swarm)",
          "type": "string"

--- pinned/claims_accept-handoff
+++ observed/claims_accept-handoff
  {
-   "description": "Accept a pending handoff Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Accept a pending handoff. Use when the receiving claimant confirms a claims_handoff request, completing the ownership transfer.",
    "inputSchema": {
      "properties": {
        "claimant": {

--- pinned/claims_board
+++ observed/claims_board
  {
-   "description": "Get a visual board view of all claims Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Get a visual board view of all claims. Use when scanning overall claim status across issues and agents instead of composing the view from claims_list yourself.",
    "inputSchema": {
      "properties": {},
      "type": "object"

--- pinned/claims_claim
+++ observed/claims_claim
  {
-   "description": "Claim an issue for work (human or agent) Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Claim an issue for work (human or agent). Use when multiple agents might pick up the same issue — claiming makes ownership visible via claims_list before work starts.",
    "inputSchema": {
      "properties": {
        "claimant": {
+       },
+       "ttlMs": {
+         "description": "Optional time-to-live in milliseconds; when set, the claim records an expiresAt timestamp. Informational only today — no handler currently enforces it (e.g. claims_steal still requires claims_mark-stealable rather than checking expiry).",
+         "type": "number"
        }
      },
      "required": [

--- pinned/claims_handoff
+++ observed/claims_handoff
  {
-   "description": "Request handoff of an issue to another claimant Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Request handoff of an issue to another claimant. Use when transferring in-progress work to a different agent, instead of releasing and having them claim it fresh.",
    "inputSchema": {
      "properties": {
        "from": {

--- pinned/claims_list
+++ observed/claims_list
  {
-   "description": "List all claims or filter by criteria Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "List all claims or filter by criteria. Use when checking what is already claimed before starting new work, instead of guessing from issue comments.",
    "inputSchema": {
      "properties": {
        "agentType": {

--- pinned/claims_load
+++ observed/claims_load
  {
-   "description": "Get agent load information Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Get agent load information. Use when deciding which agent should take new work by comparing claim counts against claims_rebalance targets.",
    "inputSchema": {
      "properties": {
        "agentId": {

--- pinned/claims_mark-stealable
+++ observed/claims_mark-stealable
  {
-   "description": "Mark an issue as stealable by other agents Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Mark an issue as stealable by other agents. Use when a claimant is overloaded or stalled and wants another agent to pick it up via claims_steal.",
    "inputSchema": {
      "properties": {
        "context": {

--- pinned/claims_rebalance
+++ observed/claims_rebalance
  {
-   "description": "Suggest or apply load rebalancing across agents Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Suggest or apply load rebalancing across agents. Use when some agents are overloaded and others idle, instead of manually reassigning claims one at a time.",
    "inputSchema": {
      "properties": {
        "dryRun": {

--- pinned/claims_release
+++ observed/claims_release
  {
-   "description": "Release a claim on an issue Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Release a claim on an issue. Use when the claimant stops working on it, freeing it for another claims_claim instead of leaving it claimed indefinitely.",
    "inputSchema": {
      "properties": {
        "claimant": {

--- pinned/claims_status
+++ observed/claims_status
  {
-   "description": "Update claim status Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Update claim status. Use when progress changes (active, blocked, review-requested, etc.) so claims_list and claims_load reflect current state.",
    "inputSchema": {
      "properties": {
        "issueId": {

--- pinned/claims_steal
+++ observed/claims_steal
  {
-   "description": "Steal a stealable issue Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "Steal a stealable issue. Use when picking up work already marked stealable via claims_mark-stealable, rather than claiming an issue someone else still owns.",
    "inputSchema": {
      "properties": {
        "issueId": {

--- pinned/claims_stealable
+++ observed/claims_stealable
  {
-   "description": "List all stealable issues Use when nothing native covers per-agent capability gating — Claude Code agents have file-system access by default. Pair claims_grant + claims_check before letting an agent run privileged ops. For trusted in-session work, no claims call is needed.",
+   "description": "List all stealable issues. Use when looking for available work that has been freed up via claims_mark-stealable.",
    "inputSchema": {
      "properties": {
        "agentType": {

--- 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": {
+       "maxAgents": {
+         "default": 15,
+         "description": "Maximum number of agents the hive may contain (default: 15)",
+         "maximum": 1000,
+         "minimum": 1,
+         "type": "number"
+       },
+       "memoryBackend": {
+         "default": "hybrid",
+         "description": "Memory backend requested for this hive (default: hybrid)",
+         "enum": [
+           "agentdb",
+           "sqlite",
+           "hybrid"
+         ],
+         "type": "string"
+       },
+       "persist": {
+         "default": true,
+         "description": "Persist hive state to .claude-flow/hive-mind/state.json. Set false for an ephemeral init that writes no durable state.",
+         "type": "boolean"
+       },
        "queenId": {
          "description": "Initial queen agent ID",
          "type": "string"

--- pinned/hooks_intelligence_attention
+++ observed/hooks_intelligence_attention
  {
-   "description": "Compute attention-weighted similarity using MoE/Flash/Hyperbolic 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.",
+   "description": "Compute attention-weighted similarity using MoE/Flash. 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": {
      "properties": {
        "mode": {
-         "description": "Attention mode (flash, moe, hyperbolic)",
+         "description": "Attention mode (flash, moe)",
          "type": "string"
        },
        "query": {

--- pinned/memory_export
+++ observed/memory_export
  {
    "description": "Export memory entries to a JSON file (keys, namespaces, timestamps, and values when available). Use when native Write is wrong because the data is rows in .swarm/memory.db, not a file you can copy. For ingesting an export elsewhere use memory_import. (CSV output and embedding-vector export are follow-ups.)",
    "inputSchema": {
+       "dbPath": {
+         "description": "Explicit memory DB to export (default: the AgentDB store plus the CLI sibling)",
+         "type": "string"
+       },
        "format": {
          "description": "Export format (csv falls back to json today)",
          "enum": [

--- 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.",
+   "description": "Import memory entries from a JSON export file (produced by memory_export) into .swarm/memory.db, re-embedding values. Preserves tags when present in the export (ruflo-memory-export/v1.1+). 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": {
      "properties": {
        "dbPath": {

--- pinned/memory_list
+++ observed/memory_list
  {
    "description": "Enumerate stored memory entries (optionally filtered by namespace/tags) without semantic search. Use when native Glob is wrong because the entries are not files (they live in .swarm/memory.db). For inspection / audit / \"what is in my memory\" — pair with memory_search for retrieval-by-meaning.",
    "inputSchema": {
+       },
+       "tags": {
+         "description": "Require entries to include all of these tags (AND). Matches the description claim \"optionally filtered by namespace/tags\".",
+         "items": {
+           "type": "string"
+         },
+         "type": "array"
        }
      },
      "type": "object"

+ tool added: team_broadcast

+ tool added: team_create

+ tool added: team_inbox

+ tool added: team_on_stop

+ tool added: team_plan

+ tool added: team_send

+ tool added: team_shutdown

+ tool added: team_spawn

+ tool added: team_status

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)