graph-mind-memory 0.2.1__tar.gz → 0.3.1__tar.gz

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.1
+Version: 0.3.1
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -164,7 +164,15 @@ Then restart your AI apps. The server is also listed in the
 | Claude desktop: chat | what the model saves with `brain_remember` |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
-private keys, and passwords inside URLs.
+private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
+and any long machine-random string even from a service no rule knows (by its randomness: 91% of
+random 20-64 character tokens caught; in 246,750 ordinary chat turns it fired 92 times, nearly
+all on real ids and tokens). Commit ids, hashes and UUIDs are kept, since you recall those on
+purpose.
+
+There is no switch to keep keys: a recalled memory goes to your model's provider with the question,
+so a stored key would leave your PC the first time it is useful. To have Graph-MIND remember a key,
+tell it **where the key is**, not the key: *"my OpenAI key is in 1Password, under Dev"*.
 
 Only what you actually send is captured: the service reads each app's transcript, which is written
 after you press Enter, so a paste you delete before sending never reaches it. A plain password
@@ -174,6 +182,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -189,9 +201,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/README.md

@@ -138,7 +138,15 @@ Then restart your AI apps. The server is also listed in the
 | Claude desktop: chat | what the model saves with `brain_remember` |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
-private keys, and passwords inside URLs.
+private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
+and any long machine-random string even from a service no rule knows (by its randomness: 91% of
+random 20-64 character tokens caught; in 246,750 ordinary chat turns it fired 92 times, nearly
+all on real ids and tokens). Commit ids, hashes and UUIDs are kept, since you recall those on
+purpose.
+
+There is no switch to keep keys: a recalled memory goes to your model's provider with the question,
+so a stored key would leave your PC the first time it is useful. To have Graph-MIND remember a key,
+tell it **where the key is**, not the key: *"my OpenAI key is in 1Password, under Dev"*.
 
 Only what you actually send is captured: the service reads each app's transcript, which is written
 after you press Enter, so a paste you delete before sending never reaches it. A plain password
@@ -148,6 +156,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -163,9 +175,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/automatic_capture.py

@@ -118,24 +118,26 @@ class AutomaticCaptureService:
         if shared:
             from brain_log import append
             publish = lambda turn: append(shared, "turn", turn)     # a folder or a Postgres URL
