hermes-brain-memory 0.1.0__tar.gz

hermes_brain_memory-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+dist/
+build/
+.venv*/
+__pycache__/
+*.egg-info/
+*.pyc

hermes_brain_memory-0.1.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog — hermes-brain-memory
+
+## 0.1.0 (2026-07-04)
+
+Initial release.
+
+- Vendors the Brain Memory provider for Hermes Agent (provider payload v1.0.0,
+  stdlib only): `brain_recall` / `brain_memorize` / `brain_reinforce` tools,
+  budget-bounded session-start context, background prefetch, pre-compression
+  reminder, session-context logging, MEMORY.md mirroring, `backup_paths()`.
+- `hermes-brain-memory` console script with `install` (idempotent, `--force`),
+  `uninstall`, and `status` subcommands targeting `$HERMES_HOME/plugins/brain`
+  (mechanism mirrors the `hermes-memori` precedent).
+- Verified live end-to-end on Hermes Agent v0.18.0.

hermes_brain_memory-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Omelas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hermes_brain_memory-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: hermes-brain-memory
+Version: 0.1.0
+Summary: Brain Memory provider for Hermes Agent — local-first, cross-agent Markdown memory (~/.brain) shared with Claude Code, Codex, OpenCode, and OpenClaw. No runtime dependencies.
+Project-URL: Homepage, https://brainmemory.ai
+Project-URL: Repository, https://github.com/omelas-tech/brain
+Project-URL: Documentation, https://brainmemory.ai
+Project-URL: Changelog, https://github.com/omelas-tech/brain/blob/main/integrations/hermes/package/CHANGELOG.md
+Author-email: Omelas <onur@omelas.tech>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-memory,brain-memory,hermes,hermes-agent,local-first,memory,memory-provider,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# hermes-brain-memory
+
+**[Brain Memory](https://brainmemory.ai) provider for [Hermes Agent](https://hermes-agent.nousresearch.com)** — one local-first memory shared across all your AI agents. The same human-readable Markdown store in `~/.brain/` is read and written by Claude Code, Codex, OpenCode, and OpenClaw, so Hermes remembers what your other agents learned — and vice versa.
+
+Memories are plain Markdown files with YAML frontmatter (greppable, diffable, editable). They decay over time, strengthen with use (spaced reinforcement), and connect through an associative network with spreading activation. The model decides *what* to remember via explicit tools; the `brain` CLI scores recall deterministically.
+
+**Zero pip dependencies** — this package and the provider it installs are Python stdlib only.
+
+## Install
+
+```bash
+# 1. The brain CLI (once, if you don't already use Brain Memory)
+npm install -g brain-memory
+
+# 2. This package + the provider
+pip install hermes-brain-memory       # or: uv tool install / pipx install hermes-brain-memory
+hermes-brain-memory install           # copies the provider into $HERMES_HOME/plugins/brain
+```
+
+## Activate
+
+```bash
+hermes config set memory.provider brain
+hermes memory setup        # optional guided configuration
+hermes memory status       # verify: "brain" should show as installed & available
+```
+
+Or set it directly in `$HERMES_HOME/config.yaml` (usually `~/.hermes/config.yaml`):
+
+```yaml
+memory:
+  provider: brain
+```
+
+Only one external memory provider can be active at a time; Hermes' built-in MEMORY.md/USER.md memory keeps running alongside.
+
+## What it does
+
+| Lifecycle | Behavior |
+|---|---|
+| Session start | Injects a budget-bounded context block from `brain session-start`: status line, pinned facts, procedural-skills index, relevant memory titles, memorize guidance |
+| Pre-turn | Prefetches relevant memories for the user's message (background thread, non-blocking) |
+| Tools | `brain_recall` (deterministic recall + full bodies + auto-reinforce), `brain_memorize` (validated store), `brain_reinforce` (spaced reinforcement by ID) |
+| Pre-compression | Reminds the model to store un-memorized notable content before context is discarded |
+| Session end | Appends a session entry to `~/.brain/contexts.json` (last 20 kept) |
+| Built-in memory writes | Mirrors MEMORY.md entries into `~/.brain` as content-hash-deduplicated observations |
+| Backup | `~/.brain` is declared via `backup_paths()` so `hermes backup` captures it |
+
+No transcript dumping: `sync_turn` does lightweight in-memory topic tracking only. Nothing leaves the machine unless you enable Brain's own sync (Brain Cloud or a private Git remote).
+
+## Installer commands
+
+```bash
+hermes-brain-memory install [--force]   # copy/update the provider (idempotent; --force overwrites)
+hermes-brain-memory uninstall           # remove it ($HERMES_HOME/plugins/brain only — ~/.brain is untouched)
+hermes-brain-memory status              # install state, brain CLI, active memory.provider
+```
+
+`HERMES_HOME` (or `--hermes-home PATH`) selects the Hermes profile to install into; default `~/.hermes`.
+
+## Configuration
+
+Stored in `$HERMES_HOME/brain.json` (written by `hermes memory setup`); environment variables override.
+
+| Key | Default | Env var | Description |
+|---|---|---|---|
+| `project` | `hermes` | `BRAIN_PROJECT` | Project label for context-dependent recall |
+| `top_recall` | `6` | `BRAIN_TOP_RECALL` | Max memories per recall (1–25) |
+| `auto_reinforce` | `true` | `BRAIN_AUTO_REINFORCE` | Reinforce memories surfaced by `brain_recall` |
+| `brain_bin` | `brain` | `BRAIN_BIN` | Path to the brain CLI |
+| `sync_on_memorize` | `false` | `BRAIN_SYNC_ON_MEMORIZE` | Push each store to Brain Cloud / Git remote |
+
+## Requirements
+
+- [Hermes Agent](https://hermes-agent.nousresearch.com) (a version with pluggable memory providers)
+- The `brain` CLI from the [`brain-memory`](https://www.npmjs.com/package/brain-memory) npm package
+- Python 3.10+ — no pip dependencies
+
+## Docs & source
+
+- Brain Memory: [brainmemory.ai](https://brainmemory.ai)
+- Source & full integration docs: [github.com/omelas-tech/brain](https://github.com/omelas-tech/brain) (`integrations/hermes/`)
+- Hermes memory providers: [hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers](https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers)
+
+## License
+
+MIT © Omelas

hermes_brain_memory-0.1.0/README.md

@@ -0,0 +1,87 @@
+# hermes-brain-memory
+
+**[Brain Memory](https://brainmemory.ai) provider for [Hermes Agent](https://hermes-agent.nousresearch.com)** — one local-first memory shared across all your AI agents. The same human-readable Markdown store in `~/.brain/` is read and written by Claude Code, Codex, OpenCode, and OpenClaw, so Hermes remembers what your other agents learned — and vice versa.
+
+Memories are plain Markdown files with YAML frontmatter (greppable, diffable, editable). They decay over time, strengthen with use (spaced reinforcement), and connect through an associative network with spreading activation. The model decides *what* to remember via explicit tools; the `brain` CLI scores recall deterministically.
+
+**Zero pip dependencies** — this package and the provider it installs are Python stdlib only.
+
+## Install
+
+```bash
+# 1. The brain CLI (once, if you don't already use Brain Memory)
+npm install -g brain-memory
+
+# 2. This package + the provider
+pip install hermes-brain-memory       # or: uv tool install / pipx install hermes-brain-memory
+hermes-brain-memory install           # copies the provider into $HERMES_HOME/plugins/brain
+```
+
+## Activate
+
+```bash
+hermes config set memory.provider brain
+hermes memory setup        # optional guided configuration
+hermes memory status       # verify: "brain" should show as installed & available
+```
+
+Or set it directly in `$HERMES_HOME/config.yaml` (usually `~/.hermes/config.yaml`):
+
+```yaml
+memory:
+  provider: brain
+```
+
+Only one external memory provider can be active at a time; Hermes' built-in MEMORY.md/USER.md memory keeps running alongside.
+
+## What it does
+
+| Lifecycle | Behavior |
+|---|---|
+| Session start | Injects a budget-bounded context block from `brain session-start`: status line, pinned facts, procedural-skills index, relevant memory titles, memorize guidance |
+| Pre-turn | Prefetches relevant memories for the user's message (background thread, non-blocking) |
+| Tools | `brain_recall` (deterministic recall + full bodies + auto-reinforce), `brain_memorize` (validated store), `brain_reinforce` (spaced reinforcement by ID) |
+| Pre-compression | Reminds the model to store un-memorized notable content before context is discarded |
+| Session end | Appends a session entry to `~/.brain/contexts.json` (last 20 kept) |
+| Built-in memory writes | Mirrors MEMORY.md entries into `~/.brain` as content-hash-deduplicated observations |
+| Backup | `~/.brain` is declared via `backup_paths()` so `hermes backup` captures it |
+
+No transcript dumping: `sync_turn` does lightweight in-memory topic tracking only. Nothing leaves the machine unless you enable Brain's own sync (Brain Cloud or a private Git remote).
+
+## Installer commands
+
+```bash
+hermes-brain-memory install [--force]   # copy/update the provider (idempotent; --force overwrites)
+hermes-brain-memory uninstall           # remove it ($HERMES_HOME/plugins/brain only — ~/.brain is untouched)
+hermes-brain-memory status              # install state, brain CLI, active memory.provider
+```
+
+`HERMES_HOME` (or `--hermes-home PATH`) selects the Hermes profile to install into; default `~/.hermes`.
+
+## Configuration
+
+Stored in `$HERMES_HOME/brain.json` (written by `hermes memory setup`); environment variables override.
+
+| Key | Default | Env var | Description |
+|---|---|---|---|
+| `project` | `hermes` | `BRAIN_PROJECT` | Project label for context-dependent recall |
+| `top_recall` | `6` | `BRAIN_TOP_RECALL` | Max memories per recall (1–25) |
+| `auto_reinforce` | `true` | `BRAIN_AUTO_REINFORCE` | Reinforce memories surfaced by `brain_recall` |
+| `brain_bin` | `brain` | `BRAIN_BIN` | Path to the brain CLI |
+| `sync_on_memorize` | `false` | `BRAIN_SYNC_ON_MEMORIZE` | Push each store to Brain Cloud / Git remote |
+
+## Requirements
+
+- [Hermes Agent](https://hermes-agent.nousresearch.com) (a version with pluggable memory providers)
+- The `brain` CLI from the [`brain-memory`](https://www.npmjs.com/package/brain-memory) npm package
+- Python 3.10+ — no pip dependencies
+
+## Docs & source
+
+- Brain Memory: [brainmemory.ai](https://brainmemory.ai)
+- Source & full integration docs: [github.com/omelas-tech/brain](https://github.com/omelas-tech/brain) (`integrations/hermes/`)
+- Hermes memory providers: [hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers](https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers)
+
+## License
+
+MIT © Omelas

hermes_brain_memory-0.1.0/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hermes-brain-memory"
+version = "0.1.0"
+description = "Brain Memory provider for Hermes Agent — local-first, cross-agent Markdown memory (~/.brain) shared with Claude Code, Codex, OpenCode, and OpenClaw. No runtime dependencies."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Omelas", email = "onur@omelas.tech" }]
+requires-python = ">=3.10"
+dependencies = []
+keywords = [
+    "hermes-agent",
+    "hermes",
+    "memory",
+    "memory-provider",
+    "brain-memory",
+    "agent-memory",
+    "local-first",
+    "plugin",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://brainmemory.ai"
+Repository = "https://github.com/omelas-tech/brain"
+Documentation = "https://brainmemory.ai"
+Changelog = "https://github.com/omelas-tech/brain/blob/main/integrations/hermes/package/CHANGELOG.md"
+
+[project.scripts]
+hermes-brain-memory = "hermes_brain_memory.installer:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hermes_brain_memory"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/hermes_brain_memory",
+    "tests",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+exclude = ["**/__pycache__", "**/*.pyc", ".gitignore"]

hermes_brain_memory-0.1.0/src/hermes_brain_memory/__init__.py

@@ -0,0 +1,18 @@
+"""hermes-brain-memory — Brain Memory provider for Hermes Agent.
+
+This package is an *installer + payload*: it vendors the Brain Memory
+provider (a Hermes ``exclusive``/memory plugin, stdlib only) and ships the
+``hermes-brain-memory`` console script that copies it into
+``$HERMES_HOME/plugins/brain/``, where Hermes' user-plugin memory discovery
+picks it up.
+
+The provider itself lives in ``_vendor/brain/`` and is deliberately
+self-contained — Hermes loads it from the plugins directory, never through
+this package's import path.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

hermes_brain_memory-0.1.0/src/hermes_brain_memory/_vendor/brain/README.md

@@ -0,0 +1,51 @@
+# Brain Memory provider for Hermes Agent
+
+Backs Hermes Agent's memory slot with [Brain Memory](https://brainmemory.ai) — a local-first, human-readable Markdown memory store in `~/.brain/`, shared across Hermes, Claude Code, Codex, OpenCode, and OpenClaw. Memories decay, strengthen with use, and connect through an associative network — the model decides *what* to remember; the `brain` CLI handles the plumbing deterministically.
+
+## Requirements
+
+- The `brain` CLI: `npm install -g brain-memory` (then run its installer once so `~/.brain/` exists)
+- Python 3.10+ (no pip dependencies)
+
+## Setup
+
+1. Copy this directory to `$HERMES_HOME/plugins/brain/` (usually `~/.hermes/plugins/brain/`), or use it in-tree at `plugins/memory/brain/`.
+2. Activate it:
+
+```bash
+hermes memory setup        # guided
+```
+
+or in `~/.hermes/config.yaml`:
+
+```yaml
+memory:
+  provider: brain
+```
+
+3. Verify: `hermes memory status`
+
+## What it does
+
+| Lifecycle | Behavior |
+|---|---|
+| Session start | Injects a budget-bounded context block from `brain session-start`: status line, pinned facts, skills index, relevant memory titles, memorize guidance |
+| Pre-turn | Prefetches relevant memories for the user's message (background thread) |
+| Tools | `brain_recall` (recall + auto-reinforce + full bodies), `brain_memorize` (validated store), `brain_reinforce` |
+| Pre-compression | Reminds the model to store un-memorized notable content before context is discarded |
+| Session end | Appends a session entry to `~/.brain/contexts.json` (last 20 kept) |
+| Built-in memory writes | Mirrors MEMORY.md entries into `~/.brain` as deduplicated observations |
+
+## Configuration
+
+Stored in `$HERMES_HOME/brain.json`; environment variables override defaults.
+
+| Key | Default | Env var | Description |
+|---|---|---|---|
+| `project` | `hermes` | `BRAIN_PROJECT` | Project label for context-dependent recall |
+| `top_recall` | `6` | `BRAIN_TOP_RECALL` | Max memories per recall (1–25) |
+| `auto_reinforce` | `true` | `BRAIN_AUTO_REINFORCE` | Reinforce memories surfaced by `brain_recall` |
+| `brain_bin` | `brain` | `BRAIN_BIN` | Path to the brain CLI |
+| `sync_on_memorize` | `false` | `BRAIN_SYNC_ON_MEMORIZE` | Push each store to Brain Cloud / Git remote |
+
+The built-in MEMORY.md/USER.md memory keeps running alongside — this provider supplements it with a long-lived, cross-agent store. See `integrations/hermes/README.md` in the brain-memory repository for hooks-based and MCP-based alternatives.

hermes_brain_memory-0.1.0/src/hermes_brain_memory/_vendor/brain/__init__.py

@@ -0,0 +1,31 @@
+"""Brain Memory provider plugin for Hermes Agent.
+
+Local-first, human-readable Markdown memory (~/.brain) shared across Hermes,
+Claude Code, Gemini CLI, Codex, OpenCode, and OpenClaw. See README.md.
+"""
+
+try:
+    # Normal case: loaded as a package (in-tree plugins/memory/brain or
+    # $HERMES_HOME/plugins/brain when the loader imports the package).
+    from .provider import BrainMemoryProvider
+except ImportError:  # pragma: no cover
+    # Fallback: some loaders exec __init__.py as a standalone module, which
+    # breaks relative imports. Load provider.py from the same directory.
+    import importlib.util as _ilu
+    import os as _os
+
+    _spec = _ilu.spec_from_file_location(
+        "hermes_brain_memory_provider",
+        _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "provider.py"),
+    )
+    _mod = _ilu.module_from_spec(_spec)
+    assert _spec.loader is not None
+    _spec.loader.exec_module(_mod)
+    BrainMemoryProvider = _mod.BrainMemoryProvider
+
+__all__ = ["BrainMemoryProvider", "register"]
+
+
+def register(ctx) -> None:
+    """Register Brain Memory as a memory provider plugin."""
+    ctx.register_memory_provider(BrainMemoryProvider())

hermes_brain_memory-0.1.0/src/hermes_brain_memory/_vendor/brain/cli.py

@@ -0,0 +1,119 @@
+"""Standalone diagnostics CLI for the Brain Memory provider.
+
+Hermes loads user-installed memory providers through its memory-discovery
+path, whose plugin context only accepts ``register_memory_provider`` — it has
+no CLI registration (that API belongs to regular, non-exclusive plugins). So
+these commands run as a plain module instead:
+
+    python3 ~/.hermes/plugins/brain/cli.py status
+    python3 ~/.hermes/plugins/brain/cli.py recall "what did we decide about X"
+
+``register_cli(subparser)`` is kept for a possible future in-tree bundling
+where a real CLI hook exists. Stdlib only; shells out to the ``brain`` CLI
+(brain-memory npm package). In-session, use the provider's ``brain_recall`` /
+``brain_memorize`` tools — the agent calls those itself.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+try:
+    from .provider import BrainMemoryProvider, brain_dir
+except ImportError:  # pragma: no cover — standalone loading
+    import importlib.util as _ilu
+
+    _spec = _ilu.spec_from_file_location(
+        "hermes_brain_memory_provider_cli",
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "provider.py"),
+    )
+    _mod = _ilu.module_from_spec(_spec)
+    assert _spec.loader is not None
+    _spec.loader.exec_module(_mod)
+    BrainMemoryProvider = _mod.BrainMemoryProvider
+    brain_dir = _mod.brain_dir
+
+
+def _brain_bin() -> str:
+    return os.environ.get("BRAIN_BIN", "brain")
+
+
+def _cmd_status(args) -> int:
+    bin_name = _brain_bin()
+    found = shutil.which(bin_name) or (os.path.isfile(os.path.expanduser(bin_name)) and bin_name)
+    store = brain_dir()
+    index = store / "index.json"
+    print(f"brain CLI     : {found or 'NOT FOUND (npm install -g brain-memory)'}")
+    print(f"store         : {store} ({'present' if store.exists() else 'missing'})")
+    print(f"index.json    : {'present' if index.exists() else 'missing'}")
+    if found and index.exists():
+        try:
+            env = dict(os.environ)
+            env["BRAIN_AGENT"] = "hermes"
+            proc = subprocess.run(
+                [bin_name, "session-start", "--project", os.environ.get("BRAIN_PROJECT", "hermes")],
+                capture_output=True,
+                text=True,
+                timeout=15,
+                env=env,
+            )
+            if proc.returncode == 0:
+                payload = json.loads(proc.stdout)
+                print(f"memories      : {payload.get('memory_count', '?')}")
+                print(f"pinned        : {len(payload.get('pinned') or [])}")
+                print(f"skills        : {len(payload.get('skills_index') or [])}")
+        except (OSError, subprocess.TimeoutExpired, ValueError):
+            print("memories      : (could not query)")
+    return 0
+
+
+def _cmd_recall(args) -> int:
+    provider = BrainMemoryProvider()
+    provider.initialize("cli", hermes_home=os.environ.get("HERMES_HOME", ""))
+    print(
+        provider.handle_tool_call(
+            "brain_recall",
+            {"query": " ".join(args.query), "reinforce": False},
+        )
+    )
+    return 0
+
+
+def _dispatch(args) -> int:
+    command = getattr(args, "brain_command", None)
+    if command == "status":
+        return _cmd_status(args)
+    if command == "recall":
+        return _cmd_recall(args)
+    print("usage: hermes memory {status|recall <query>}")
+    return 1
+
+
+def register_cli(subparser) -> None:
+    """Attach brain subcommands to an argparse subparser (in-tree use only —
+    Hermes exposes no CLI hook to user-installed memory providers)."""
+    subs = subparser.add_subparsers(dest="brain_command")
+    subs.add_parser("status", help="Show Brain Memory store status")
+    recall = subs.add_parser("recall", help="Recall memories from ~/.brain")
+    recall.add_argument("query", nargs="+", help="What to recall")
+    subparser.set_defaults(func=_dispatch)
+
+
+def main(argv=None) -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="brain-provider",
+        description="Brain Memory provider diagnostics (standalone)",
+    )
+    register_cli(parser)
+    args = parser.parse_args(argv)
+    return _dispatch(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hermes_brain_memory-0.1.0/src/hermes_brain_memory/_vendor/brain/plugin.yaml

@@ -0,0 +1,7 @@
+name: brain
+version: 1.0.0
+description: "Brain Memory — local-first, human-readable Markdown memory (~/.brain) with decay, spreading activation, and spaced reinforcement, shared across Hermes, Claude Code, Codex, OpenCode, and OpenClaw."
+hooks:
+  - on_session_end
+  - on_pre_compress
+  - on_memory_write