graph-mind-memory 0.2.0__tar.gz → 0.3.0__tar.gz

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.0
+Version: 0.3.0
 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
@@ -166,6 +166,23 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+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
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
@@ -176,9 +193,10 @@ private keys, and passwords inside URLs.
 | `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.0 → graph_mind_memory-0.3.0}/README.md

@@ -140,6 +140,23 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+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
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
@@ -150,9 +167,10 @@ private keys, and passwords inside URLs.
 | `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.0 → graph_mind_memory-0.3.0}/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.0 → graph_mind_memory-0.3.0}/brain_log.py

@@ -36,7 +36,7 @@ import platform
 import re
 import sqlite3
 
-KINDS = ("memory", "turn")
+KINDS = ("memory", "turn", "forget")   # forget: ids another PC erased (forget.py)
 
 
 def device_name() -> str:
@@ -426,6 +426,8 @@ def sync(shared: Path, index: Path) -> dict:
             except ValueError:
                 continue                                  # a corrupt line is skipped, not fatal
         items.sort(key=lambda pair: pair[0].get("written_at", ""))
+        forgets = [item["record"] for item, _ in items if item.get("kind") == "forget"]
+        items = [(item, line) for item, line in items if item.get("kind") != "forget"]
         imported, conflicts, waiting = 0, 0, []
         with LocalBrainStore(index) as brain, ConversationMemoryStore(index) as turns:
             # A supersession can arrive before the memory it replaces when two devices' logs are
@@ -450,6 +452,10 @@ def sync(shared: Path, index: Path) -> dict:
                 if not progress:
                     waiting = [line for _, line in retry]
                     break
