mcp: factor empty-filter normalization into _normalize_optional_filter helper

Follow-up to eb27e00 (port of upstream PR MemPalace#1097). The original port only
fixed tool_search; tool_list_rooms and tool_find_tunnels still treated
whitespace-only filters as truthy, which let an LLM-supplied wing="   "
turn into a literal `WHERE wing = '   '` SQL filter that returned zero
rows.

Extracts the strip-and-empty-as-None logic into _normalize_optional_filter
and routes every LLM-callable tool with optional filter args through it:

  tool_search(wing, room)          — replaced inline normalization
  tool_list_rooms(wing)            — was the latent bug
  tool_find_tunnels(wing_a, wing_b) — was the latent bug
  tool_diary_write(wing)           — replaced inline normalization
  tool_diary_read(wing)            — replaced inline normalization

The helper also strips leading/trailing whitespace on real values, so
wing="  wing_code  " is now treated as wing="wing_code" instead of
silently matching nothing.

Six tests added: helper itself (3 cases), tool_list_rooms with empty +
real wing (2 cases), tool_find_tunnels with empty + real wings (1 case).

Found during second-order analysis of the 2026-04-25 upstream sync —
caught before any LLM agent hit the latent bug in the wild.

Author: Samuel LEGROS

mempalace/mcp_server.py

@@ -69,6 +69,20 @@ def _no_palace():
     }
 
 
+def _normalize_optional_filter(value):
+    """Treat empty/whitespace-only strings as no filter.
+
+    LLM agents tend to fill every optional parameter with "" rather than
+    omitting it. Without normalization a wing/room filter of "   " is
+    truthy and reaches the DB layer as a literal filter, scoping results
+    to a non-existent empty string and returning zero rows. Returns the
+    stripped value when it has content, ``None`` otherwise.
+    """
+    if isinstance(value, str) and not value.strip():
+        return None
+    return value.strip() if isinstance(value, str) else value
+
+
 # ==================== READ TOOLS ====================
 
 
@@ -131,6 +145,7 @@ def tool_list_wings():
 
 
 def tool_list_rooms(wing: str = None):
+    wing = _normalize_optional_filter(wing)
     db = _get_db()
     cur = db.conn().cursor()
     if wing:
@@ -159,13 +174,8 @@ def tool_get_taxonomy():
 
 
 def tool_search(query: str, limit: int = 5, wing: str = None, room: str = None):