+        from forget import forget_ids
+        forget = lambda turn_ids: forget_ids({"turn_ids": turn_ids}, self.db_path, shared)
         sources = []
         # A source whose folder does not exist yet (Codex never run on this PC) is skipped, not
         # fatal: it used to stop every source, so a Claude-Code-only user captured nothing.
         if Path(self.config["codex_sessions_root"]).is_dir():
             sources.append(("codex", CodexConversationCapture(
                 self.config["codex_sessions_root"], store, state_path=self.conversation_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.conversation_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.conversation_cursor))
         claude_root = Path(self.config.get("claude_projects_root")
                            or Path.home() / ".claude" / "projects")
         if claude_root.is_dir():
             sources.append(("claude-code", ClaudeCodeConversationCapture(
                 claude_root, store, state_path=self.claude_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.claude_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.claude_cursor))
         cowork = self.config.get("claude_cowork_root") or cowork_root()
         if cowork and Path(cowork).is_dir():
             sources.append(("claude-cowork", ClaudeCoworkConversationCapture(
                 cowork, store, state_path=self.cowork_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.cowork_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.cowork_cursor))
         return sources
 
     def baseline(self):

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/conversation_memory.py

@@ -5,8 +5,10 @@ from development_paths import use_wal
 
 from datetime import datetime
 from pathlib import Path
+import collections
 import hashlib
 import json
+import math
 import os
 import re
 import sqlite3
@@ -30,7 +32,34 @@ SECRET_PATTERNS = (
                 re.DOTALL), "[REDACTED_PRIVATE_KEY]"),
     # a database URL carries its password: postgres://user:PASSWORD@host
     (re.compile(r"(\b[a-z][a-z0-9+.-]*://[^\s:/@]+:)[^\s@/]+(@)"), r"\1[REDACTED]\2"),
+    # a password written after its name: "password: x", "pwd=x", "비밀번호: x", "비번=x"
+    (re.compile(r"(?i)((?<![a-z])(?:password|passwd|pwd)\s*[:=]\s*)\S+"), r"\1[REDACTED]"),
+    (re.compile(r"((?:비밀번호|비번|암호)\s*[:=]\s*)\S+"), r"\1[REDACTED]"),
 )
+# A token no pattern above knows: long, machine-random (mixed case and digits, no word-shaped
+# pieces, high character entropy). Measured: catches 91% of random 20-64 character tokens; in
+# LongMemEval's 246,750 chat turns it fires 92 times, nearly all on real ids and tokens (an
+# OAuth token, Drive file ids, ad click ids); in this repository's code and docs, never.
+# Commit ids, hashes and UUIDs are left alone: those get recalled on purpose.
+RANDOM_CANDIDATE = re.compile(r"(?<![A-Za-z0-9_\-])[A-Za-z0-9_\-]{20,}(?![A-Za-z0-9_\-])")
+UUID = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
+WORD_PIECE = re.compile(r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])")
+
+
+def _looks_random(token):
+    if UUID.fullmatch(token):
+        return False
+    core = re.sub(r"[_\-]", "", token)
+    if len(core) < 18 or re.fullmatch(r"[0-9a-fA-F]+", core):
+        return False
+    if not (any(c.isupper() for c in core) and any(c.islower() for c in core)
+            and sum(c.isdigit() for c in core) >= 2):
+        return False
+    pieces = WORD_PIECE.findall(core)           # code names are words strung together
+    if pieces and sum(map(len, pieces)) / len(pieces) >= 3.0:
+        return False
+    counts = collections.Counter(core)
+    return -sum(n / len(core) * math.log2(n / len(core)) for n in counts.values()) >= 3.7
 AUTOMATIC_BLOCKS = re.compile(
     r"<(?:environment_context|recommended_plugins|in-app-browser-context)\b[^>]*>.*?"
     r"</(?:environment_context|recommended_plugins|in-app-browser-context)>",
@@ -56,7 +85,15 @@ def _redact(value):
     for pattern, replacement in SECRET_PATTERNS:
         cleaned, replacements = pattern.subn(replacement, cleaned)
         count += replacements
-    return cleaned.strip(), count
+    found = [0]
+
+    def unknown_token(match):
+        if not _looks_random(match.group(0)):
+            return match.group(0)
+        found[0] += 1
+        return "[REDACTED_SECRET]"
+    cleaned = RANDOM_CANDIDATE.sub(unknown_token, cleaned)
+    return cleaned.strip(), count + found[0]
 
 
 def _message_text(payload):
@@ -238,7 +275,7 @@ class CodexConversationCapture:
     CLIENT = "codex"
 
     def __init__(self, sessions_root, store, *, state_path, workspace_scopes=None,
-                 now=None, publish=None):
+                 now=None, publish=None, forget=None):
         self.sessions_root = Path(sessions_root).resolve()
         if not self.sessions_root.is_dir():
             raise ValueError("CODEX_SESSIONS_ROOT_NOT_FOUND")
@@ -251,6 +288,46 @@ class CodexConversationCapture:
                                  for key, value in (workspace_scopes or {}).items()}
         self.now = now or (lambda: datetime.now().isoformat(timespec="microseconds"))
         self.publish = publish            # called with each turn that is new to this store
