feat(search): the agent's search can ask for every kind the corpus has (#4250)

The engine took `note_type` and `task_kind` all along. What was missing was a
way to say them: the MCP tool's `content_type` knew `note`, `task` and `all`,
and `/api/search` knew the same two — so an agent could not ask "has this
snippet already been recorded" or "what lessons apply here" without searching
everything and reading past the rest. Browse offered nine kinds from the same
data.

The cause is that each door kept its own map. `_FACETS` in services/knowledge
is where a kind is declared, and #3161 made adding one a single edit by
generating the SQL filter, the Python predicate and the door's validation from
it — but the two search doors were written before that and never joined. So
this adds the third dialect, `search_filters_for`, and one composition over it,
`content_type_filters`, and both doors now derive instead of listing.

Two names keep a meaning of their own, and the docstrings say so: `all` is no
filter, and `note` is BROAD — any non-task, snippets and lessons included —
where the browse facet of the same name is narrow (`note_type == 'note'`).
They are left different deliberately; narrowing this one would stop returning
snippets to every caller that already asks this way.

An unrecognised kind is now refused rather than answered. Both doors used to
fall through: the MCP tool into a filter matching no row, the route into no
filter at all, so `?content_type=snippets` returned the whole corpus while
looking like a narrowed search. An empty result set is a claim — "the corpus
holds nothing like this" — and an agent acts on that claim by building the
thing it could not find, so a typo must not be able to make it.

