MAMP

Mark AI Memory Protocol — persistent, searchable session memory for AI agents. SQLite-only, zero external dependencies.

Security Scan

The skill claims 'SQLite-only, local cwd' behavior, but included code (v1.2.1) implements platform-aware paths and platform detection that can change the default DB location to system directories and may persist platform info — these contradictions are concerning and warrant review before installing.

Purpose & Capability

The declared purpose (local, SQLite-only, DB in current working directory) conflicts with code in ai_memory_protocol_v1.2.1.py that implements platform detection and a platform-aware default DB path (/opt/claw/hermes/protocol/mark_memory.db or /vol2/1000/claw/hermes/protocol/mark_memory.db). The CHANGELOG and SKILL.md also contradict each other about platform_info persistence. Requesting no credentials is consistent, but the file-path behavior is disproportionate to the 'cwd-only' claim.

Instruction Scope

SKILL.md instructions themselves are scoped to local SQLite usage and provide an env var override (MARK_MEMORY_DB) and explicit db_path parameter. However, the codebase exposes auto_record (which wraps agent message-sending methods) and heartbeat hooks for cron, allowing passive capture of messages and automated flushes — this is within memory-skill scope but increases the breadth of data captured. More importantly, instructions claim no platform info persistence while the v1.2.1 code contains platform detection and a get_platform_info function; it's unclear whether platform info is stored in the DB in this release.

Install Mechanism

No install spec or external downloads — this is an instruction-only skill with bundled Python files. No remote code fetches are present, so install risk from network downloads is low. Code is executed locally via dynamic import as described in SKILL.md.

Credentials

No credentials are requested (OK). But the platform-aware code can change the DB default to system locations outside the working directory, which is more privileged than advertised and may require write access to /opt or /vol2 paths. The module also collects local host information (hostname, python_executable, container heuristics) at import time — harmless by itself, but if persisted contradicts the stated 'no platform_info persistence' and raises privacy concerns.

Persistence & Privilege

The skill does not request always:true and allows agent invocation. It writes a persistent SQLite DB (expected). The auto_record feature that hooks message-sending methods can capture data passively; this increases its blast radius but is within the stated functionality for a memory service. Combined with the platform-aware default path, persistent writes may land in system directories unless MARK_MEMORY_DB or explicit db_path is set.

What to consider before installing

This package is not clearly coherent with its public description. Before installing or enabling it for an agent: (1) Inspect the full ai_memory_protocol_v1.2.1.py for places where platform_info is written to the DB or where DEFAULT_DB_PATH points to /opt or /vol2; the code does detect hostname and container status at import time. (2) If you want strictly local cwd storage, set MARK_MEMORY_DB or pass db_path explicitly to ./mark_memory.db and verify the SessionManager uses that value. (3) Consider disabling auto_record by default and only calling add_turn() explicitly, so the agent doesn't passively capture all outbound messages. (4) Run the module in a sandboxed account or VM first to confirm it only creates the files and writes you expect. (5) Ask the maintainer to clarify the contradiction between SKILL.md/CHANGELOG (cwd-only) and v1.2.1 (platform-aware paths and possible platform_info persistence). If you cannot verify these points, treat the skill as untrusted.

MAMP — Mark AI Memory Protocol

Gives AI agents persistent, searchable memory using SQLite.

When to Use

• User says "remember what I told you last time"
• Agent needs to recall facts across conversations
• User asks about past topics, preferences, or decisions
• Context window is filling up and older info needs to be summarized

Core Concepts

• Session — a conversation, has an ID, survives restarts
• Turn — one message in a session (role: user/assistant)
• Tag — labels for a turn, e.g. ["finance", "important"]
• Priority — importance level: critical, normal, trivial

Key Methods

from importlib.util import spec_from_file_location, module_from_spec
spec = spec_from_file_location("mamp", "ai_memory_protocol_v1.2.0.py")
mod = module_from_spec(spec)
spec.loader.exec_module(mod)

# Manual mode — explicit add_turn() calls
sm = mod.SessionManager()
sm.start_conversation()
sm.add_turn("user", "I prefer dark mode")
sm.add_turn("assistant", "Noted")

# Auto mode (v1.1.8+) — auto-captures turns without manual add_turn()
sm = mod.SessionManager(auto_record=True)
sm.start_conversation()
# ... conversations are recorded automatically ...
sm.stop()  # flushes buffer and disables auto_record

# Heartbeat (v1.1.9+) — called externally every ~5 min via Hermes cron
# sm.heartbeat()  # flushes buffer + closes idle sessions (>30 min)

# Explicit db_path (recommended)
sm = mod.SessionManager(db_path="./memory.db", auto_record=True)

# Environment variable override:
# export MARK_MEMORY_DB=/path/to/memory.db

What It Solves

AI forgets everything each conversation. MAMP makes memory persistent, searchable, and structured — without any external service, API key, or dependency beyond SQLite.

Security Notes

Default behavior — local directory only:

• DB file written to ./mark_memory.db in the current working directory
• No system directories are touched
• No log files, audit files, or hidden state files are written
• No network access, no external services

Pass an explicit path to isolate data:

sm = mod.SessionManager(db_path="/your/specific/path/memory.db")

Environment variable override:

export MARK_MEMORY_DB=/your/specific/path/memory.db

This takes precedence over both the default and any db_path argument.

Permissions awareness:

• The DB file contains your conversation history in plaintext
• Ensure the directory has appropriate access controls
• If multiple agents run on the same host with the same path, they share memory — use different paths per agent to isolate

No credentials stored:

MAMP uses no API keys, tokens, or secrets. It is a pure local SQLite store.