fix(cli): also detect bm/bm.exe entrypoints in mcp pre-flight scan

Codex P1 on #776: the previous matcher required the literal string
'basic-memory' somewhere in argv, so a process started via the
supported `bm mcp` alias entrypoint slipped through and the reset
proceeded against a live MCP — the exact bug the pre-flight is
supposed to block.

Extract the matching to _is_basic_memory_mcp() and recognize:
- basic-memory / basic_memory tokens (any position)
- bm script invocations across path conventions (`bm`, `/usr/local/bin/bm`,
  `bm.exe`, `~/.venv/Scripts/bm.exe`) using both PurePosixPath and
  PureWindowsPath so cross-OS test fixtures work regardless of the
  host platform.

Test now covers both the alias forms and the negative cases (`mcp`
appearing as a substring or in an unrelated server's argv).

Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/cli/commands/db.py

@@ -2,7 +2,7 @@
 
 import os
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath, PureWindowsPath
 
 import psutil
 import typer
@@ -23,6 +23,36 @@
 console = Console()
 
 
+def _is_basic_memory_mcp(cmdline: list[str]) -> bool:
+    """Heuristic: does this argv represent a `basic-memory mcp` server?
+
+    The MCP server can be launched any of:
+      basic-memory mcp
+      bm mcp                                  # entrypoint alias from pyproject.toml
+      python -m basic_memory.cli.main mcp     # module form
+      uv run basic-memory mcp / uv run bm mcp # uv wrappers
+      /abs/path/to/{bm,basic-memory}[.exe] mcp
+
+    A reliable match needs both signals:
+      1. "mcp" appears as an exact argv token (not "mcp-foo").
+      2. Some argv token names the basic-memory entrypoint — either by
+         hyphen/underscore form, or as a `bm` script (covers `/usr/local/bin/bm`,
+         `bm.exe`, etc. via Path.stem).
+    """
+    if "mcp" not in cmdline:
+        return False
+    for arg in cmdline:
+        if "basic-memory" in arg or "basic_memory" in arg:
+            return True
+        # Try both POSIX and Windows path interpretations so a test on
+        # macOS still recognizes `C:\\...\\bm.exe`, and a real Windows
+        # run still recognizes `/usr/local/bin/bm`. Path() alone uses
+        # the host OS, which gives wrong stems for foreign separators.
+        if PurePosixPath(arg).stem == "bm" or PureWindowsPath(arg).stem == "bm":
+            return True
+    return False
+
+
 def _find_live_mcp_processes() -> list[tuple[int, str]]:
     """Return (pid, joined_cmdline) for live `basic-memory mcp` processes.
 
@@ -51,11 +81,8 @@ def _find_live_mcp_processes() -> list[tuple[int, str]]:
             cmdline = proc.info.get("cmdline") or []
             if not cmdline:
                 continue
-            # Match the full `basic-memory mcp` invocation, not just any
-            # process whose argv mentions either word individually.
-            joined = " ".join(cmdline)
-            if "basic-memory" in joined and "mcp" in cmdline:
-                matches.append((pid, joined))
+            if _is_basic_memory_mcp(cmdline):
+                matches.append((pid, " ".join(cmdline)))
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             continue
     return matches

tests/cli/test_db_reset_zombie_check.py

@@ -46,19 +46,28 @@ def test_matches_basic_memory_mcp_invocations(self, monkeypatch):
         _patch_iter(
             monkeypatch,
             [
+                # Direct `basic-memory mcp`.
                 _FakeProc(pid=101, cmdline=["/usr/bin/python", "basic-memory", "mcp"]),
-                _FakeProc(pid=202, cmdline=["bm", "mcp"]),  # alt entrypoint, no match
+                # `bm mcp` alias entrypoint — must also match (#765 P1).
+                _FakeProc(pid=202, cmdline=["bm", "mcp"]),
+                # Python module form, underscore name.
                 _FakeProc(
                     pid=303,
-                    cmdline=["python", "-m", "basic_memory.cli.main", "basic-memory", "mcp"],
+                    cmdline=["python", "-m", "basic_memory.cli.main", "mcp"],
                 ),
+                # Absolute path to the bm script.
+                _FakeProc(pid=404, cmdline=["/usr/local/bin/bm", "mcp"]),
+                # Windows-style bm.exe.
+                _FakeProc(pid=505, cmdline=["C:\\Users\\me\\.venv\\Scripts\\bm.exe", "mcp"]),
+                # Should NOT match — `mcp` is a substring of another arg, not a token.
+                _FakeProc(pid=606, cmdline=["python", "basic-memory", "mcp-helper"]),
+                # Should NOT match — has `mcp` but no basic-memory/bm signature.
+                _FakeProc(pid=707, cmdline=["python", "/some/other/server.py", "mcp"]),
             ],
         )
         result = db_cmd._find_live_mcp_processes()
-        # 101 and 303 match (cmdline contains both "basic-memory" and exact "mcp" arg).
-        # 202 is intentionally excluded because the joined cmdline has no "basic-memory".
         pids = sorted(pid for pid, _ in result)
-        assert pids == [101, 303]
+        assert pids == [101, 202, 303, 404, 505]
 
     def test_skips_current_process(self, monkeypatch):
         me = os.getpid()