The docstring is the agent-facing contract (#2846), and a test now holds it to
the table: every kind `_FACETS` declares has to appear in it, because a filter
an agent has not been told about is unreachable however well it is wired.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01821k5B3Ysecp9fNYs92Kuy

tests/test_mcp_tool_search.py

@@ -125,22 +125,107 @@ async def test_a_short_record_arrives_whole_and_unmarked():
 
 @pytest.mark.asyncio
 async def test_fable_search_content_type_filters_at_service_layer():
-    """content_type maps to the is_task kwarg passed to the service."""
+    """The three historical values keep meaning exactly what they meant.
+
+    `note` is the one that could plausibly have been tightened when the
+    specific kinds arrived — it is BROAD here (any non-task, snippets and
+    lessons included) while the web facet of the same name is narrow. Pinning
+    it stops a later tidy-up from silently removing snippets from every caller
+    that already asks this way (#4250)."""
     _user_id_ctx.set(7)
     mock_search = AsyncMock(return_value=[])
     with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
         await search(q="x", content_type="task")
         assert mock_search.call_args.kwargs["is_task"] is True
+        assert mock_search.call_args.kwargs.get("task_kind") is None
 
         mock_search.reset_mock()
         await search(q="x", content_type="note")
         assert mock_search.call_args.kwargs["is_task"] is False
+        assert mock_search.call_args.kwargs.get("note_type") is None
 
         mock_search.reset_mock()
         await search(q="x", content_type="all")
         assert mock_search.call_args.kwargs["is_task"] is None
 
 
+# --- the specific kinds: the engine already supported them (#4250) -----------
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "content_type,expected",
+    [
+        ("snippet", {"is_task": False, "note_type": "snippet"}),
+        ("lesson", {"is_task": False, "note_type": "lesson"}),
+        ("process", {"is_task": False, "note_type": "process"}),
+        ("issue", {"is_task": True, "task_kind": "issue"}),
+        ("spike", {"is_task": True, "task_kind": "spike"}),
+        ("work", {"is_task": True, "task_kind": "work"}),
+        ("plan", {"is_task": True, "task_kind": "plan"}),
+    ],
+)
+async def test_each_specific_kind_reaches_the_engine_filter_it_names(
+    content_type, expected
+):
+    """`note_type` and `task_kind` were parameters of the search all along —
+    what was missing was a way to ask for them from the agent's door. Asking
+    for a snippet must narrow to snippets, not merely to non-tasks."""
+    _user_id_ctx.set(7)
+    mock_search = AsyncMock(return_value=[])
+    with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
+        await search(q="x", content_type=content_type)
+    kwargs = mock_search.call_args.kwargs
+    for key, value in expected.items():
+        assert kwargs[key] == value, f"{content_type}: {key}"
+
+
+def test_the_vocabulary_is_derived_from_the_facet_table_not_recopied():
+    """#3161's property, held at this door too: adding a kind to `_FACETS` is
+    one edit. A hand-kept list here is exactly how the agent's search came to
+    offer two kinds while the web's offered nine."""
+    from scribe.services.knowledge import FACET_TYPES, content_type_filters
+
+    for facet in FACET_TYPES:
+        filters = content_type_filters(facet)  # raises if a kind is unreachable
+        assert "is_task" in filters, facet
+
+    # The guard can fail: a name absent from the table is refused, so this is
+    # membership in the table and not "every string works" (#167).
+    with pytest.raises(ValueError):
+        content_type_filters("a-kind-that-is-not-in-the-facet-table")
+
+
+@pytest.mark.asyncio
+async def test_an_unknown_content_type_is_refused_rather_than_returning_nothing():
+    """An empty result set is a CLAIM — "the corpus holds nothing like this" —
+    and an agent acts on it by writing the thing it could not find. A typo must
+    not be able to make that claim, so the door raises with the vocabulary
+    instead of falling through to a filter that matches no row."""
+    _user_id_ctx.set(7)
+    mock_search = AsyncMock(return_value=[])
+    with patch("scribe.mcp.tools.search.semantic_search_notes", mock_search):
+        with pytest.raises(ValueError) as err:
+            await search(q="x", content_type="snippets")   # plural typo
+    mock_search.assert_not_awaited()
+    message = str(err.value)
+    assert "snippets" in message
+    assert "snippet" in message and "lesson" in message   # names the valid ones
+
+
+@pytest.mark.asyncio
+async def test_the_docstring_names_every_kind_the_tool_accepts():
+    """The docstring IS the agent-facing contract (#2846) — a filter an agent
+    has not been told about is unreachable however well it is wired."""
+    from scribe.mcp.tools.search import search as search_tool
+    from scribe.services.knowledge import FACET_TYPES
+
+    doc = search_tool.__doc__ or ""
+    for facet in FACET_TYPES:
+        assert f"'{facet}'" in doc, f"{facet} is accepted but never documented"
+    assert "'rule'" in doc and "'milestone'" in doc and "'all'" in doc
+
+
 @pytest.mark.asyncio
 async def test_an_explicit_search_reaches_a_lesson_from_any_project():
     """The wiring half of milestone 385 step 3.

tests/test_search_route.py

@@ -1,18 +1,50 @@
-"""Unit tests for the search route parameter mapping."""
-from scribe.routes.search import _content_type_to_is_task
+"""/api/search — the kind filter it offers, and what it does with a bad one.
+
+This route used to carry its own two-value map (`note`/`task`/everything else
+is `all`), which made it the third hand-kept copy of a vocabulary that lives in
+one table. Both halves of #4250 are pinned here: every declared kind is
+reachable, and a kind that does not exist is refused rather than widened.
+"""
+import pytest
+
+from scribe.services.knowledge import FACET_TYPES, content_type_filters
 
 
-def test_content_type_note():
-    assert _content_type_to_is_task("note") is False
+def test_the_three_historical_values_still_mean_what_they_meant():
+    assert content_type_filters("all") == {"is_task": None}
+    assert content_type_filters("task")["is_task"] is True
+    # BROAD on purpose: any non-task, so snippets and lessons stay in scope.
+    assert content_type_filters("note") == {"is_task": False}
 
 
-def test_content_type_task():
-    assert _content_type_to_is_task("task") is True
+@pytest.mark.parametrize("facet", sorted(FACET_TYPES))
+def test_every_declared_kind_is_reachable_through_this_door(facet):
+    """The engine took `note_type` and `task_kind` all along — the route was
+    simply unable to say them."""
+    filters = content_type_filters(facet)
+    assert "is_task" in filters
+    if facet not in ("all", "note", "task"):
+        assert filters.get("note_type") == facet or filters.get("task_kind") == facet
 
 
-def test_content_type_all():
-    assert _content_type_to_is_task("all") is None
+def test_an_unknown_kind_is_refused_instead_of_silently_widening():
+    """The old map read anything unrecognised as "no filter", so
+    `?content_type=snippets` returned the whole corpus while looking like a
+    narrowed search — the failure mode that answers a question nobody asked."""
+    with pytest.raises(ValueError) as err:
+        content_type_filters("snippets")
+    assert "snippets" in str(err.value)
+    assert "snippet" in str(err.value)        # names the real ones
 
 
-def test_content_type_unknown_defaults_to_all():
-    assert _content_type_to_is_task("unknown") is None
+def test_a_doors_refusal_lists_only_what_that_door_accepts():
+    """`rule` and `milestone` are the MCP tool's own searches. This route has
+    neither, so offering them in its error would send a caller at a parameter
+    that does not work here."""
+    with pytest.raises(ValueError) as plain:
+        content_type_filters("nonsense")
+    assert "rule" not in str(plain.value)
+
+    with pytest.raises(ValueError) as extra:
+        content_type_filters("nonsense", extra=("rule", "milestone"))
+    assert "rule" in str(extra.value) and "milestone" in str(extra.value)