-    # LLM agents tend to fill every optional parameter with "" rather than
-    # omitting it. Treat empty/whitespace-only wing/room as no filter so the
-    # search isn't silently scoped to a non-existent empty wing/room.
-    if isinstance(wing, str) and not wing.strip():
-        wing = None
-    if isinstance(room, str) and not room.strip():
-        room = None
+    wing = _normalize_optional_filter(wing)
+    room = _normalize_optional_filter(room)
     return search_memories(
         query,
         palace_path=_config.palace_path,
@@ -221,7 +231,7 @@ def tool_traverse_graph(start_room: str, max_hops: int = 2):
 
 def tool_find_tunnels(wing_a: str = None, wing_b: str = None):
     """Find rooms that bridge two wings — the hallways connecting domains."""
-    return find_tunnels(wing_a, wing_b)
+    return find_tunnels(_normalize_optional_filter(wing_a), _normalize_optional_filter(wing_b))
 
 
 def tool_graph_stats():
@@ -329,9 +339,8 @@ def tool_diary_write(agent_name: str, entry: str, topic: str = "general", wing:
     agent's default ``wing_<agent_name>`` wing — used by hooks to scope
     entries to the project the session belongs to.
     """
-    if isinstance(wing, str) and wing.strip():
-        wing = wing.strip()
-    else:
+    wing = _normalize_optional_filter(wing)
+    if not wing:
         wing = f"wing_{agent_name.lower().replace(' ', '_')}"
     db = _get_db()
 
@@ -380,12 +389,10 @@ def tool_diary_read(agent_name: str, last_n: int = 10, wing: str = ""):
     PR #659 review).
     """
     db = _get_db()
-    use_wing_filter = isinstance(wing, str) and wing.strip()
-    if use_wing_filter:
-        wing = wing.strip()
+    wing = _normalize_optional_filter(wing)
 
     try:
-        if use_wing_filter:
+        if wing:
             where = {
                 "$and": [
                     {"wing": wing},

tests/test_mcp_server.py

@@ -138,6 +138,31 @@ def fake_handler(**kwargs):
     assert calls == [{}]
 
 
+# ── _normalize_optional_filter: empty/whitespace = no filter (upstream #1097
+#    pattern, factored out across every LLM-callable tool)
+
+
+def test_normalize_optional_filter_returns_none_for_empty_strings():
+    from mempalace.mcp_server import _normalize_optional_filter
+
+    assert _normalize_optional_filter("") is None
+    assert _normalize_optional_filter("   ") is None
+    assert _normalize_optional_filter("\t\n") is None
+
+
+def test_normalize_optional_filter_strips_then_returns_value():
+    from mempalace.mcp_server import _normalize_optional_filter
+
+    assert _normalize_optional_filter("wing_code") == "wing_code"
+    assert _normalize_optional_filter("  wing_code  ") == "wing_code"
+
+
+def test_normalize_optional_filter_passes_none_through():
+    from mempalace.mcp_server import _normalize_optional_filter
+
+    assert _normalize_optional_filter(None) is None
+
+
 # ── tool_search: empty/whitespace wing/room treated as no filter (upstream #1097)
 
 
@@ -240,6 +265,82 @@ def test_diary_read_whitespace_wing_spans_all_wings_for_agent(monkeypatch):
     assert all("wing" not in c for c in conds)
 
 
+# ── tool_list_rooms / tool_find_tunnels: same empty-filter normalization
+
+
+def test_tool_list_rooms_empty_wing_lists_all_rooms(monkeypatch):
+    """tool_list_rooms with wing="   " must hit the unfiltered branch
+    (counts rooms across all wings) instead of running
+    `WHERE wing = '   '` and returning nothing."""
+    captured = {"sql": None, "params": None}
+
+    class _FakeCursor:
+        def execute(self, sql, params=None):
+            captured["sql"] = sql
+            captured["params"] = params
+
+        def fetchall(self):
+            return []
+
+    class _FakeConn:
+        def cursor(self):
+            return _FakeCursor()
+
+    class _FakeDB:
+        def conn(self):
+            return _FakeConn()
+
+    monkeypatch.setattr(mcp_server, "_get_db", lambda: _FakeDB())
+
+    result = mcp_server.tool_list_rooms(wing="   ")
+    assert result["wing"] == "all"
+    assert "WHERE wing" not in captured["sql"]
+    assert captured["params"] is None
+
+
+def test_tool_list_rooms_with_real_wing_filters(monkeypatch):
+    captured = {"sql": None, "params": None}
+
+    class _FakeCursor:
+        def execute(self, sql, params=None):
+            captured["sql"] = sql
+            captured["params"] = params
+
+        def fetchall(self):
+            return []
+
+    class _FakeConn:
+        def cursor(self):
+            return _FakeCursor()
+
+    class _FakeDB:
+        def conn(self):
+            return _FakeConn()
+
+    monkeypatch.setattr(mcp_server, "_get_db", lambda: _FakeDB())
+
+    result = mcp_server.tool_list_rooms(wing="  wing_code  ")
+    assert result["wing"] == "wing_code"  # stripped
+    assert "WHERE wing" in captured["sql"]
+    assert captured["params"] == ("wing_code",)
+
+
+def test_tool_find_tunnels_normalizes_both_wings(monkeypatch):
+    captured = {"args": None}
+
+    def fake_find_tunnels(a, b):
+        captured["args"] = (a, b)
+        return {"tunnels": []}
+
+    monkeypatch.setattr(mcp_server, "find_tunnels", fake_find_tunnels)
+
+    mcp_server.tool_find_tunnels(wing_a="", wing_b="   ")
+    assert captured["args"] == (None, None)
+
+    mcp_server.tool_find_tunnels(wing_a=" wing_code ", wing_b="wing_user")
+    assert captured["args"] == ("wing_code", "wing_user")
+
+
 def test_tools_call_unknown_tool_returns_error():
     """Unknown tool name yields a JSON-RPC error, not a crash."""
     request = {