+        # erases captured turns everywhere (forget.forget_ids with the shared log); by default
+        # this store only
+        self.forget = forget or (lambda turn_ids: __import__("forget").erase(
+            self.store.path, {"turn_ids": turn_ids}))
+
+    FORGET_TOOL = "brain_forget"
+    FORGET_WINDOW_MINUTES = 30
+
+    def _forget_call(self, item):
+        """Whether this record is the assistant calling brain_forget. Codex: a function call
+        named for it, or (code mode) a completed MCP tool call of it."""
+        payload = item.get("payload") or {}
+        if payload.get("type") in {"function_call", "custom_tool_call"}:
+            return str(payload.get("name", "")).endswith(self.FORGET_TOOL)
+        call = payload.get("item") if isinstance(payload.get("item"), dict) else {}
+        return call.get("type") == "McpToolCall" and call.get("tool") == self.FORGET_TOOL
+
+    def _forget_exchange(self, session_id, at, sessions):
+        """The assistant called brain_forget: what led up to it is a conversation about deleting,
+        so it goes too. From the user turn that asked (or from the previous forget call, when this
+        is the second, deleting call of the same exchange) up to now; the assistant's reply that
+        follows is skipped until the user speaks again."""
+        at = self.store._time(at)
+        previous = sessions.get(session_id, {}).get("signal_at")
+        db = self.store.db
+        if previous and (datetime.fromisoformat(at) - datetime.fromisoformat(previous)
+                         ).total_seconds() <= self.FORGET_WINDOW_MINUTES * 60:
+            since = previous
+        else:
+            since = db.execute(
+                "SELECT max(happened_at) FROM conversation_turns WHERE client=? AND "
+                "client_session_id=? AND role='user' AND happened_at<=?",
+                (self.CLIENT, session_id, at)).fetchone()[0]
+        if since:
+            ids = [row[0] for row in db.execute(
+                "SELECT turn_id FROM conversation_turns WHERE client=? AND client_session_id=? "
+                "AND happened_at>=?", (self.CLIENT, session_id, since))]
+            if ids:
+                self.forget(ids)
+        sessions[session_id] = {"signal_at": at, "quiet": True}
 
     def _files(self):
         return sorted(self.sessions_root.rglob("*.jsonl"))
@@ -293,11 +370,13 @@ class CodexConversationCapture:
         value = json.loads(self.state_path.read_text(encoding="utf-8"))
         if value.get("capture_version") != CAPTURE_VERSION:
             raise ValueError("CONVERSATION_CAPTURE_VERSION_MISMATCH")
+        self._forget_sessions = value.get("forget_sessions", {})
         return value.get("offsets", {})
 
     def _write_state(self, offsets):
         value = {"capture_version": CAPTURE_VERSION,
-                 "sessions_root": str(self.sessions_root), "offsets": offsets}
+                 "sessions_root": str(self.sessions_root), "offsets": offsets,
+                 "forget_sessions": getattr(self, "_forget_sessions", {})}
         temporary = self.state_path.with_suffix(".tmp")
         temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n",
                              encoding="utf-8")
@@ -332,12 +411,21 @@ class CodexConversationCapture:
                         item = json.loads(line.decode("utf-8", "strict"))
                     except (UnicodeDecodeError, json.JSONDecodeError):
                         continue
+                    if self._forget_call(item):
+                        self._forget_exchange(session_id, item.get("timestamp") or known_at,
+                                              self._forget_sessions)
+                        continue
                     message = self._message(item)
                     if message is None:
                         continue
                     role, raw = message
                     if not raw.strip():
                         continue
+                    quiet = self._forget_sessions.get(session_id)
+                    if quiet and quiet.get("quiet"):
+                        if role == "assistant":
+                            continue           # the reply to a forget call: not remembered
+                        quiet["quiet"] = False  # the user spoke again: the exchange is over
                     cleaned, count = _redact(raw)
                     if not cleaned:
                         continue
@@ -413,6 +501,15 @@ class ClaudeCodeConversationCapture(CodexConversationCapture):
         resolved_cwd = str(Path(cwd).resolve()) if isinstance(cwd, str) and cwd else None
         return session_id, cwd, self.workspace_scopes.get(resolved_cwd, "global")
 
+    def _forget_call(self, item):
+        """An assistant record with a tool_use block calling brain_forget (any MCP prefix)."""
+        if item.get("type") != "assistant" or item.get("isSidechain"):
+            return False
+        content = (item.get("message") or {}).get("content")
+        return isinstance(content, list) and any(
+            isinstance(block, dict) and block.get("type") == "tool_use"
+            and str(block.get("name", "")).endswith(self.FORGET_TOOL) for block in content)
+
     def _message(self, item):
         if item.get("isSidechain") or item.get("isMeta"):
             return None

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/forget.py