+        if forgets:                         # after the imports: a forgotten turn may be in them
+            from forget import erase
+            for record in forgets:
+                erase(index, record)
         with db:
             db.execute("DELETE FROM brain_log_pending")
             db.executemany("INSERT OR IGNORE INTO brain_log_pending VALUES(?)",

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/conversation_memory.py

@@ -238,7 +238,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 +251,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 +333,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 +374,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 +464,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.3.0/forget.py

@@ -0,0 +1,203 @@
+"""Forget everything that contains a phrase: on this PC, in the shared log, and on the other PCs.
+
+    graph-mind-forget                  # asks for the phrase without echoing it (keeps it out of
+                                       # the shell history), shows what matches, asks to confirm
+    graph-mind-forget "hunter2" --yes
+
+A captured turn or memory lives in its store, in that store's word index, and as an engram in the
+associative index; all three go. In the shared log its lines go too: Postgres rows are deleted, a
+folder's lines are blanked in place (same length, so other PCs' read offsets stay valid). Then a
+"forget" record listing the ids, never the phrase, tells every other PC to erase its own copies.
+
+Not covered: the AI app's own transcript (Claude Code keeps ~/.claude/projects/*.jsonl) and the
+embedding vectors, which are numbers keyed by a hash and hold no text.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+import argparse
+import getpass
+import json
+import sqlite3
+import sys
+
+
+def find(index: Path, phrase: str) -> dict:
+    """Ids of the turns and memories whose text contains the phrase (exact, case-sensitive)."""
+    db = sqlite3.connect(index, timeout=30)
+    try:
+        tables = {row[0] for row in db.execute("SELECT name FROM sqlite_master")}
+        turns = [row[0] for row in db.execute(
+            "SELECT turn_id FROM conversation_turns WHERE instr(content_redacted, ?) > 0",
+            (phrase,))] if "conversation_turns" in tables else []
+        memories = [row[0] for row in db.execute(
+            "SELECT memory_id FROM local_brain_memories "
+            "WHERE instr(content, ?) > 0 OR instr(title, ?) > 0",
+            (phrase, phrase))] if "local_brain_memories" in tables else []
+    finally:
+        db.close()
+    return {"turn_ids": turns, "memory_ids": memories}
+
+
+def erase(index: Path, ids: dict) -> dict:
+    """Delete these turns and memories, with every index entry derived from them."""
+    turns, memories = list(ids.get("turn_ids", [])), list(ids.get("memory_ids", []))
+    db = sqlite3.connect(index, timeout=30)
+    try:
+        tables = {row[0] for row in db.execute("SELECT name FROM sqlite_master")}
+        with db:
+            if turns and "conversation_turns" in tables:
+                marks = ",".join("?" * len(turns))
+                rows = db.execute(f"SELECT revision, content_redacted FROM conversation_turns "
+                                  f"WHERE turn_id IN ({marks})", turns).fetchall()
+                # an external-content FTS table keeps its words until told to drop them
+                db.executemany("INSERT INTO conversation_turns_fts(conversation_turns_fts, rowid, "
+                               "content_redacted) VALUES('delete', ?, ?)", rows)
+                db.execute(f"DELETE FROM conversation_turns WHERE turn_id IN ({marks})", turns)
+            if memories and "local_brain_memories" in tables:
+                marks = ",".join("?" * len(memories))
+                db.execute(f"DELETE FROM local_brain_memories WHERE memory_id IN ({marks})",
+                           memories)
+                if "local_brain_memory_profiles" in tables:
+                    db.execute(f"DELETE FROM local_brain_memory_profiles "
+                               f"WHERE memory_id IN ({marks})", memories)
+            sources = turns + memories
+            if sources and "associative_engrams" in tables:
+                marks = ",".join("?" * len(sources))
+                engrams = [row[0] for row in db.execute(
+                    f"SELECT engram_id FROM associative_engrams WHERE source_id IN ({marks})",
+                    sources)]
+                if engrams:
+                    em = ",".join("?" * len(engrams))
+                    for table, column in (("associative_engrams_fts", "engram_id"),
+                                          ("associative_terms", "engram_id"),
+                                          ("associative_edges", "source_engram_id"),
+                                          ("associative_edges", "target_engram_id"),
+                                          ("associative_pending_edges", "source_engram_id"),
+                                          ("associative_pending_edges", "target_engram_id"),
+                                          ("associative_engrams", "engram_id")):
+                        if table in tables:
+                            db.execute(f"DELETE FROM {table} WHERE {column} IN ({em})", engrams)
+    finally:
+        db.close()
+    return {"turns": len(turns), "memories": len(memories)}
+
+
+def _keys(ids: dict) -> list[str]:
+    """How a target's log line spells its id (brain_log writes sorted keys, ": " separators)."""
+    return ([f'"turn_id": {json.dumps(t)}' for t in ids.get("turn_ids", [])]
+            + [f'"memory_id": {json.dumps(m)}' for m in ids.get("memory_ids", [])])
+
+
+def scrub_shared(shared, ids: dict) -> int:
+    """Remove the targets' lines from the shared log. Returns how many lines went."""
+    from brain_log import _pg, is_database
+    keys = _keys(ids)
+    if not keys:
+        return 0
+    if is_database(shared):
+        with _pg(shared) as connection:
+            removed = 0
+            for key in keys:
+                removed += connection.execute(
+                    "DELETE FROM brain_log WHERE strpos(line, %s) > 0", (key,)).rowcount
+            connection.commit()
+        return removed
+    removed = 0
+    for log in (Path(shared) / "log").glob("*.jsonl"):
+        data = log.read_bytes()
+        lines = data.split(b"\n")
+        changed = False
+        for n, line in enumerate(lines):
+            text = line.decode("utf-8", "replace")
+            if any(key in text for key in keys) and '"kind": "forget"' not in text:
+                lines[n] = b" " * len(line)        # same length: readers' offsets stay valid
+                changed, removed = True, removed + 1
+        if changed:
+            with log.open("r+b") as stream:            # in place: the file is never shorter
+                stream.write(b"\n".join(lines))
+    return removed
+
+
+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
+    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 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
+    parser = argparse.ArgumentParser(description="Forget every captured turn and memory "
+                                                 "that contains a phrase, on every PC.")
+    parser.add_argument("phrase", nargs="?", help="omit it to type it without echo")
+    parser.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    args = parser.parse_args(argv)
+    phrase = args.phrase or getpass.getpass("Phrase to forget (not shown): ")
+    if len(phrase.strip()) < 4:
+        sys.exit("Use at least 4 characters, so a short word does not wipe half the memory.")
+    index = default_development_db()
+    ids = find(index, phrase)
+    count = len(ids["turn_ids"]) + len(ids["memory_ids"])
+    if not count:
+        print("Nothing in this PC's memory contains that phrase.")
+        return
+    print(f"{len(ids['turn_ids'])} conversation turns and {len(ids['memory_ids'])} memories "
+          "contain it.")
+    if not args.yes and input("Forget them here and on your other PCs? [y/N] ").lower() != "y":
+        print("Nothing changed.")
+        return
+    shared = folder()
+    result = forget(phrase, index, shared)
+    print(f"Forgotten: {result['turns']} turns, {result['memories']} memories"
+          + (f"; {result['shared_lines_removed']} lines removed from the shared memory, "
+             "other PCs follow on their next sync" if shared else "") + ".")
+    print("Your AI app may still have it in its own history (Claude Code: ~/.claude/projects).")
+
+
+if __name__ == "__main__":
+    main()

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/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.0 → graph_mind_memory-0.3.0}/graph_mind_memory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.0
+Version: 0.3.0
 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
@@ -166,6 +166,23 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+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
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
@@ -176,9 +193,10 @@ private keys, and passwords inside URLs.
 | `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.0 → graph_mind_memory-0.3.0}/graph_mind_memory.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ development_memory.py
 development_paths.py
 embedding_warmup.py
 entity_timeline.py
+forget.py
 graph_mind_mcp_server.py
 install.py
 local_brain.py

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/graph_mind_memory.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 graph-mind = graph_mind_mcp_server:main
 graph-mind-capture = automatic_capture_cli:main
+graph-mind-forget = forget:main
 graph-mind-install = install:main

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/graph_mind_memory.egg-info/top_level.txt

@@ -9,6 +9,7 @@ development_memory
 development_paths
 embedding_warmup
 entity_timeline
+forget
 graph_mind_mcp_server
 install
 local_brain

{graph_mind_memory-0.2.0 → graph_mind_memory-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.2.0"
+version = "0.3.0"
 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"
@@ -39,6 +39,7 @@ Issues = "https://github.com/goyohan0611-png/graph-mind/issues"
 graph-mind = "graph_mind_mcp_server:main"
 graph-mind-install = "install:main"
 graph-mind-capture = "automatic_capture_cli:main"
+graph-mind-forget = "forget:main"
 
 [tool.setuptools]
 # ponytail: flat modules, as in the repository; a graph_mind/ package is the upgrade path.
@@ -54,6 +55,7 @@ py-modules = [
     "development_paths",
     "embedding_warmup",
     "entity_timeline",
+    "forget",
     "graph_mind_mcp_server",
     "install",
     "local_brain",