{
  "schema_version": 1,
  "server_id": "mnemosyne-os-mcp",
  "package": "@mnemosyne_os/mcp",
  "version": "2.2.0",
  "collected_at": "2026-11-16T22:06:30.890Z",
  "analyzed_at": "2026-11-16T22:06:30.890Z",
  "modelara_version": "v0.1.8",
  "fingerprint": "sha256:ccc62c3d0f45c477d6f111a34da4e785e29202d78b92ffe4f6c933ae045609ac",
  "tool_count": 25,
  "interface": {
    "format": "modelara.inspect/v0",
    "capability_set": {
      "source": {
        "type": "mcp",
        "name": "mnemosyne-os",
        "version": "2.2.0",
        "protocol_version": "2025-11-25"
      },
      "discovered_at": "2026-11-16T22:06:30.56063732Z",
      "capabilities": [
        {
          "id": "mcp:mnemosyne-os/mnemosyne_about",
          "name": "mnemosyne_about",
          "title": "About Mnemosyne OS",
          "description": "Re-read the server instructions: the governance tenet, the vault protection model (NORMAL and MAXIMUM, mixableWith, isolated sandbox vaults), the spine model, and the rules for an agent working on someone else's memory. Most clients show this text on connect. Call it if yours did not, or to read it again.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_about"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:fa31d193adefd922a5257742647c712e8152b854ac3e4f66f03d0d47decc3533"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agenda_add",
          "name": "mnemosyne_agenda_add",
          "title": "Add appointments",
          "description": "Put appointments or deadlines into the user's calendar, the Agenda widget on their canvas. Use it when a conversation names a date and time to remember: a meeting, a deadline, \"add this to my calendar\". The app routes the write through the widget's own store, so what you file is what the user sees. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. To read the calendar back, change or remove an appointment, see mnemosyne_agenda_list, mnemosyne_agenda_update and mnemosyne_agenda_remove.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agenda_add"
          },
          "input_schema": {
            "properties": {
              "events": {
                "description": "One or more appointments to add.",
                "items": {
                  "properties": {
                    "alarm_minutes_before": {
                      "description": "Minutes before \"start\" a reminder rings in the app. Omit for no reminder. 0 = at the time; 1440 = a day before.",
                      "type": "number"
                    },
                    "all_day": {
                      "description": "True for a day marker with no specific time (a deadline's date, a holiday). Default false.",
                      "type": "boolean"
                    },
                    "description": {
                      "description": "Optional notes.",
                      "type": "string"
                    },
                    "end": {
                      "description": "ISO 8601 date-time the appointment ends. Optional; omit for a point-in-time reminder or deadline rather than a block of time.",
                      "type": "string"
                    },
                    "location": {
                      "description": "Optional.",
                      "type": "string"
                    },
                    "recurrence": {
                      "description": "Omit for a one-off appointment. A recurring event keeps its day-of-month/weekday from \"start\".",
                      "enum": [
                        "daily",
                        "weekly",
                        "monthly",
                        "yearly"
                      ],
                      "type": "string"
                    },
                    "start": {
                      "description": "ISO 8601 date-time, e.g. \"2026-09-10T14:00:00\". No timezone offset = read as the HUMAN'S OWN machine local time, never UTC. Do not add a \"Z\" unless you mean UTC.",
                      "type": "string"
                    },
                    "title": {
                      "description": "What the appointment is, e.g. \"Dentist\" or \"Ship the report\".",
                      "type": "string"
                    }
                  },
                  "required": [
                    "title",
                    "start"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "events"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:35f9ce8914caefed3bf7735273e67934f10227fbfd753daf72c3f4570ca48d65"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agenda_list",
          "name": "mnemosyne_agenda_list",
          "title": "List appointments",
          "description": "Read the user's calendar back: the appointments in a time window, each with the id you need to change or remove it. Call this before mnemosyne_agenda_update and mnemosyne_agenda_remove, which both name appointments by id. The calendar has no archive and a removal cannot be undone. A repeating event appears once, with its cadence and the date of its next occurrence. Times in the answer are the user's machine local time. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope agenda:read.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agenda_list"
          },
          "input_schema": {
            "properties": {
              "from": {
                "description": "ISO 8601 date-time (or epoch ms). Only appointments with an occurrence at or after this. Omitted = now.",
                "type": "string"
              },
              "include_past": {
                "default": false,
                "description": "Include appointments with no occurrence left. Default false. Those ones come back with no \"next\" date rather than with their original start dressed up as a future one.",
                "type": "boolean"
              },
              "limit": {
                "description": "Maximum appointments returned (default and ceiling: 200).",
                "type": "number"
              },
              "to": {
                "description": "ISO 8601 date-time (or epoch ms). Only appointments with an occurrence at or before this. Omitted = no upper bound, which for a repeating event means it always counts.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:1ab26be696da05babedf820d7eb08334c667872b3d6dc8072939eeb3769c7e8b"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agenda_remove",
          "name": "mnemosyne_agenda_remove",
          "title": "Remove appointments",
          "description": "Remove appointments from the user's calendar. Read them with mnemosyne_agenda_list first and pass the ids. This tool matches by id only, because \"remove my meetings on Thursday\" is how an agent removes the wrong Thursday. There is no archive: unlike a To-do task, a removed appointment is gone, so the answer names each one it removed by title and start time for the user to check. A repeating appointment is removed as a whole series, since the calendar cannot cancel a single occurrence. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope agenda:write.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agenda_remove"
          },
          "input_schema": {
            "properties": {
              "event_ids": {
                "description": "The appointment ids to remove, exactly as mnemosyne_agenda_list printed them in brackets. Up to 50.",
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "event_ids"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f4e2dd05973f61a9b9b191d4c08da8d0ad705ca859d90aec888a1d4294b59639"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agenda_update",
          "name": "mnemosyne_agenda_update",
          "title": "Change an appointment",
          "description": "Change an appointment already in the user's calendar: move it, rename it, add or drop a reminder, start or stop it repeating. It names appointments by the id from mnemosyne_agenda_list, so call that first. A field you leave out is left alone, and passing null clears it. A start or end time that cannot be read refuses the change rather than leaving the old one quietly in place. A cadence outside daily, weekly, monthly and yearly is refused rather than turned into a one-off. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope agenda:write.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agenda_update"
          },
          "input_schema": {
            "properties": {
              "changes": {
                "description": "One entry per appointment. Up to 50 per call.",
                "items": {
                  "properties": {
                    "alarm_minutes_before": {
                      "description": "Minutes before the start a reminder rings; null removes the reminder. Changing only this keeps the existing ring sound and volume.",
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "all_day": {
                      "description": "Day marker with no specific time.",
                      "type": "boolean"
                    },
                    "description": {
                      "description": "null clears it.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "end": {
                      "description": "New end, ISO 8601. null makes it a point in time rather than a block.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "event_id": {
                      "description": "The appointment id, exactly as mnemosyne_agenda_list printed it in brackets.",
                      "type": "string"
                    },
                    "location": {
                      "description": "null clears it.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "recurrence": {
                      "description": "daily / weekly / monthly / yearly, or null to STOP repeating (which also drops the series end date, since it would describe a series that no longer exists).",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "start": {
                      "description": "New start, ISO 8601. No timezone offset = the HUMAN'S OWN machine local time, never UTC.",
                      "type": "string"
                    },
                    "title": {
                      "description": "New title. Cannot be emptied.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "event_id"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "changes"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:2c9e1363d413d62c0fc14cc8cd36507d98b6f1a783e650537876dc8cb99d5af7"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agent_collisions",
          "name": "mnemosyne_agent_collisions",
          "title": "Check agent collisions",
          "description": "Check whether two agent sessions are live in the same git working tree and branch right now, across every installed harness. Call it before `git add -A`, before a commit, and before a rebase: one working tree shares one git index, so a commit from one session picks up whatever the other has staged. It answers from transcript files on disk and needs neither Mnemosyne OS nor a token. Each recorded directory is resolved to its working tree first, because one `cd` into a subfolder would make two sessions in one repository look like two projects. A clean answer covers what is readable: a session whose transcripts live elsewhere does not appear at all, and sessions whose harness records no directory are listed separately as unplaceable.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agent_collisions"
          },
          "input_schema": {
            "properties": {
              "project": {
                "description": "Restrict to one working tree, matched exactly (separators and case are normalised). Pass the output of `git rev-parse --show-toplevel`. Omit to check every project on the machine.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:5b5dce1199ca1c74f51876b56aa0baf3124623876e23283c8cd1a4973d642b62"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agent_files",
          "name": "mnemosyne_agent_files",
          "title": "List files an agent wrote",
          "description": "List the files other agent sessions wrote or edited recently, newest first, with the session each one came from. Paths and timestamps only. Each entry says how it is known. `recorded` means the harness logged a file-writing tool call. `from a command` means a redirection was read out of a shell command the session ran, which may never have completed. It spans every installed harness and names the agent each line came from. Use it to see what another session has already touched before you edit the same area.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agent_files"
          },
          "input_schema": {
            "properties": {
              "contains": {
                "description": "Keep only paths containing this string. A folder name works as well as a file name.",
                "type": "string"
              },
              "limit": {
                "default": 40,
                "description": "Max files to return (default 40, max 200).",
                "type": "number"
              },
              "project": {
                "description": "Keep only files from sessions whose project path contains this string.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:e2f4cd4f7f89edafee7b1a3a1e877009f0f6f67c6911dd829e87bf1e0af02197"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_agent_list",
          "name": "mnemosyne_agent_list",
          "title": "List coding agents",
          "description": "List the other coding-agent sessions on this machine, read from the transcript files their harnesses already write to disk. Metadata only: conversation name, project, git branch, model, last tool, how many files were touched, and when a line was last written. It reads every harness installed here, not just your own, so you can see a session from a different agent working in your repository. Use it before you touch shared state. It reports when a line was last seen and you draw the conclusion: a crashed session and an idle one fall equally silent, so nothing here can tell you an agent is working. Works with the Mnemosyne OS app closed.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_agent_list"
          },
          "input_schema": {
            "properties": {
              "limit": {
                "default": 40,
                "description": "How many transcripts to open PER HARNESS, newest first (default 40, max 200). Capping the merged total instead would let a chatty agent push a quiet one off the end, and the quiet one is the session you did not know about.",
                "type": "number"
              },
              "live_only": {
                "default": false,
                "description": "Only sessions that wrote a line recently (see the window printed in the answer). Default false, which lists the most recent sessions whether or not they moved lately.",
                "type": "boolean"
              },
              "project": {
                "description": "Keep only sessions whose project path contains this string. Pass the repository folder name to scope the answer to the repo you are working in.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:0f96f6e6bec8b0f398670c0fb3ceca0a0d78081040a929411482b60859c28274"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_cockpit_update",
          "name": "mnemosyne_cockpit_update",
          "title": "Update your status card",
          "description": "Update your own status card on the user's canvas, the cockpit. Call it when you start a task (\"working\", with a short title and status), when you need the user (\"waiting\"), when you are stuck (\"blocked\"), and when you finish (\"done\"). \"waiting\" and \"blocked\" make the card pulse and the taskbar flash. Send \"waiting\" IN THE SAME TURN as the question you ask the user, right before you stop: the harness only knows to say \"waiting\" for a permission prompt, and a question asked in the chat is otherwise just the end of a turn — the user never sees that you are waiting for them. Your \"waiting\" survives the harness saying the turn ended. You declare the state; the app prints it next to the time since your last call, so keep calling at real milestones or the card goes quiet. The answer carries any message the user left on your card. Read it and act on it. Needs the app window open. This is a card, so nothing is stored in memory.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_cockpit_update"
          },
          "input_schema": {
            "properties": {
              "attention": {
                "default": false,
                "description": "Ask for the human's eye even in \"working\"/\"done\" (the card pulses, the taskbar flashes). \"waiting\" and \"blocked\" ask on their own.",
                "type": "boolean"
              },
              "desktop": {
                "description": "The desktop this session should put its cards on, by name, exactly as the human wrote it. Send it once when they tell you; the card stays there for the rest of the conversation without you repeating it. The match is exact apart from case, and an unknown or duplicated name is reported back with the names that exist rather than guessed at. Leave it out and the card goes to whichever desktop answers for this project, which is what most sessions want.",
                "type": "string"
              },
              "detail": {
                "description": "Up to 4 short lines under the status (files, a branch, a count). Optional.",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "session": {
                "description": "Only when the harness publishes no CLAUDE_CODE_SESSION_ID: a stable id for this conversation, reused on every call.",
                "type": "string"
              },
              "state": {
                "description": "\"working\" = on it; \"waiting\" = you asked the human something and stopped; \"done\" = the task is finished; \"blocked\" = you cannot continue without them; \"closed\" = this conversation is over (removes the card).",
                "enum": [
                  "working",
                  "waiting",
                  "done",
                  "blocked",
                  "closed"
                ],
                "type": "string"
              },
              "status": {
                "description": "One line: what you are doing right now, or what you need. 160 characters max.",
                "type": "string"
              },
              "title": {
                "description": "What this conversation is about, in a few words (the card's title). Give it at least once; later calls may omit it.",
                "type": "string"
              }
            },
            "required": [
              "state"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:67f8c56b1acb5eb7f12b76f919165dbc71de8cba3d2773be2ac9ca739c9f546b"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_dream_bridges",
          "name": "mnemosyne_dream_bridges",
          "title": "List dream bridges",
          "description": "List the connections the Dream State engine found between memories while the machine was idle. Each bridge links two memories, sometimes from different vaults, with a Dream Bridge Score, a raw cosine similarity, and a short excerpt of both sides. Use it to surface associations the memory made on its own, to audit whether they are insightful or noise, or to seed creative exploration. An empty list is normal and means the engine has not produced bridges yet. It runs on idle time, when the user enables it in Settings.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_dream_bridges"
          },
          "input_schema": {
            "properties": {
              "chronicle_id": {
                "description": "Only bridges touching this chronicle id (either endpoint).",
                "type": "number"
              },
              "limit": {
                "default": 50,
                "description": "Max bridges to return, strongest (highest dbs) first (default: 50, server cap: 200).",
                "type": "number"
              },
              "min_dbs": {
                "description": "Only bridges with a Dream Bridge Score at or above this value (0-1).",
                "type": "number"
              },
              "session_id": {
                "description": "Restrict to one dream scan session.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:61b4612ae088d71f1ec5e98ba424f5bac52ac81d6fa9c5d00e3370ea7bfe5703"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_git_log",
          "name": "mnemosyne_git_log",
          "title": "Read git history",
          "description": "Read recent commits from the git repository this Mnemosyne OS is configured to read. Read-only. Each commit carries an 8-character hash, the subject line, the author and the date, newest first. The path is set on the app side, so this cannot be pointed at another checkout, and it needs the monorepo:read scope. When either is missing the answer names what is missing, rather than returning an empty list that would read as \"no commits\". Use mnemosyne_memory_query for the reasoning behind a change.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_git_log"
          },
          "input_schema": {
            "properties": {
              "limit": {
                "default": 20,
                "description": "Number of commits to return (default: 20)",
                "type": "number"
              },
              "since": {
                "default": "30 days ago",
                "description": "Time range (e.g. \"7 days ago\", \"2024-01-01\")",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:995218d07d607e52fef6d4d2423aa7175c2bc1468e2f53add534be12e38934e8"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_memory_ask",
          "name": "mnemosyne_memory_ask",
          "title": "Ask the vault",
          "description": "Ask a question and get a prose answer grounded in the vault, plus the memories it drew on. It runs the full local RAG pipeline: deeper retrieval, lexical fusion and a re-rank. That also makes it the better retriever, so reach for it whenever you need to find something, and read the Sources list even if you ignore the prose. It is at its best on why, who and how questions that span many memories. It takes up to about 30 seconds. The prose is a model rewording of the sources, so quote the sources instead, or fetch them with mnemosyne_memory_query. Check them before you trust the answer.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_memory_ask"
          },
          "input_schema": {
            "properties": {
              "question": {
                "description": "A question in plain language, the way you would ask a colleague who knows the material. Be specific.",
                "type": "string"
              },
              "vault": {
                "default": "DEV",
                "description": "Vault to reason over, case-insensitive. Default for this deployment: \"DEV\". A vault this server is not scoped for is refused.",
                "type": "string"
              }
            },
            "required": [
              "question"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:cdf998f284a3d4bb48c215cfd3a006cbb441593387321fa4c0b8f546fc220c0e"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_memory_ingest",
          "name": "mnemosyne_memory_ingest",
          "title": "Save a memory",
          "description": "Write a memory into a vault: a decision, an architecture note, a debug finding, a session summary. It is stored permanently and indexed for every future agent to retrieve. Use it at the end of a meaningful work session, or whenever a decision is reached that someone will want to recall later.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_memory_ingest"
          },
          "input_schema": {
            "properties": {
              "content": {
                "description": "The content to store. Markdown works. Write it self-contained, and say WHY the decision was made rather than only what was decided.",
                "type": "string"
              },
              "spine_type": {
                "default": "NOTE",
                "description": "Semantic type of the content. ARCHITECTURE is boosted heavily in code-scope queries: use it for design docs, big-picture decisions and structural choices. DECISION for narrower trade-offs. BUGFIX and DEBUG for incident learnings. SESSION for where you left off. FEATURE for new capabilities. NOTE for the rest.",
                "enum": [
                  "DECISION",
                  "ARCHITECTURE",
                  "DEBUG",
                  "BUGFIX",
                  "FEATURE",
                  "NOTE",
                  "SESSION",
                  "RESONANCE",
                  "CUSTOM"
                ],
                "type": "string"
              },
              "vault": {
                "default": "DEV",
                "description": "Target vault TOKEN: the folder name uppercased, with spaces and hyphens as underscores. The path-shaped id from mnemosyne_vault_list also works. Default for this deployment: \"DEV\". Scoped tokens, which are configuration rather than a census: DEV, PERSONAL, SOCIAL. Ingest is permanent, so confirm the vault exists with mnemosyne_vault_list before writing anywhere new.",
                "type": "string"
              }
            },
            "required": [
              "content"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:7086c4194a6d64b1c3051b0bd7d099daf8f5b53f9b6f74ff8f055c3fe99846f2"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_memory_query",
          "name": "mnemosyne_memory_query",
          "title": "Search chronicles",
          "description": "Search a vault and get the matching memories back word for word: notes, code, decisions, session summaries, commit history. Nothing is rewritten, so use this when you need the source text itself, to quote it or to write documentation from it. Ranking is vector similarity fused with a local BM25 channel, weighted by spine type. To FIND something rather than quote it, prefer mnemosyne_memory_ask, even when you only want its sources. It retrieves deeper and re-ranks, so it catches rare literal terms this tool misses: proper nouns, identifiers, product names. The score is not a confidence value. A hit and a miss come back with similar numbers, so judge the text, not the number beside it.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_memory_query"
          },
          "input_schema": {
            "properties": {
              "limit": {
                "default": 10,
                "description": "Max number of results (default: 10, max: 50)",
                "type": "number"
              },
              "max_content_chars": {
                "default": 600,
                "description": "Per-memory snippet size in characters (default 600). Each result is cut to this length, with a hint about its full size. Raise it past 2000 when you need whole files, and watch your context window.",
                "type": "number"
              },
              "query": {
                "description": "The search query. Be specific. Examples: \"why we moved off Postgres\", \"the retry logic in the payment worker\", \"notes from the March planning session\".",
                "type": "string"
              },
              "spine_type_filter": {
                "description": "Optional whitelist of spine types. Use [\"ARCHITECTURE\"] for design docs, [\"GIT\"] for commit history, [\"BUGFIX\",\"DEBUG\"] for incident knowledge, [\"SOURCE_CODE\"] for code only. Omit it to get every type, with the SOURCE_CODE scope weighting deciding the ranking.",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "vault": {
                "default": "DEV",
                "description": "Vault TOKEN to search, case-insensitive. A token is the folder name uppercased, with spaces and hyphens as underscores. The path-shaped id from mnemosyne_vault_list also works. This deployment's default is \"DEV\". It is also scoped for: PERSONAL, SOCIAL. That list is configuration rather than a census, so call mnemosyne_vault_list for the vaults that exist on this machine. Anything outside the list is refused.",
                "type": "string"
              }
            },
            "required": [
              "query"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f71ff63669b50ab56c8b6b8cfec157da86bf9fa7e96d71d1e1a7e2f15395d34d"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_pheme_radar",
          "name": "mnemosyne_pheme_radar",
          "title": "Read the Pheme radar",
          "description": "Read what the user's Pheme radar last found: fresh threads in the subreddits and Hacker News queries they watch. Each thread carries a topic score, and a tier once they have run the Mnemosyne pass. The tier says how much substance they can bring to that thread. The answer leads with when the scan ran, because it is only as fresh as the last time they opened Pheme and pressed Scan. Use it to find threads to draft a reply for; the user posts it. \"No radar\" means no scan has been projected yet, so ask them to open Pheme and scan. Needs the app running, though Pheme itself can be closed.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_pheme_radar"
          },
          "input_schema": {
            "properties": {
              "limit": {
                "default": 30,
                "description": "How many threads at most (default 30, max 100).",
                "type": "number"
              },
              "tier": {
                "description": "Only threads of this tier. Omit for all (unranked ones included, last).",
                "enum": [
                  "high",
                  "mid",
                  "low"
                ],
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:ca56a57bd5f4ac7c9f637329ce09aaecb72c413525f6bc70040ed8e13fffcad6"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_pheme_watch",
          "name": "mnemosyne_pheme_watch",
          "title": "Edit the Pheme watchlist",
          "description": "Add a subreddit, a Hacker News search query or a topic to the user's Pheme radar, or take one off. Pheme is their reputation cartridge: it finds fresh threads worth a genuine reply. The lists belong to them. An operation that would empty one is refused. Every operation reports its own outcome: done, already there, not there, refused. The user gets a receipt in Pheme naming this agent and what changed. Use it when a conversation finds a community worth watching. It scans nothing and posts nothing; the user posts. Needs the app running, though Pheme itself can be closed.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_pheme_watch"
          },
          "input_schema": {
            "properties": {
              "ops": {
                "description": "The changes, in order. Up to 50.",
                "items": {
                  "properties": {
                    "kind": {
                      "description": "\"sub\" = a subreddit (with or without r/); \"topic\" = an expertise topic that scores every network's radar; \"hnQuery\" = a Hacker News search query.",
                      "enum": [
                        "sub",
                        "topic",
                        "hnQuery"
                      ],
                      "type": "string"
                    },
                    "op": {
                      "enum": [
                        "add",
                        "remove"
                      ],
                      "type": "string"
                    },
                    "value": {
                      "description": "The subreddit name, topic or query. 120 characters max.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "op",
                    "kind",
                    "value"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "ops"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:b3302b6c84c31b7563936b212fa836fe676f440be4c380c947cca971e1853e44"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_position_get",
          "name": "mnemosyne_position_get",
          "title": "Read a resonance position",
          "description": "Read where one resonance was left: the phase, and the free-text note an agent or the cockpit wrote when it stopped. Read-only. It returns the resonance id, when it was saved, the spine type of the memory, and the whole note. An id nothing was ever saved under answers in plain words and points at mnemosyne_position_update, so a blank history and a failed call do not look alike. Call mnemosyne_resonance_list when you do not know the id.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_position_get"
          },
          "input_schema": {
            "properties": {
              "resonance_id": {
                "description": "ID of the resonance, for example \"checkout-rewrite\" or \"v2-migration\".",
                "type": "string"
              }
            },
            "required": [
              "resonance_id"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:0f8b7de5c5237e8c8eed7bd5e5165251b35d2120646125ef5d2f837f3cdfe7dc"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_position_update",
          "name": "mnemosyne_position_update",
          "title": "Record where you left off",
          "description": "Record where you left off on a resonance: phase, current state, next steps. Call it at the end of a session. It is stored as a DECISION memory in the vault.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_position_update"
          },
          "input_schema": {
            "properties": {
              "phase": {
                "description": "Current phase label (e.g. \"Phase 52\", \"v1.1.0 release\")",
                "type": "string"
              },
              "position": {
                "description": "Description of the current position / what was done / what is next",
                "type": "string"
              },
              "resonance_id": {
                "description": "ID of the resonance to update",
                "type": "string"
              }
            },
            "required": [
              "resonance_id",
              "position",
              "phase"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:3d0c32b862cda2cc2c455e02aac22f8264ccdc25495a59530d3a8b58fa575c66"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_resonance_list",
          "name": "mnemosyne_resonance_list",
          "title": "List resonances",
          "description": "List the resonances recorded in the default vault. A resonance is a workspace that tracks one ongoing project. Each entry carries its id, its last phase, how many minutes ago it moved, and the id of the memory behind it. Read-only. There is no status filter, so you get every resonance the scan matched in one vault, from at most 30 candidates. An empty result is written in words and means no resonance has been recorded yet. Read one in full with mnemosyne_position_get, or write a new one with mnemosyne_position_update.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_resonance_list"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:dda4e2ee8a2be3b405f464135bdfed459c1961cbaf85cbc62b4d42a87bdfa21b"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_spine_assignments",
          "name": "mnemosyne_spine_assignments",
          "title": "List spine assignments",
          "description": "See how Mnemosyne classified its memories. It returns the memory-to-spine assignments for one vault, newest first, and the per-spine counts for the whole vault. Use it to check whether memories landed in the right spines, to read a vault's composition at a glance, or to find the taxon ids to pass as spine_type_filter in mnemosyne_memory_query. Set include_taxonomy to also get the global spine tree.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_spine_assignments"
          },
          "input_schema": {
            "properties": {
              "include_taxonomy": {
                "default": false,
                "description": "Also return the global spine taxonomy tree (natures → sub-spines).",
                "type": "boolean"
              },
              "limit": {
                "default": 25,
                "description": "Max assignments returned (default: 25 to stay context-friendly, server cap: 500).",
                "type": "number"
              },
              "offset": {
                "default": 0,
                "description": "Pagination offset (default: 0).",
                "type": "number"
              },
              "spine_type": {
                "description": "Restrict the assignment page to one spine taxon id (e.g. \"DOCUMENT\", \"GIT\"). Counts stay whole-vault.",
                "type": "string"
              },
              "vault": {
                "default": "DEV",
                "description": "Vault to inspect, case-insensitive. Default for this deployment: \"DEV\".",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8db40169cb22e8fb89eaf154926afd98142b539c165fa55108d0bc01ca6e54bf"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_todo_add",
          "name": "mnemosyne_todo_add",
          "title": "Add To-do tasks",
          "description": "Put tasks into the user's To-do backlog, the To-do widget on their canvas, in order and optionally under named steps. Use it when a conversation has settled what to do. Name the destination list in \"list\": call once without it to get the existing lists back on a LIST_NOT_FOUND answer, or pass create_list: true to make a new one. Always name a list, and file one plan into ONE list, its steps as \"group\". Write each text as a short title a person can say aloud (about 80 characters); the detail goes in \"description\". A rule, a trap or a decision is not something to do: file it with kind \"note\", so it stays as context and counts in no total. On a recent app your tasks wait in « To triage » until the human keeps them, and each gets a number (#42) shown by mnemosyne_todo_list. The app routes the write through the widget's own store, so what you file is what the user sees. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. To read the backlog back or change what is in it, see mnemosyne_todo_list, mnemosyne_todo_update and mnemosyne_todo_categories.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_todo_add"
          },
          "input_schema": {
            "properties": {
              "color": {
                "description": "Hex colour (#rrggbb) for a list being created. Optional; the host picks the next swatch otherwise.",
                "type": "string"
              },
              "create_list": {
                "default": false,
                "description": "Create the list named in \"list\" when it does not exist. Default false, so an agent does not invent lists in someone's backlog without saying so.",
                "type": "boolean"
              },
              "list": {
                "description": "Displayed name of the destination list, case-insensitive: \"Today\", \"WIP\", or a list the user created. Omitted, it goes to the first original list. An unknown name with create_list false is refused, and the answer gives the names that exist.",
                "type": "string"
              },
              "tasks": {
                "description": "The tasks, in execution order. Each item is a string, or an object: \"text\" (a short title), \"group\" (the STEP it belongs to, e.g. \"Step 1 · Mockup\"; tasks with the same group are shown under one header), \"description\" (the detail, 4000 max), \"kind\" (\"note\" for context that is not a thing to do), \"status\" (\"doing\", \"waiting\" or \"someday\"), \"priority\" (\"high\" or \"low\"), \"attachments\" (absolute paths of files or folders the task is about, or {\"path\", \"kind\": \"file\"|\"dir\", \"label\"}). 300 characters max per text; a longer text is filed shortened and the answer says so.",
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "properties": {
                        "attachments": {
                          "items": {
                            "anyOf": [
                              {
                                "type": "string"
                              },
                              {
                                "properties": {
                                  "kind": {
                                    "enum": [
                                      "file",
                                      "dir"
                                    ],
                                    "type": "string"
                                  },
                                  "label": {
                                    "type": "string"
                                  },
                                  "path": {
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "path"
                                ],
                                "type": "object"
                              }
                            ]
                          },
                          "type": "array"
                        },
                        "description": {
                          "type": "string"
                        },
                        "group": {
                          "type": "string"
                        },
                        "kind": {
                          "enum": [
                            "note"
                          ],
                          "type": "string"
                        },
                        "priority": {
                          "enum": [
                            "high",
                            "low"
                          ],
                          "type": "string"
                        },
                        "status": {
                          "enum": [
                            "doing",
                            "waiting",
                            "someday"
                          ],
                          "type": "string"
                        },
                        "text": {
                          "type": "string"
                        }
                      },
                      "required": [
                        "text"
                      ],
                      "type": "object"
                    }
                  ]
                },
                "type": "array"
              }
            },
            "required": [
              "tasks"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f12ce3973896246481ee92c54e63a2a35d04e8c612a4b1dd0a724f1dfd99c981"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_todo_categories",
          "name": "mnemosyne_todo_categories",
          "title": "List To-do lists",
          "description": "Manage the lists of the user's To-do backlog: create one, rename or recolour one, remove an empty one. It is separate from mnemosyne_todo_update because these change the shape of a workspace rather than the work in it. Two refusals are worth knowing before you call. A list that still holds tasks is never removed, and you are told how many are in the way: move them first, since the app will not pick a destination on someone's behalf. The three original lists can be renamed, never removed, because their contents are what make the file readable. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope todo:write.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_todo_categories"
          },
          "input_schema": {
            "properties": {
              "ops": {
                "description": "The changes, applied in order - so you can create a list and rename another in one call.",
                "items": {
                  "properties": {
                    "color": {
                      "description": "Hex colour (#rrggbb). Optional; the host picks the next swatch for a new list.",
                      "type": "string"
                    },
                    "list": {
                      "description": "list.edit / list.remove: which list, by displayed name or key.",
                      "type": "string"
                    },
                    "name": {
                      "description": "list.create: the name. list.edit: the new name; passing an empty string on one of the three ORIGINAL lists gives it back its localised default name.",
                      "type": "string"
                    },
                    "op": {
                      "description": "list.create = a new empty list. list.edit = rename and/or recolour. list.remove = delete an EMPTY, non-original list.",
                      "enum": [
                        "list.create",
                        "list.edit",
                        "list.remove"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "op"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "ops"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:ab71216d51a5afc00b7bfab4dea43c0653e6669667b4d43b17a10c0605193d07"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_todo_list",
          "name": "mnemosyne_todo_list",
          "title": "List To-do tasks",
          "description": "Read the user's To-do backlog back: the lists that exist and the tasks in them, each with the id (and the short number, #42) you need to change it, its status, priority, whether it is a note or waits in triage, and the names of its attached files. Call this before mnemosyne_todo_update, which names tasks by id or number. A phrase like \"delete the task about the invoice\" reads perfectly and can still match the wrong task. This is also the way to answer \"what is on my plate\", or to check whether something is already filed before you add a duplicate. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope todo:read.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_todo_list"
          },
          "input_schema": {
            "properties": {
              "include_done": {
                "default": false,
                "description": "Include tasks already checked off. Default false: the open ones are what almost every question is actually about. Tasks moved to the ARCHIVE are never listed, only counted.",
                "type": "boolean"
              },
              "include_paths": {
                "default": false,
                "description": "Also print the full path of each attached file or folder, not only its name. Default false. A folder's content is never listed here.",
                "type": "boolean"
              },
              "limit": {
                "description": "Maximum tasks returned (default and ceiling: 300). The answer always says how many matched and how many were cut.",
                "type": "number"
              },
              "list": {
                "description": "Only this list, by displayed name (case-insensitive) or by the key shown in brackets. Omitted = every list. A name that matches nothing returns NO tasks rather than silently widening to all of them.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:077137b1c30149d7aba878ec5320c51a3d44e5ecef154e3b53f9911a3b4164fe"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_todo_update",
          "name": "mnemosyne_todo_update",
          "title": "Change the To-do backlog",
          "description": "Change the user's To-do backlog: edit a task, tick it off, move it to another list, or take it out. Every operation names a task by the id from mnemosyne_todo_list, so call that first. Removing a task archives it by default, and it can be restored. Pass permanent: true only when the user asked for it to be deleted outright. The whole batch is applied in order as one save, and each operation reports its own outcome, so a stale id does not sink the ones around it. Works with the app closed on a dev install (the headless daemon reads the file); an npm install has no daemon and needs the app running. Scope todo:write.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_todo_update"
          },
          "input_schema": {
            "properties": {
              "ops": {
                "description": "The changes, applied in order. Up to 100 per call.",
                "items": {
                  "properties": {
                    "color": {
                      "description": "edit: hex colour, or null to clear.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "description": {
                      "description": "edit: new notes. null clears them; omitting leaves them alone.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "done": {
                      "description": "complete: true ticks it, false re-opens it. Ticking records the human's streak; un-ticking never takes it back.",
                      "type": "boolean"
                    },
                    "dropped": {
                      "default": false,
                      "description": "remove: archive it as « not planned » rather than as tidied away.",
                      "type": "boolean"
                    },
                    "dueAt": {
                      "description": "edit: due date as epoch milliseconds. null clears it.",
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "group": {
                      "description": "edit: the STEP heading this task sits under. null removes it.",
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "kind": {
                      "description": "edit: \"note\" turns a task into context (not ticked, counted nowhere); \"task\" turns it back.",
                      "enum": [
                        "note",
                        "task"
                      ],
                      "type": "string"
                    },
                    "label": {
                      "description": "attach: a name to show instead of the file name.",
                      "type": "string"
                    },
                    "list": {
                      "description": "move: the destination list, by displayed name or key.",
                      "type": "string"
                    },
                    "op": {
                      "description": "edit = rewrite text/description/colour/step/due date/status/priority, or turn it into a note. complete = tick or un-tick (a note cannot be ticked). move = send to another list. remove = archive it (dropped: true marks it « not planned »), or delete it with permanent: true. attach = attach a file or folder by absolute path. detach = take an attachment off by its path.",
                      "enum": [
                        "edit",
                        "complete",
                        "move",
                        "remove",
                        "attach",
                        "detach"
                      ],
                      "type": "string"
                    },
                    "path": {
                      "description": "attach / detach: the ABSOLUTE path of the file or folder. Nothing is read: only the path is stored.",
                      "type": "string"
                    },
                    "permanent": {
                      "default": false,
                      "description": "remove: true DELETES the task outright, and it is not in the archive afterwards. Default false = archived, recoverable. Only pass true when the human asked to delete rather than to tidy away.",
                      "type": "boolean"
                    },
                    "priority": {
                      "description": "edit: high or low. null is normal.",
                      "enum": [
                        "high",
                        "low",
                        null
                      ],
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "status": {
                      "description": "edit: where its work stands. null puts it back to « to do ».",
                      "enum": [
                        "doing",
                        "waiting",
                        "someday",
                        null
                      ],
                      "type": [
                        "string",
                        "null"
                      ]
                    },
                    "task": {
                      "description": "The task id, exactly as mnemosyne_todo_list printed it in brackets, or its number (#42).",
                      "type": "string"
                    },
                    "text": {
                      "description": "edit: the new text. Omit to leave it alone; it can never be emptied.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "op",
                    "task"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "ops"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:fd5e7018bb92e94a5c9ccbdb738d89196f2eb7d34f8fd2ac97e46e8e6ee844ea"
        },
        {
          "id": "mcp:mnemosyne-os/mnemosyne_vault_list",
          "name": "mnemosyne_vault_list",
          "title": "List vaults",
          "description": "List the memory vaults this Mnemosyne OS exposes, each with its token, display name, memory count and, when the owner wrote one, a line on what it holds. Call it first when you are unsure which vault to work against, or when the user names a store you have not seen. Pass the bold token as the `vault` argument of the other tools. The `id` line is a local path and the other tools do not take it. Vaults this server was not configured for are flagged here and refused until the user adds them.",
          "source": {
            "type": "mcp",
            "server": "mnemosyne-os",
            "operation": "mnemosyne_vault_list"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "unknown",
            "idempotent": "false",
            "open_world": "unknown"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "unknown"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:cb22be1321545cb67f3804d972b573de9d915bafa9c994dcd329d0d27b609b01"
        }
      ],
      "discovery_order": [
        "mcp:mnemosyne-os/mnemosyne_about",
        "mcp:mnemosyne-os/mnemosyne_memory_query",
        "mcp:mnemosyne-os/mnemosyne_memory_ask",
        "mcp:mnemosyne-os/mnemosyne_vault_list",
        "mcp:mnemosyne-os/mnemosyne_memory_ingest",
        "mcp:mnemosyne-os/mnemosyne_resonance_list",
        "mcp:mnemosyne-os/mnemosyne_position_get",
        "mcp:mnemosyne-os/mnemosyne_position_update",
        "mcp:mnemosyne-os/mnemosyne_git_log",
        "mcp:mnemosyne-os/mnemosyne_dream_bridges",
        "mcp:mnemosyne-os/mnemosyne_spine_assignments",
        "mcp:mnemosyne-os/mnemosyne_agent_list",
        "mcp:mnemosyne-os/mnemosyne_agent_collisions",
        "mcp:mnemosyne-os/mnemosyne_agent_files",
        "mcp:mnemosyne-os/mnemosyne_cockpit_update",
        "mcp:mnemosyne-os/mnemosyne_pheme_watch",
        "mcp:mnemosyne-os/mnemosyne_pheme_radar",
        "mcp:mnemosyne-os/mnemosyne_todo_add",
        "mcp:mnemosyne-os/mnemosyne_todo_list",
        "mcp:mnemosyne-os/mnemosyne_todo_update",
        "mcp:mnemosyne-os/mnemosyne_todo_categories",
        "mcp:mnemosyne-os/mnemosyne_agenda_list",
        "mcp:mnemosyne-os/mnemosyne_agenda_update",
        "mcp:mnemosyne-os/mnemosyne_agenda_remove",
        "mcp:mnemosyne-os/mnemosyne_agenda_add"
      ],
      "fingerprint": "sha256:ccc62c3d0f45c477d6f111a34da4e785e29202d78b92ffe4f6c933ae045609ac"
    },
    "summary": {
      "total": 25,
      "read_only": 16,
      "potential_writes": 9,
      "destructive": 3,
      "unknown_effects": 0,
      "retry_safe": 16
    },
    "schema_stats": {
      "mcp:mnemosyne-os/mnemosyne_about": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agenda_add": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 9,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 11
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agenda_list": {
        "input": {
          "properties": 4,
          "required": 0,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agenda_remove": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agenda_update": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 10,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 12
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agent_collisions": {
        "input": {
          "properties": 1,
          "required": 0,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agent_files": {
        "input": {
          "properties": 3,
          "required": 0,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemosyne-os/mnemosyne_agent_list": {
        "input": {
          "properties": 3,
          "required": 0,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemosyne-os/mnemosyne_cockpit_update": {
        "input": {
          "properties": 7,
          "required": 1,
          "total_properties": 7,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:mnemosyne-os/mnemosyne_dream_bridges": {
        "input": {
          "properties": 4,
          "required": 0,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:mnemosyne-os/mnemosyne_git_log": {
        "input": {
          "properties": 2,
          "required": 0,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:mnemosyne-os/mnemosyne_memory_ask": {
        "input": {
          "properties": 2,
          "required": 1,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:mnemosyne-os/mnemosyne_memory_ingest": {
        "input": {
          "properties": 3,
          "required": 1,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemosyne-os/mnemosyne_memory_query": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:mnemosyne-os/mnemosyne_pheme_radar": {
        "input": {
          "properties": 2,
          "required": 0,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:mnemosyne-os/mnemosyne_pheme_watch": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:mnemosyne-os/mnemosyne_position_get": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:mnemosyne-os/mnemosyne_position_update": {
        "input": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemosyne-os/mnemosyne_resonance_list": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        }
      },
      "mcp:mnemosyne-os/mnemosyne_spine_assignments": {
        "input": {
          "properties": 5,
          "required": 0,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:mnemosyne-os/mnemosyne_todo_add": {
        "input": {
          "properties": 4,
          "required": 1,
          "total_properties": 14,
          "nested_objects": 2,
          "arrays": 2,
          "max_depth": 3,
          "combinators": 4,
          "refs": 0,
          "complexity": 22
        }
      },
      "mcp:mnemosyne-os/mnemosyne_todo_categories": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 7
        }
      },
      "mcp:mnemosyne-os/mnemosyne_todo_list": {
        "input": {
          "properties": 4,
          "required": 0,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:mnemosyne-os/mnemosyne_todo_update": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 17,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 19
        }
      },
      "mcp:mnemosyne-os/mnemosyne_vault_list": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        }
      }
    }
  },
  "source": {
    "registry": "npm",
    "package": "@mnemosyne_os/mcp",
    "version": "2.2.0",
    "published_at": "2026-10-29T17:43:05.420Z",
    "integrity": "sha512-vQ956Udkzwcmc3ze7giAw8kkLat/z8gqzhCjGBzrzA3WYwMEKefoQJUZyprJEjPcoCKVvNFON21irSuldWkebQ==",
    "repository": "https://github.com/Mnemosyne-OS/Mnemosyne-Neural-OS"
  },
  "analyzer": {
    "name": "modelara",
    "version": "v0.1.8",
    "policy_version": null
  },
  "capability_hash_version": 2,
  "capability_hashes": {
    "mnemosyne-os-mcp:tool:mnemosyne_about": {
      "description": "sha256:01a0e3e4a7068a04bd9acd87193cba26d39390ac97f7a1e898a962dadd2f3ed1",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:77cb985cc9c5aba73720c8290a8927df95d85fc6370231c46effbc68d6c2909f"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agenda_add": {
      "description": "sha256:35fc8f30cda991a1f4c2f943a4879483e8e30d4a1cce83fc1c4c1ff0dcfadc9b",
      "input_schema": "sha256:8509d1f029a60c8134129b492b110fa2f7d7888b562615508cc1e45e0c56a7d2",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:0847a84e3d73bd50bee088d7ec1814bcbde987a9e973a9b7c18589a0b03b53f2"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agenda_list": {
      "description": "sha256:e666e73d63798d0d866dc41b7dea2d9923f6adcc543a2af2a94ee476bd6559ec",
      "input_schema": "sha256:691e565ad7b6809ee3c60a535b7db7f79dc65614209ec3216300d9f786fade5a",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:8d89b82e9e844e9daf79765a626d93f891279e07e20446835bbd9ddd9660e62c"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agenda_remove": {
      "description": "sha256:2f17a449fc88556baf980bf6269c9fddeb9c35c5e8e46dda32e98d967641a964",
      "input_schema": "sha256:837ec7b54c8cf8ecb837e1bb0c4ac6065fba68e17334c2c12447ab7b64fcb3df",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:2b50e432db6586c06b1c081b5a13e7329110ebbb80520544c8092543d08e16e7"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agenda_update": {
      "description": "sha256:5c14f986ff24c78cd97e3258dc8c8df13558fca483187c702a01363b40bea8d7",
      "input_schema": "sha256:52c9f830919d17ae76db9f6262fc045f6828f11d09187bc6ffef7a8dabee924f",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:dacbac2682a2d0e8829c0641ff80a129d043a4fa333da6b1fb698dcb3c71a8c5"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agent_collisions": {
      "description": "sha256:d48feec82c88412df5d7c18bbfdc86649583d208967bf68ffc3ac59a54a1282e",
      "input_schema": "sha256:67ec2469eac7d533a9b1ed0e9bb50bc4558d5487fffdefef0fc6db8afaf9df7e",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:fb8d7eda68328411506daf14330b14782abb86e176da7dd84884849eb31d2100"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agent_files": {
      "description": "sha256:a17aa679817622323c899bc42ac0a4fa010e8fc37b0970fc27e7f8713c71b2f1",
      "input_schema": "sha256:742cb9b409bd76f23324aa7f2ee675995e1a4c063fe57819324656f568b058df",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:2917a4b979db2aa9287f62a40c34d2d32be754159efa83a2aa9f327e9f6888b5"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_agent_list": {
      "description": "sha256:4d62df64f23d521702c412d1338a03c93147973ce8e2a8e7debcc6d0bfcbb354",
      "input_schema": "sha256:ce47040435d1ffa4cf84e33f6760d5e3154de9f3778584176239ca93447969d9",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:d7793c10680e0f8e73a20675ec72929f78d74a234aa534b3e700b104a4876a2b"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_cockpit_update": {
      "description": "sha256:2ddac09bbc9efd49220a27242db510596cb2af48293f9d3da7189ea5e24416e4",
      "input_schema": "sha256:5961cee2a6026483736f487477d98b60871da385c1341ad59c93d232d70e9e42",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:bd59c9548e5014d9c6034f0e1ef9582b9da7782ef26b3bf42344c15275320239"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_dream_bridges": {
      "description": "sha256:968b06b00bdfcf53d43da35c478d6293310ff19727b58a3e44d1a8d9180d1376",
      "input_schema": "sha256:48660c643fea8cbbb930dbee07980fe5674fff36a4531765df241d46777a11d1",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:6a29711f8ac8c19a8aa31d401aa933f2c12b7968cd9423e09f36ec9f39ae8bde"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_git_log": {
      "description": "sha256:e7493c68e8eefb170483b2f86bc2035b1f8465a23bd07242bb9e1de2fec514f5",
      "input_schema": "sha256:c6897737bbb82548cae9c30485e24722c1022b6877a0bbcede4cde86a1b74b0a",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:c6333109131abe0ddba23f8a6841a6bfc89d0d887f472a7f5a3cb0b63a1e4990"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_memory_ask": {
      "description": "sha256:8930851a8c7cd59982a48996528795a54e40043a79ed526e3e2af21c2def2d4f",
      "input_schema": "sha256:cacd45599fae73e58bc949f9bc962b7075c5d8b08bd3e618d7fb5632bc91c50e",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:ad69f2b079a8d8fed6e45ba4512bc2d5448ffc136ee8196a67719bfbb61f3743"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_memory_ingest": {
      "description": "sha256:8fd371cc299b2a24b6400c2979718535831b3dee5155c4192b236f7062f627bd",
      "input_schema": "sha256:e32400b941f4ad295d728365f4ca3fa127bb8a4708e04f5190a2d5133a1a3ca6",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:9b95c48ca5d76e9c4c90a4da72f825c421405c670369dd4d965edf057dd62365"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_memory_query": {
      "description": "sha256:defa79f95fa882c91c132c9a25818b4e7d367fe30ff44b76e551b61be2664320",
      "input_schema": "sha256:992c3bbc51f39648ff0b69b6dd658dd106183414750d000fef3978b3cf77bd4a",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:3631cfe31938e62bdf386cf2244596054229a189c7662ecbe5f53bdf73ad3dcd"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_pheme_radar": {
      "description": "sha256:e0b078959de569ca9a464e919cec057ec6d5eae266c81c45a6c98750adee0249",
      "input_schema": "sha256:cd351a8e2e46b20e615c2f036c83d5d5634a160f027657a51e84357a0b47e409",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:5cab67fc629bc1ee0d41eae4b91254743872ee8a442b49d3318816e15e059be8"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_pheme_watch": {
      "description": "sha256:258a663e7c54b1e9bcbfd6cae096bbeb4a1d246c5a2edc8020cda5497a477487",
      "input_schema": "sha256:91a4e561cff93307503857a34a10eb12ac4548199387ac21d0e429db8e3d1048",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:2c35b0ac1ad04c4c6cddbde8c861c69191abfcc3f76a9cc31889f2dbe3d8602b"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_position_get": {
      "description": "sha256:90fbb15af6ffb5e9925c09af7fbb8ab6c72d6996b517727207c0a3bbbdb1f7ef",
      "input_schema": "sha256:305b54f82aceffae59e38aaf12412661817863c7d53c1e5855c309debd989dfb",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:b8e9842d37abf37895cbb1fa55efa3b25fd493ffdc3dfddd41ca6fc91c809783"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_position_update": {
      "description": "sha256:455306a63596c42a489d8a4117e02245a04058bff4737801f24afd820b1b331a",
      "input_schema": "sha256:e5b3b64be127e7bb7e9c2683e5025c346a3502e55eb88cb76b5683aff8c235b7",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:215c4f27f73c4386d610643de7b8c34863caf0cf69ab4f8c4514302ff43771be"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_resonance_list": {
      "description": "sha256:cc25d466d90785835274d3e32b726bf4bc0642d370a8fa6e8817b527ac016caa",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:169fdf1ff9ee397dea5ce1386ddac18cee2e58b40db0e34b07bb83614e768a69"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_spine_assignments": {
      "description": "sha256:294ed83730fcbf8128e61388ec7d0039a419cc7c0cf88363f49b28ff842993f9",
      "input_schema": "sha256:2aca328576fe6e0ee03dd319d70f60ab1610c5e2b6798b3321bc0e1213d5a94b",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:492963cb08042d062463fd05a433ceb1a99bfa30c96744ad4391eece2053759e"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_todo_add": {
      "description": "sha256:1ed95da77982f954908144963eebf7256b8cab440c269007238be95f536c818e",
      "input_schema": "sha256:4bb0fa2f081aaafc9d702034147c75847bb85a94ef2f0a114f250094c4a844ab",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:6af115d3cc05d949474088e8a03b47e7c4a99e9b7733f4aa198b1aa6e823c017"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_todo_categories": {
      "description": "sha256:df8114037e0bc88323dcba699fb57fe25144d441ec7df2bd7b7af0a109b35530",
      "input_schema": "sha256:889e0787cdb1130f06d4443f2ee2ac8f9f8e1a2eba97d3be5a4dc09dcd30f031",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:5ece90b2583fcd2c95d5a692bd6df3778533f13a24f3462227ba06a9579410de"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_todo_list": {
      "description": "sha256:dc08d9f100c741d4ec56d8fce0f6cf497ac7752c273408706ef9471698a1dfe5",
      "input_schema": "sha256:ff9829deea36992fe99ea479bdf6f04549772085bf0e985a415a20118d2085c7",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:f2924754fe1bca983cac28ca3b358990f85718d778bf8cae172b5462777eaf51"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_todo_update": {
      "description": "sha256:e730674f06c3402042ad1419df95e2e8430215b449ab920a31044cc76d418aff",
      "input_schema": "sha256:63b95ab2be2396cba5e402e27d85cb46829740dea967c2dd585415ef0e697959",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:52fc29b5476e0062a8c348f8e9d3ca0357b8f6254b20793cc6adad8a919aab65"
    },
    "mnemosyne-os-mcp:tool:mnemosyne_vault_list": {
      "description": "sha256:016054d2673bd9764339f3f5154795be28dd89656ba28efd34f3837449c88db1",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:c6dbdb904953595ef39b900c62744ff5e029e557d4d54c3104a865e8f7080ab5"
    }
  }
}