@@ -119,19 +119,56 @@ def scrub_shared(shared, ids: dict) -> int:
     return removed
 
 
-def forget(phrase: str, index: Path, shared=None) -> dict:
-    """Find, erase here, scrub the shared log, and tell the other PCs."""
+def forget_ids(ids: dict, index: Path, shared=None) -> dict:
+    """Erase these turns and memories here, scrub the shared log, and tell the other PCs."""
     from brain_log import append
-    ids = find(index, phrase)
-    if not (ids["turn_ids"] or ids["memory_ids"]):
+    if not (ids.get("turn_ids") or ids.get("memory_ids")):
         return {"turns": 0, "memories": 0, "shared_lines_removed": 0}
+    ids = {"turn_ids": list(ids.get("turn_ids", [])),
+           "memory_ids": list(ids.get("memory_ids", []))}
     result = erase(index, ids)
     if shared:
         result["shared_lines_removed"] = scrub_shared(shared, ids)
-        append(shared, "forget", ids)                  # ids only: the phrase never leaves here
+        append(shared, "forget", ids)                  # ids only: the text never leaves here
     return result
 
 
+def forget(phrase: str, index: Path, shared=None) -> dict:
+    """Find everything containing the phrase, then forget it as forget_ids does."""
+    return forget_ids(find(index, phrase), index, shared)
+
+
+SECRET_HINTS = ("password", "passwd", "pw", "pin", "비밀번호", "비번", "암호", "key", "token",
+                "secret", "api")
+LINKS = {"is", "was", "=", ":", "->", "는", "은", "이", "가"}
+
+
+def masked_preview(text: str, width: int = 90) -> str:
+    """Enough of a turn to recognise it, with what could be a secret replaced by ****: the word
+    after "password"/"비번"/"key"..., anything after "password:" or "key=", and any word that
+    mixes letters with digits or symbols. Over-masks on purpose; the original is never shown, so
+    listing candidates does not put a secret back into the chat it is being removed from."""
+    out, hide_next = [], False
+    for token in str(text).split():
+        lowered = token.lower()
+        bare = token.strip(".,!?\"'()[]{}")
+        hint = any(word in lowered for word in SECRET_HINTS)
+        if hint and (":" in token or "=" in token):
+            separator = ":" if ":" in token else "="
+            out.append(token.split(separator, 1)[0] + separator + "****")
+            hide_next = not token.split(separator, 1)[1]
+            continue
+        if hide_next and lowered in LINKS:          # "password is ...", "비번은 = ..."
+            out.append(token)
+            continue
+        secretish = hide_next or (any(c.isdigit() for c in bare) and any(c.isalpha() for c in bare)) \
+            or any(c in "!@#$%^&*_=+<>|~`\\" for c in bare)
+        out.append("****" if secretish else token)
+        hide_next = hint
+    preview = " ".join(out)
+    return preview if len(preview) <= width else preview[:width] + "…"
+
+
 def main(argv=None):
     from brain_log import folder
     from development_paths import default_development_db

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/graph_mind_mcp_server.py

@@ -342,7 +342,9 @@ def build_server(db_path=None):
             "replaying full history. Use brain_recall to look memories up directly, or with "
             "`entity` for the history of one thing in order. For code changed in a time range, "
             "project, file or symbol, use code_activity. brain_folder shows or changes where the "
-            "memory lives and shares it with the user's other PCs. Preserve provenance."
+            "memory lives and shares it with the user's other PCs. When the user asks to "
+            "delete something from memory, use brain_forget: list first, delete only what the "
+            "user picks. Preserve provenance."
         ),
         version=SERVER_VERSION,
     )
@@ -605,6 +607,67 @@ def build_server(db_path=None):
                 "existing_memories_shared": exported or "not shared; ask the user before "
                                                        "setting share_existing=true"}
 
+    @server.tool(
+        name="brain_forget",
+        structured_output=True,
+        annotations=types.ToolAnnotations(
+            readOnlyHint=False,
+            destructiveHint=True,
+            idempotentHint=True,
+            openWorldHint=False,
+        ),
+    )
+    def brain_forget(query: str | None = None, ids: list[str] | None = None) -> dict[str, Any]:
+        """Delete what the user wants gone from memory: "delete the password I typed earlier",
+        "그 토큰 지워줘", "forget what I said about my ex".
+
+        Always two calls. First `query`: what to look for, in general words ("password", "wifi",
+        "DB login"); never repeat a secret the user typed. It returns numbered candidates with
+        masked previews. Show the user exactly those previews and ask which to delete; never
+        quote the original text. Then call again with the `ids` the user picked, and only those.
+
+        Deleting removes them from this PC, its search indexes, the shared memory and the user's
+        other PCs. This exchange about deleting is not saved either. The AI app's own chat
+        history is separate and untouched (Claude Code keeps ~/.claude/projects).
+        """
+        import sqlite3
+
+        from forget import forget_ids, masked_preview
+        if ids:
+            db = sqlite3.connect(database, timeout=30)
+            try:
+                turns = [row[0] for row in db.execute(
+                    "SELECT turn_id FROM conversation_turns WHERE turn_id IN ("
+                    + ",".join("?" * len(ids)) + ")", ids)]
+                memories = [row[0] for row in db.execute(
+                    "SELECT memory_id FROM local_brain_memories WHERE memory_id IN ("
+                    + ",".join("?" * len(ids)) + ")", ids)]
+            except sqlite3.OperationalError:
+                turns, memories = [], []
+            finally:
+                db.close()
+            from brain_log import folder
+            try:
+                shared = folder()
+            except Exception:
+                shared = None
+            result = forget_ids({"turn_ids": turns, "memory_ids": memories}, database, shared)
+            return {"status": "FORGOTTEN", **result,
+                    "not_found": [i for i in ids if i not in turns and i not in memories]}
+        if not query:
+            return {"status": "QUERY_OR_IDS_REQUIRED", "candidates": []}
+        recalled = gather(database, query, as_of=_now(), limit=10)
+        candidates = [{"id": m["memory_id"], "kind": "memory", "when": m.get("effective_at"),
+                       "preview": masked_preview(m.get("content", ""))}
+                      for m in recalled.get("matches", [])]
+        candidates += [{"id": t["turn_id"], "kind": f"{t.get('role')} turn in {t.get('client')}",
+                        "when": t.get("happened_at"),
+                        "preview": masked_preview(t.get("content", ""))}
+                       for t in recalled.get("conversation_turns", [])]
+        return {"status": "CANDIDATES", "candidates": candidates,
+                "next": "Show these numbered with their masked previews exactly as given, ask "
+                        "which to delete, then call brain_forget with those ids."}
+
     @server.tool(
         name="code_activity",
         structured_output=True,

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/graph_mind_memory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.1
+Version: 0.3.1
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -164,7 +164,15 @@ Then restart your AI apps. The server is also listed in the
 | Claude desktop: chat | what the model saves with `brain_remember` |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
-private keys, and passwords inside URLs.
+private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
+and any long machine-random string even from a service no rule knows (by its randomness: 91% of
+random 20-64 character tokens caught; in 246,750 ordinary chat turns it fired 92 times, nearly
+all on real ids and tokens). Commit ids, hashes and UUIDs are kept, since you recall those on
+purpose.
+
+There is no switch to keep keys: a recalled memory goes to your model's provider with the question,
+so a stored key would leave your PC the first time it is useful. To have Graph-MIND remember a key,
+tell it **where the key is**, not the key: *"my OpenAI key is in 1Password, under Dev"*.
 
 Only what you actually send is captured: the service reads each app's transcript, which is written
 after you press Enter, so a paste you delete before sending never reaches it. A plain password
@@ -174,6 +182,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -189,9 +201,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.2.1"
+version = "0.3.1"
 description = "Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time."
 readme = "README.md"
 requires-python = ">=3.10"