From 6db9948c54b132aceea5592b798f955183044f77 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 7 Sep 2026 11:42:14 +0000
Subject: [PATCH 1/2] =?UTF-8?q?fix(search):=20=D7=9B=D7=A9=D7=9C=20=D7=91?=
 =?UTF-8?q?=D7=9E=D7=A1=D7=9C=D7=95=D7=9C=20=D7=94=D7=97=D7=99=D7=A4=D7=95?=
 =?UTF-8?q?=D7=A9=20=D7=94=D7=9E=D7=94=D7=99=D7=A8=20=D7=A0=D7=A8=D7=A9?=
 =?UTF-8?q?=D7=9D,=20=D7=95-code=20=D7=A0=D7=95=D7=A1=D7=A3=20=D7=9C=D7=A8?=
 =?UTF-8?q?=D7=A9=D7=99=D7=9E=D7=AA=20=D7=94=D7=A4=D7=A8=D7=95=D7=A4=D7=99?=
 =?UTF-8?q?=D7=99=D7=9C=D7=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

שלושה סבבי חקירה על "הפרופיילר לא שומר ערכים" הובילו למקום אחר לגמרי.
הסימפטום היה unknown_field:code. השורש הוא שלושה except שקטים במסלול
החיפוש.

מה שהלוגים הראו
---------------
חיפוש תוכן אחד שלא הניב תוצאות:

  10:33:27.95  webapp:post:api_search_global — אגרגציה בלי code, 1043ms
  10:33:30→37  בניית אינדקס בזיכרון: 67,381 מילים, 392 פונקציות
  10:33:46.03  slow_mongo — אגרגציה עם code: {$regex}, 1073ms

ה-$project של הרשומה שנדחתה הוא צורת ההחרגה (code: 0, _m: 0, …), כלומר
בדיוק המסלול של הפולבאק בוובאפ. לא ניחוש.

שני פולבאקים שונים, ואל תבלבלו ביניהם
--------------------------------------
להגיע ל-_safe_search בכלל זה מסלול תקין: היא נקראת כשמנוע החיפוש החזיר
אפס תוצאות, וההערה בקוד אומרת את זה במפורש. אין שם שום שגיאה.

ה-except הפנימי הוא משהו אחר — שאילתת ה-$text עצמה נזרקה. שם חיפשתי
במפורש if not results / len(docs)==0 ואין: המעבר ל-$regex הוא רק על
חריגה.

הכשל היה בלתי נראה, וזה השורש
------------------------------
except Exception: בלי שורת לוג אחת. כשהמסלול המהיר נשבר, המערכת עברה
בשקט לשאילתה אחרת — $regex על code, סריקה מלאה בלי אינדקס — שנמדדה
כשאילתה האיטית ביותר בכל הלוח (3,730ms). היא רצה רק מפני שהמסלול המהיר
נפל, ואיש לא ידע.

ההערה שהייתה שם ניחשה "למשל אין אינדקס טקסט". בדקתי את הניחוש ופסלתי
אותו: search_text_idx קיים, והרצתי את אותה שאילתת $text בדיוק מול
הקלאסטר — היא עובדת ומחזירה תוצאות. הסיבה האמיתית נשארה בלתי ידועה, וזה
מה שהשורות החדשות מתקנות.

שלושתן נוספו: $text ← $regex, $regex ← הפייפליין הישן, והאחרון שמחזיר
"לא נמצאו תוצאות" — כלומר חיפוש שבור שנראה בדיוק כמו חיפוש שלא מצא, וזה
ההבדל היחיד שחשוב למשתמש.

code ברשימה — משני, ולא במקום התיקון
-------------------------------------
בלעדיו השאילתה נדחית, וניתוח שלה רץ על regex של "<value>" שאינו מתאים
כמעט לכלום — כלומר דוח שאומר "מהיר, אפס מסמכים נסרקו" על השאילתה האיטית
ביותר במערכת. הערך שנשמר הוא דפוס החיפוש שהוקלד, לא תוכן הקובץ.

וההערה מעל הרשימה תוקנה. היא טענה שהרשימה נגזרה מ"השדות של code_snippets
בפרודקשן" — נמדדו 32 שדות באוסף מול 19 ברשימה. הכלל האמיתי הוא: השדות
שמסננים לפיהם בשאילתות המשויכות למשתמש. זה נגזר מסדר הבדיקות — שער
הבעלות רץ לפני בדיקת השדות — ולכן שדות ה-worker לעולם אינם מגיעים לשם.

מגבלה ידועה שתועדה ולא תוקנה: הרשימה גלובלית אבל מתארת את code_snippets,
ובלוג יש 15 צירופי אוסף/פעולה. שאילתה משויכת-משתמש על large_files או
markdown_images תיפסל על השדות של עצמה. סעיף נפרד.

אימות
-----
טסטי הלוג בודקים את ההתנהגות ולא את קיום השורה: הם מאלצים כל אחד משלושת
הכשלים ובודקים מה יצא ללוג, כולל exc_info. קריאת קוד הייתה "מאמתת" גם
ניסוח שלא רץ לעולם.

טסטי משפחות השאילתות מריצים את ההחלטה על הצורות שהריפו באמת בונה, ולא על
תוכן הרשימה — assert "code" in ALLOWED_FIELDS היה מאשר את עצמו.

מוטציות, כל אחת מפילה בדיוק את שלה:
- הסרת שלוש שורות הלוג ← שלושת טסטי הלוג
- הסרת code מהרשימה ← שני טסטי החיפוש
- הסרת שער הבעלות ← טסט ה-worker

ובדרך, טסט קיים תפס את השינוי לבד: הטבלה ב-test_query_profiler_service
דורשת כיסוי מלא של הרשימה, ונפלה על code עד שנוספה לו דגימה. בדיוק לשם
כך היא נכתבה.

150 טסטים · flake8 זהה לבסיס (webapp/app.py ירד ב-1, השאר 1=1 ו-2=2).

מה שלא אימתתי
--------------
לא אימתתי מה $text זרק בפועל — עד שהלוג החדש ירוץ בפרודקשן אין דרך לדעת,
וזו בדיוק הסיבה שהוא נוסף. כל טענה על הסיבה עד אז היא ניחוש.

ממצא לוואי שלא נגעתי בו: בניית האינדקס בזיכרון לוקחת כשבע שניות, בתוך
בקשת חיפוש. לא מדדתי כמה פעמים זה קורה.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UBugD1DV8LhHBSGnvpAgzK
---
 docs/whats-new.rst                        |   2 +
 services/query_profiler_service.py        |  25 +++-
 tests/test_profiler_raw_query_families.py | 175 ++++++++++++++++++++++
 tests/test_query_profiler_service.py      |   5 +
 tests/test_search_fallback_is_logged.py   | 100 +++++++++++++
 webapp/app.py                             |  39 ++++-
 6 files changed, 341 insertions(+), 5 deletions(-)
 create mode 100644 tests/test_profiler_raw_query_families.py
 create mode 100644 tests/test_search_fallback_is_logged.py

diff --git a/docs/whats-new.rst b/docs/whats-new.rst
index 4bc823ca5..644750057 100644
--- a/docs/whats-new.rst
+++ b/docs/whats-new.rst
@@ -8,6 +8,8 @@ What's New
 - **fix: הדגל נכנס למפתח הקאש של** ``/files``\ **, אחרת השינוי לא היה נראה.** העמוד שומר את ה-HTML המרונדר, והמפתח נבנה מפרמטרי החיפוש בלבד. בלי הדגל, משתמש שמדליק את המתג היה מקבל את ה-HTML של המצב הקודם עד שה-TTL פוקע, ומסיק שהפיצ'ר שבור. הדגל נוסף כתחילית למפתח כך שגם ענף ה-fallback מבדיל בין המצבים. ביטול קאש נשקל ונפסל: אין היום שום קוד שמבטל את ``web:files:user:*``, ומפתח שמתאר את התוכן אינו זקוק לפעולה שיכולה להיכשל בשקט.
 - **fix: ההעדפה נפתרת פעם אחת לכל בקשה.** ``/files`` בונה את מפתח הקאש לפני הרינדור וה-context processor מזין את התבנית — שתי קריאות נפרדות למסד באותה בקשה. שינוי העדפה שנוחת ביניהן היה גורם ל-HTML של מצב אחד להישמר תחת התגית של המצב השני, וכל מי שמבקש אחר כך את התצוגה ההיא היה מקבל את ההפך עד פקיעת ה-TTL. התוצאה נשמרת עכשיו על ``g``, ההיקף היחיד שמובטח שהוא בדיוק בקשה אחת.
 - **fix: המאזין של המתג מסומן על האלמנט, כי הבלוק** ``extra_js`` **של עמוד ההגדרות מרונדר פעמיים.** ``settings.html`` מצהיר אותו בתוך ``block content``, ולכן Jinja מרנדר אותו גם שם וגם ב-``base.html``. נמדד בדפדפן: לחיצה אחת, אירוע ``change`` אחד, ושתי בקשות ל-``/api/ui_prefs`` משתי שורות שונות באותו עמוד. הכפילות קיימת גם ב-``persistentToggle``, ב-``fontMinus`` וב-``themeSelect``, ולא תוקנה כאן — היא נוגעת בכל העמוד ומצריכה שינוי מבני נפרד.
+- **fix (חיפוש): כשל במסלול החיפוש המהיר נרשם ללוג במקום להיבלע.** שלושה ``except`` שקטים ב-``_safe_search`` — הראשון נופל מ-``$text`` ל-``$regex`` על ``code``, השני משם לפייפליין הישן, והשלישי מחזיר "לא נמצאו תוצאות". אף אחד מהם לא כתב שורה אחת, ולכן כשהמסלול המהיר נשבר המערכת עברה בשקט לשאילתה **אחרת**: סריקה מלאה בלי אינדקס, שנמדדה כשאילתה **האיטית ביותר בכל הלוח** (3,730ms). ההערה שהייתה שם ניחשה "למשל אין אינדקס טקסט" — הניחוש נבדק ונפסל: ``search_text_idx`` קיים, ואותה שאילתת ``$text`` בדיוק רצה מול הקלאסטר ומחזירה תוצאות. ⚠️ ולא לבלבל בין שני פולבאקים שונים: להגיע לפונקציה הזו זה מסלול **תקין** שקורה כשמנוע החיפוש החזיר אפס תוצאות; ה-``except`` הוא משהו אחר — השאילתה עצמה נזרקה. כשל שלישי מחזיר "לא נמצאו תוצאות", כלומר חיפוש שבור נראה בדיוק כמו חיפוש שלא מצא — וזה ההבדל היחיד שחשוב למשתמש.
+- **fix (פרופיילר): ``code`` נוסף לרשימת השדות שנשמרים עם ערכים אמיתיים.** בלעדיו שאילתת החיפוש נדחתה ב-``unknown_field:code``, וניתוח שלה רץ על ``{"code": {"$regex": "<value>"}}`` — regex שאינו מתאים כמעט לכלום, ולכן ה-explain דיווח "מהיר, אפס מסמכים נסרקו" **על השאילתה האיטית ביותר במערכת**. הערך שנשמר הוא דפוס החיפוש שהוקלד ולא תוכן הקובץ. ובאותו מעבר תוקנה ההערה מעל הרשימה: היא טענה שהרשימה נגזרה מ"השדות של ``code_snippets``" (נמדדו 32 שדות באוסף מול 19 ברשימה), בעוד הכלל האמיתי הוא *השדות שמסננים לפיהם בשאילתות שמשויכות למשתמש* — מה שגם מסביר למה שדות ה-worker אינם שייכים לשם: הם נדחים כ-``owner_missing`` לפני שהרשימה נבדקת בכלל.
 - **fix (פרופיילר): שינוי מסנן ה-collection באמצע דפדוף כבר אינו מעלים שורות.** ל-``<select>`` של הסינון **לא היה שום מאזין שינוי** — עד שנוסף העימוד זה היה פגם חוויה בלבד (בחירה לא עשתה כלום עד לחיצה על "רענן"), אבל עם קורסור זה הפך לבאג נכונות: בחירת collection ואז "טען עוד" שלחה את המסנן החדש עם הקורסור הישן, שנטבע עבור אוכלוסייה אחרת. במיון יורד לפי זמן, שורות של ה-collection החדש שזמנן מאוחר מנקודת הקורסור לא היו מופיעות לעולם. שתי שכבות: ה-select מרענן ומאפס את הקורסור, **והקורסור עצמו נושא עכשיו את מסנני האוכלוסייה** ונדחה ב-400 כשהם משתנים — בדיוק כמו שהוא כבר נושא את שדה המיון והכיוון. הכלל אחד: קורסור תקף רק לשאילתה שהוא נטבע עבורה.
 - **docs (פרופיילר): הובהר ש-``/api/profiler/slow-queries`` מוגש בידי שני שירותים שונים.** הוובאפ (סשן אדמין) מממש עימוד, מיון, ``total`` ו-``next_cursor``; הראוט של הבוט (``X-Profiler-Token``) מממש רק ``limit``/``collection``/``min_time``/``hours``, ומתעלם בשקט מכל פרמטר אחר. דוגמת ה-``curl`` בעמוד השתמשה בטוקן בזמן שהטקסט תיאר את הוובאפ — כלומר מי שהעתיק אותה קיבל בדיוק את ההתעלמות השקטה שהעמוד מבטיח שלא תקרה. בנוסף: הפסקה על האינדקסים הבהירה שהם משרתים את הראוט של הבוט ולא את הדשבורד, וההנמקה על ``collection_timestamp`` מפרידה עכשיו בין "לא מספק את המיון" לבין "כן היה מצמצם סריקה" — שני דברים שהיו מעורבבים.
 - **fix (פרופיילר): ``min_time`` חזר לעבוד.** הפרמטר מתועד, והראוט של הבוט עדיין משתמש בו — אבל המעבר ל-``get_slow_queries_page`` הפיל אותו בשקט: הראוט המשיך לקבל אותו, להתעלם, ולהחזיר **200 עם שורות לא מסוננות**. תשובה שנראית תקינה ואינה נכונה גרועה משגיאה, כי אין בה שום סימן שמשהו לא בסדר. הוא מצטרף עכשיו לפילטר החלון ולא לפילטר הדף — כלומר הוא נספר גם ב-``total``, בדיוק כמו ``collection``, אחרת "מוצגות 2 מתוך 4" היה מדווח על אוכלוסייה שכולה 2. ערך שאינו מספר סופי מוחזר כ-400 ולא מדולג: ``{"$gte": NaN}`` אינו מתאים לאף מסמך במונגו, כלומר טבלה ריקה בלי הסבר.
diff --git a/services/query_profiler_service.py b/services/query_profiler_service.py
index 0c98fc955..1cb3243ae 100644
--- a/services/query_profiler_service.py
+++ b/services/query_profiler_service.py
@@ -268,13 +268,34 @@ def _env_int(name: str, default: int) -> int:
 #: המפתח שמזהה את בעל השאילתה.
 RAW_QUERY_OWNER_KEY = "user_id"
 
-#: שדות שמותר להם להופיע בשאילתה שנשמרת עם ערכים. נגזר מהשדות של
-#: ``code_snippets`` בפרודקשן וממה שנרשם ב-``slow_queries_log``.
+#: שדות שמותר להם להופיע בשאילתה שנשמרת עם ערכים.
+#:
+#: **הכלל אינו "השדות של האוסף".** הוא: *השדות שמסננים לפיהם בשאילתות
+#: שמשויכות למשתמש*. ההבדל אינו סמנטי — הוא נגזר מסדר הבדיקות ב-
+#: ``_decide_raw_query``: שער הבעלות רץ **לפני** בדיקת השדות, ולכן הרשימה
+#: רואה רק שאילתות שכבר הצהירו על משתמש מורשה יחיד. שדות ה-worker
+#: (``needs_embedding``, ``contentHash``, ``chunkerVersion`` ומשפחת
+#: ``embedding*``) נדחים כ-``owner_missing`` הרבה קודם ולכן אינם שייכים לכאן,
+#: ו-``snippetEmbedding`` לעולם לא — הוא וקטור, לא מסנן.
+#:
+#: ההערה הקודמת כאן טענה שהרשימה נגזרה מ"השדות של ``code_snippets``
+#: בפרודקשן", וזה לא היה מדויק: נמדדו 32 שדות באוסף מול 19 ברשימה, ו-``code``
+#: — שנמצא ב-400 מתוך 400 מסמכים שנדגמו — נשמט. הערה שמתארת כלל שגוי היא מה
+#: שמייצר את הפער הבא, ולכן היא תוקנה לכלל האמיתי.
+#:
+#: ⚠️ **מגבלה ידועה:** הרשימה גלובלית, אבל היא מתארת את ``code_snippets``.
+#: שאילתה משויכת-משתמש על אוסף אחר (``large_files``, ‏``markdown_images``,
+#: ‏``note_reminders``, ‏``users`` — כולם מופיעים ב-``slow_queries_log``) תיפסל
+#: על השדות הלגיטימיים של עצמה. זה סעיף נפרד ולא תוקן כאן.
 RAW_QUERY_ALLOWED_FIELDS: FrozenSet[str] = frozenset({
     "user_id", "_id", "is_active", "file_name", "programming_language", "tags",
     "description", "version", "created_at", "updated_at", "deleted_at",
     "deleted_expires_at", "file_size", "lines_count", "is_favorite", "favorited_at",
     "is_pinned", "pinned_at", "pin_order",
+    # ``code`` נושא את **דפוס החיפוש שהוקלד**, לא את תוכן הקובץ: בשאילתה הזו
+    # הוא תמיד בצד השמאלי של ``$regex``. תקרת ``PROFILER_UNREDACTED_MAX_BYTES``
+    # חוסמת דפוס חריג בגודלו.
+    "code",
 })
 
 RAW_QUERY_LOGICAL_OPERATORS: FrozenSet[str] = frozenset({"$and", "$or", "$nor"})
diff --git a/tests/test_profiler_raw_query_families.py b/tests/test_profiler_raw_query_families.py
new file mode 100644
index 000000000..dd10f864f
--- /dev/null
+++ b/tests/test_profiler_raw_query_families.py
@@ -0,0 +1,175 @@
+"""‏``_decide_raw_query`` מול **הצורות שהריפו באמת בונה**.
+
+**למה לא טסט על תוכן הרשימה.** ``assert "code" in RAW_QUERY_ALLOWED_FIELDS``
+מאשר את עצמו: הוא מעתיק את ההחלטה במקום לבדוק אותה, והוא ימשיך לעבור גם אם
+שאילתה אמיתית תפסיק לעבור. הטסטים כאן מריצים את ההחלטה על הפייפליינים שהקוד
+מייצר, ולכן הם נשברים ברגע שמישהו מוסיף סינון על שדה חדש — וזה בדיוק מה
+שרוצים לתפוס.
+
+**הצורות מגיעות ממקום מוגדר בקוד ולא מהזיכרון:**
+
+=========================================  ==============================================
+הצורה                                       מי בונה אותה
+=========================================  ==============================================
+חיפוש עם ``$regex`` על ``code``             ``webapp/app.py`` — הפולבאק של החיפוש
+חיפוש עם ``$text``                          אותו מקום, המסלול המהיר
+רשימת הקבצים / חיפוש תוכן                   ``search_engine._content_search`` ← ``get_user_files``
+העמוד השני של ``/files``                    שאילתת הקורסור
+=========================================  ==============================================
+
+הצורה הראשונה **נדחתה בפרודקשן** ב-``unknown_field:code``, והיא הסיבה
+לקובץ הזה.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from unittest.mock import MagicMock
+
+import pytest
+from bson import ObjectId
+
+from services.query_profiler_service import PersistentQueryProfilerService
+
+ME = 6865105071
+WHEN = datetime(2026, 9, 7, 12, 0, 0)
+OID = ObjectId("6a8e6c04cfb3849504b6e210")
+
+#: הפייפליין של החיפוש כשהמסלול המהיר נכשל. ``$match`` הראשון הוא מה שנבדק;
+#: שאר השלבים כאן כדי שהצורה תהיה אמיתית ולא מקוצצת.
+SEARCH_REGEX_PIPELINE = [
+    {"$match": {"user_id": ME, "is_active": True, "code": {"$regex": "סטיקי", "$options": "i"}}},
+    {"$sort": {"file_name": 1, "version": -1}},
+    {"$group": {"_id": "$file_name", "latest": {"$first": "$$ROOT"}}},
+    {"$replaceRoot": {"newRoot": "$latest"}},
+    {"$addFields": {"_m": {"$regexFind": {"input": "$code", "regex": "סטיקי", "options": "i"}}}},
+    {"$project": {"code": 0, "_m": 0}},
+    {"$sort": {"updated_at": -1}},
+    {"$limit": 50},
+]
+
+SEARCH_TEXT_PIPELINE = [
+    {"$match": {"user_id": ME, "is_active": True, "$text": {"$search": "סטיקי"}}},
+    {"$sort": {"file_name": 1, "version": -1}},
+    {"$limit": 50},
+]
+
+#: ``_content_search`` ורשימת הקבצים — ``get_user_files``.
+USER_FILES_PIPELINE = [
+    {"$match": {"is_active": True, "user_id": ME}},
+    {"$sort": {"file_name": 1, "version": -1}},
+    {"$group": {"_id": "$file_name", "latest": {"$first": "$$ROOT"}}},
+    {"$replaceRoot": {"newRoot": "$latest"}},
+    {"$sort": {"updated_at": -1}},
+    {"$project": {"code": 1, "file_name": 1, "programming_language": 1, "tags": 1, "updated_at": 1}},
+    {"$skip": 200},
+    {"$limit": 200},
+]
+
+#: העמוד השני של ``/files`` — שאילתת הקורסור, זו שכל הפיצ'ר נבנה בשבילה.
+FILES_CURSOR_QUERY = {
+    "user_id": ME,
+    "$and": [
+        {"is_active": True},
+        {"$or": [
+            {"created_at": {"$lt": WHEN}},
+            {"$and": [{"created_at": {"$eq": WHEN}}, {"_id": {"$lt": OID}}]},
+        ]},
+    ],
+}
+
+
+@pytest.fixture
+def svc(monkeypatch):
+    monkeypatch.setenv("PROFILER_UNREDACTED_USER_IDS", str(ME))
+    manager = MagicMock()
+    manager.db = None  # ההחלטה על הערכים אינה נוגעת ב-DB
+    return PersistentQueryProfilerService(db_manager=manager, slow_threshold_ms=100)
+
+
+def _decide(service, operation, query):
+    raw, owner, reason = service._decide_raw_query(operation, query)
+    return raw, owner, reason
+
+
+class TestTheQueryFamiliesTheRepoBuilds:
+    def test_the_search_that_was_rejected_in_production_is_accepted(self, svc):
+        """‏**הטסט שנולד מהדחייה.**
+
+        השאילתה הזו נדחתה ב-``unknown_field:code``, והיא הייתה האיטית ביותר
+        שנרשמה. ניתוח שלה על השלד מריץ ``explain`` על ``{"code": {"$regex":
+        "<value>"}}`` — regex שלא מתאים כמעט לכלום — ולכן הדוח מדווח "מהיר,
+        אפס מסמכים נסרקו" **על השאילתה האיטית ביותר במערכת**.
+        """
+        raw, owner, reason = _decide(svc, "aggregate", {"pipeline": SEARCH_REGEX_PIPELINE})
+
+        assert reason is None, f"נדחתה: {reason}"
+        assert owner == str(ME)
+        assert raw is not None
+
+    def test_and_the_search_pattern_survives_as_the_real_pattern(self, svc):
+        """לא מספיק ש"התקבלה" — הערך שנשמר חייב להיות הדפוס האמיתי.
+
+        ``json_util`` ממיר ``{"$regex": …, "$options": …}`` ל-``Regex`` — זו
+        גם צורת הייצוג של regex ב-Extended JSON, ולכן הדפוס והדגלים עוברים
+        באותו מנגנון בלי לאבד דבר.
+        """
+        raw, _owner, _reason = _decide(svc, "aggregate", {"pipeline": SEARCH_REGEX_PIPELINE})
+
+        saved = raw["pipeline"][0]["$match"]["code"]
+        assert getattr(saved, "pattern", None) == "סטיקי", f"הדפוס לא שרד: {saved!r}"
+
+    def test_the_fast_path_with_text_is_accepted_too(self, svc):
+        """המסלול המהיר של אותה פונקציה. כאן כדי שהוספת ``code`` לא תשבור אותו."""
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": SEARCH_TEXT_PIPELINE})
+
+        assert reason is None, f"נדחתה: {reason}"
+
+    def test_the_content_search_and_file_list_query_is_accepted(self, svc):
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": USER_FILES_PIPELINE})
+
+        assert reason is None, f"נדחתה: {reason}"
+
+    def test_the_files_cursor_query_is_accepted(self, svc):
+        raw, _owner, reason = _decide(svc, "find", FILES_CURSOR_QUERY)
+
+        assert reason is None, f"נדחתה: {reason}"
+        assert raw["$and"][1]["$or"][0]["created_at"]["$lt"] == WHEN
+
+
+class TestNothingWasOpenedUp:
+    """‏``code`` נוסף לרשימה — ולא נפתח שום דבר אחר."""
+
+    def test_a_worker_query_without_an_owner_is_still_withheld(self, svc):
+        """שאילתת ה-worker אינה מצהירה על בעלים, ולכן היא נדחית לפני בדיקת השדות.
+
+        זו גם ההוכחה לכלל שכתוב בהערה מעל הרשימה: שדות ה-worker לעולם אינם
+        מגיעים אליה, ולכן אין שום סיבה להוסיף אותם.
+        """
+        pipeline = [{"$match": {"needs_embedding": True, "chunkerVersion": {"$lt": 3}}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == "owner_missing"
+
+    def test_an_unknown_field_is_still_withheld(self, svc):
+        pipeline = [{"$match": {"user_id": ME, "shared_with": 42}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == "unknown_field:shared_with"
+
+    def test_another_users_id_is_still_withheld(self, svc):
+        pipeline = [{"$match": {"user_id": ME}}, {"$match": {"user_id": 999}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == "owner_mismatch"
+
+    def test_a_vector_search_is_still_withheld(self, svc):
+        """החיפוש הסמנטי נדחה בכוונה, ולא בגלל שדה."""
+        pipeline = [{"$vectorSearch": {"index": "vector_index", "path": "snippetEmbedding"}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == "vector_query"
diff --git a/tests/test_query_profiler_service.py b/tests/test_query_profiler_service.py
index b97bbdbf2..3adf17bb6 100644
--- a/tests/test_query_profiler_service.py
+++ b/tests/test_query_profiler_service.py
@@ -830,6 +830,11 @@ def test_nin_never_asserts_ownership(self, raw_values_service):
     "is_pinned": (False, None),
     "pinned_at": (datetime(2026, 9, 6), None),
     "pin_order": (1, None),
+    # ``code`` מופיע בשאילתות **כדפוס חיפוש**, לא כתוכן קובץ — תמיד בצד
+    # השמאלי של ``$regex``. הדגימה כאן היא מחרוזת פשוטה בכוונה: הטסט הזה בודק
+    # את הסיבוב של הערך, וצורת ה-``$regex`` המלאה נבדקת ב-
+    # ``test_profiler_raw_query_families.py`` על השאילתה האמיתית.
+    "code": ("סטיקי", None),
 }
 
 
diff --git a/tests/test_search_fallback_is_logged.py b/tests/test_search_fallback_is_logged.py
new file mode 100644
index 000000000..54f9a2a76
--- /dev/null
+++ b/tests/test_search_fallback_is_logged.py
@@ -0,0 +1,100 @@
+"""כשמסלול החיפוש המהיר נכשל — זה נרשם, ולא נבלע.
+
+**למה הקובץ הזה קיים.** שלושה ``except`` ב-``_safe_search`` היו שקטים
+לחלוטין. כשה-``$text`` נשבר, המערכת עברה בשקט לשאילתה **אחרת** — ``$regex``
+על ``code``, סריקה מלאה בלי אינדקס — שנמדדה בפרודקשן כשאילתה האיטית ביותר
+בכל הלוח (3,730ms). לקח שלושה סבבי חקירה רק כדי להבין שזה מה שקורה, ובסוף
+לא היה אפשר לדעת **למה** הוא נשבר, כי אף שורה לא נכתבה.
+
+הטסטים כאן מאלצים כל אחד מהכשלים ובודקים שנכתבה שורת לוג. הם בודקים את
+**ההתנהגות** (מה יצא ללוג) ולא את קיום השורה בקוד — קריאת הקוד הייתה
+"מאמתת" גם ניסוח שאינו רץ לעולם.
+
+⚠️ **שני פולבאקים שונים, ואל תבלבלו:** להגיע ל-``_safe_search`` בכלל זה
+מסלול **תקין** — היא נקראת כשמנוע החיפוש החזיר אפס תוצאות, וזו לא שגיאה.
+מה שנבדק כאן הוא ה-``except`` הפנימי: השאילתה עצמה נזרקה.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+
+class _RaisingCollection:
+    """‏``aggregate`` שנכשל במספר הקריאות הראשונות, ואז מצליח.
+
+    ``fail_times=1`` מדמה "המסלול המהיר נשבר, הפולבאק הצליח";
+    ``fail_times=3`` מדמה נפילה עד הסוף.
+    """
+
+    def __init__(self, fail_times):
+        self.fail_times = fail_times
+        self.calls = 0
+
+    def aggregate(self, pipeline, **kwargs):
+        self.calls += 1
+        if self.calls <= self.fail_times:
+            raise RuntimeError(f"aggregate exploded (call {self.calls})")
+        return []
+
+
+class _FakeDB:
+    def __init__(self, collection):
+        self.code_snippets = collection
+
+
+@pytest.fixture
+def app_module(monkeypatch):
+    import webapp.app as webapp_app
+
+    # מנוע החיפוש מחזיר אפס תוצאות — המסלול התקין שמוביל לפונקציה הזו.
+    monkeypatch.setattr(webapp_app, "search_engine", None, raising=False)
+    return webapp_app
+
+
+def _run(app_module, monkeypatch, fail_times):
+    collection = _RaisingCollection(fail_times)
+    monkeypatch.setattr(app_module, "get_db", lambda: _FakeDB(collection), raising=True)
+    results = app_module._safe_search(6865105071, "סטיקי", limit=50)
+    return results, collection
+
+
+def test_a_failing_text_pipeline_is_logged(app_module, monkeypatch, caplog):
+    """הכשל שבגללו רצה השאילתה האיטית ביותר במערכת — עכשיו יש לו שורה."""
+    with caplog.at_level(logging.WARNING):
+        _results, collection = _run(app_module, monkeypatch, fail_times=1)
+
+    assert collection.calls >= 2, "הפולבאק לא רץ, אז אין מה לבדוק"
+    assert any("$text" in r.getMessage() for r in caplog.records), (
+        f"אין שורת לוג על כשל המסלול המהיר: {[r.getMessage() for r in caplog.records]}"
+    )
+
+
+def test_the_failure_carries_the_exception_itself(app_module, monkeypatch, caplog):
+    """‏``exc_info`` ולא רק הודעה.
+
+    בלי ה-traceback השורה אומרת "משהו נשבר" ולא **מה** — וזה בדיוק הפער
+    שהשאיר את הסיבה בלתי ידועה שלושה סבבים.
+    """
+    with caplog.at_level(logging.WARNING):
+        _run(app_module, monkeypatch, fail_times=1)
+
+    failed = [r for r in caplog.records if "$text" in r.getMessage()]
+    assert failed and failed[0].exc_info is not None, "השורה אינה נושאת את החריגה"
+
+
+def test_falling_all_the_way_down_is_logged_too(app_module, monkeypatch, caplog):
+    """נפילה עד "לא נמצאו תוצאות" — המצב שנראה בדיוק כמו חיפוש שלא מצא.
+
+    זה ההבדל היחיד שחשוב למשתמש, ועד עכשיו הוא לא היה מובחן בשום מקום.
+    """
+    with caplog.at_level(logging.WARNING):
+        results, _collection = _run(app_module, monkeypatch, fail_times=99)
+
+    assert results == []
+    messages = [r.getMessage() for r in caplog.records]
+    assert any("no results" in m for m in messages), (
+        f"חיפוש שנשבר לגמרי חזר שקט: {messages}"
+    )
diff --git a/webapp/app.py b/webapp/app.py
index 4abeafd3c..d9a0381ca 100644
--- a/webapp/app.py
+++ b/webapp/app.py
@@ -9540,8 +9540,27 @@ def _safe_search(user_id: int, query: str, **kwargs):
             ))
         return results
     except Exception:
-        # אם $text נכשל (למשל אין אינדקס טקסט), ננסה fallback ל-$regex על code בלבד
-        # כדי לשמור על התנהגות חיפוש בסיסית.
+        # ⚠️ **הכשל הזה נרשם, ולא נבלע.**
+        #
+        # ⚠️ ואל תבלבלו בין שני הפולבאקים: ל-**פונקציה הזו** מגיעים גם כשאין
+        # שגיאה בכלל — ``_safe_search`` נופל לכאן כשמנוע החיפוש החזיר **אפס
+        # תוצאות**, וזה מסלול תקין. ה-``except`` כאן הוא משהו אחר לגמרי:
+        # שאילתת ה-``$text`` עצמה נזרקה. אין כאן שום פולבאק על תוצאות ריקות.
+        #
+        # עד כאן ה-``except`` היה שקט לחלוטין, ולכן כשהמסלול המהיר נכשל
+        # המערכת עברה בשקט לשאילתה **אחרת** — ``$regex`` על ``code``, סריקה
+        # מלאה בלי אינדקס — ואיש לא ידע. בפרודקשן זו הייתה השאילתה האיטית
+        # ביותר שנרשמה (3,730ms), והיא רצה רק מפני שהמסלול המהיר נפל.
+        #
+        # ההערה שהייתה כאן ניחשה "למשל אין אינדקס טקסט", והניחוש הזה **נבדק
+        # ונפסל**: ‏``search_text_idx`` קיים, ואותה שאילתת ``$text`` בדיוק רצה
+        # מול הקלאסטר ומחזירה תוצאות. הסיבה האמיתית הייתה בלתי נראית, וזה מה
+        # שהשורה הבאה מתקנת.
+        logger.warning(
+            "search fallback: $text pipeline failed, falling back to $regex on code",
+            exc_info=True,
+            extra={"event": "search_text_pipeline_failed", "is_regex": is_regex},
+        )
         try:
             if (not is_regex) and isinstance(match_stage, dict) and ('$text' in match_stage):
                 match_stage2 = dict(match_stage)
@@ -9576,7 +9595,13 @@ def _safe_search(user_id: int, query: str, **kwargs):
                     ))
                 return results2
         except Exception:
-            pass
+            # אותו נימוק בדיוק: כשל כאן מוביל לפולבאק **שלישי**, ובלי שורה
+            # אחת בלוג אין שום דרך לדעת שירדנו עוד מדרגה.
+            logger.warning(
+                "search fallback: $regex pipeline failed, falling back to the legacy pipeline",
+                exc_info=True,
+                extra={"event": "search_regex_pipeline_failed"},
+            )
 
         # fallback אחרון: שמירה על פונקציונליות גם אם Mongo לא תומך ב-$regexFind וכו'.
         try:
@@ -9590,6 +9615,14 @@ def _safe_search(user_id: int, query: str, **kwargs):
             ]
             docs = list(db.code_snippets.aggregate(old_pipeline, allowDiskUse=True))
         except Exception:
+            # ‏**זה המסלול שמחזיר "לא נמצאו תוצאות" על כשל.** בלי לוג, חיפוש
+            # שנשבר נראה בדיוק כמו חיפוש שלא מצא כלום — וזה ההבדל היחיד
+            # שחשוב למשתמש.
+            logger.warning(
+                "search fallback: legacy pipeline failed too, returning no results",
+                exc_info=True,
+                extra={"event": "search_legacy_pipeline_failed"},
+            )
             return []
         from types import SimpleNamespace
         results: list = []

From a1e2c2fc6f71b50f6331055da13b4f071878ec9d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 7 Sep 2026 12:14:35 +0000
Subject: [PATCH 2/2] =?UTF-8?q?fix(search,profiler):=20=D7=A9=D7=9C=D7=95?=
 =?UTF-8?q?=D7=A9=D7=94=20=D7=9E=D7=9E=D7=A6=D7=90=D7=99=20=D7=A8=D7=99?=
 =?UTF-8?q?=D7=95=D7=95=D7=99=D7=95=20=E2=80=94=20=D7=94=D7=95=D7=93=D7=A2?=
 =?UTF-8?q?=D7=94=20=D7=A9=D7=99=D7=9B=D7=9C=D7=94=20=D7=9C=D7=A9=D7=A7?=
 =?UTF-8?q?=D7=A8,=20=D7=99=D7=A8=D7=99=D7=93=D7=94=20=D7=A9=D7=A7=D7=98?=
 =?UTF-8?q?=D7=94,=20=D7=95-code=20=D7=91=D7=9C=D7=99=20=D7=90=D7=99=D7=9C?=
 =?UTF-8?q?=D7=95=D7=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

הרצתי ריוויו על ה-PR (cubic מיצה מכסה). שלושת הממצאים אומתו מול הקוד
לפני שנגעתי, ושלושתם אמיתיים.

1. הודעת לוג שהצהירה על מסלול שלא בהכרח נלקח
--------------------------------------------
"falling back to $regex on code" נכתבה ללא תנאי, אבל הפולבאק הזה מותנה
ב-not is_regex. בחיפוש REGEX שנכשל השורה טענה שני דברים שלא קרו: שהייתה
שאילתת $text, ושרץ פולבאק $regex.

ההודעה כבר לא מצהירה מה יקרה הלאה — היא אומרת רק מה נכשל.

2. ובאותו מסלול, ירידה שקטה לפולבאק השלישי
-------------------------------------------
כשתנאי ה-if שקר, הקוד נפל לפייפליין הישן בלי שום שורת לוג. זה בדיוק סוג
הנפילה שה-PR הזה בא לחסל, רק בענף שפספסתי. נוספה שורה למסלול הזה.

3. code נוסף לרשימה על סמך הערה שאין קוד שאוכף אותה
----------------------------------------------------
כתבתי ש-code "תמיד בצד השמאלי של $regex". זו הייתה טענה על הקוראים של
היום, לא אילוץ: RAW_QUERY_ALLOWED_OPERATORS מתיר לכל שדה גם $eq/$in/$all.
תנאי שוויון על code הוא דבר אחר לגמרי — הוא נושא את תוכן הקובץ, ושאילתה
כזו סבירה בעתיד (בדיקת כפילות תוכן). היא הייתה שומרת עד
PROFILER_UNREDACTED_MAX_BYTES של קוד מקור ב-slow_queries_log לשבוע,
מציגה אותו בדשבורד, ומכניסה אותו לטקסט "העתק דוח ל-AI".

נוסף RAW_QUERY_FIELD_OPERATORS: הגבלת אופרטורים לשדה מסוים, מעל הרשימה
הכללית. עבור code — {$regex, $options} בלבד, וערך שאינו מילון נדחה. ההערה
הפכה לאילוץ נאכף.

ושני טסטים שומרים תפסו את זה לבד
---------------------------------
- הטבלה ב-test_query_profiler_service נפלה על code, כי הדגימה שלה היא
  מחרוזת — כלומר בדיוק הצורה שההגבלה החדשה דוחה. השורה מתעדת עכשיו את
  ההתנהגות הנכונה.
- test_profiler_withheld_reasons_are_translated נפל על שתי הסיבות
  החדשות, כי הוא חולץ אותן מקוד המקור ודורש תרגום בתבנית. נוספו.

שניהם נכתבו בדיוק בשביל הרגע הזה.

אימות
-----
239 טסטים · flake8 זהה לבסיס · node --check תקין.

שלוש מוטציות, כל אחת מפילה בדיוק את שלה:
- השורה האמצעית חוזרת ל-pass ← טסט הירידה מ-$regex
- הסרת הלוג על המסלול שדולג ← טסט חיפוש ה-REGEX
- ריקון RAW_QUERY_FIELD_OPERATORS ← חמישה טסטים

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UBugD1DV8LhHBSGnvpAgzK
---
 services/query_profiler_service.py        | 36 ++++++++++++++---
 tests/test_profiler_raw_query_families.py | 45 +++++++++++++++++++++
 tests/test_query_profiler_service.py      |  9 +++--
 tests/test_search_fallback_is_logged.py   | 49 +++++++++++++++++++++--
 webapp/app.py                             | 17 +++++++-
 webapp/templates/profiler_dashboard.html  |  2 +
 6 files changed, 143 insertions(+), 15 deletions(-)

diff --git a/services/query_profiler_service.py b/services/query_profiler_service.py
index 1cb3243ae..dd7924c69 100644
--- a/services/query_profiler_service.py
+++ b/services/query_profiler_service.py
@@ -292,12 +292,27 @@ def _env_int(name: str, default: int) -> int:
     "description", "version", "created_at", "updated_at", "deleted_at",
     "deleted_expires_at", "file_size", "lines_count", "is_favorite", "favorited_at",
     "is_pinned", "pinned_at", "pin_order",
-    # ``code`` נושא את **דפוס החיפוש שהוקלד**, לא את תוכן הקובץ: בשאילתה הזו
-    # הוא תמיד בצד השמאלי של ``$regex``. תקרת ``PROFILER_UNREDACTED_MAX_BYTES``
-    # חוסמת דפוס חריג בגודלו.
+    # ``code`` — ראו ``RAW_QUERY_FIELD_OPERATORS``: הוא מותר **רק** כדפוס
+    # חיפוש, ולא כערך שוויון.
     "code",
 })
 
+#: הגבלת אופרטורים לשדה מסוים, מעל ``RAW_QUERY_ALLOWED_OPERATORS``.
+#:
+#: **למה זה נחוץ דווקא ל-``code``.** הוא נוסף לרשימה כי בשאילתת החיפוש הוא
+#: נושא את **דפוס החיפוש שהוקלד** — כלומר קלט של המשתמש עצמו, קצר. אבל
+#: רשימת האופרטורים הכללית מתירה לכל שדה גם ``$eq``/``$in``/``$all``, ותנאי
+#: שוויון על ``code`` הוא דבר אחר לגמרי: הוא נושא את **תוכן הקובץ**. שאילתה
+#: כזו סבירה לגמרי בעתיד (בדיקת כפילות תוכן, למשל), והיא הייתה שומרת עד
+#: ``PROFILER_UNREDACTED_MAX_BYTES`` של קוד מקור ב-``slow_queries_log`` לשבוע,
+#: מציגה אותו בדשבורד, ומכניסה אותו לטקסט "העתק דוח ל-AI".
+#:
+#: ההערה הקודמת כאן טענה ש-``code`` "תמיד בצד השמאלי של ``$regex``" — וזו
+#: הייתה טענה על הקוראים של היום, לא אילוץ. כאן היא הופכת לאילוץ נאכף.
+RAW_QUERY_FIELD_OPERATORS: Dict[str, FrozenSet[str]] = {
+    "code": frozenset({"$regex", "$options"}),
+}
+
 RAW_QUERY_LOGICAL_OPERATORS: FrozenSet[str] = frozenset({"$and", "$or", "$nor"})
 RAW_QUERY_TEXT_OPTIONS: FrozenSet[str] = frozenset(
     {"$search", "$language", "$caseSensitive", "$diacriticSensitive"}
@@ -713,13 +728,24 @@ def _asserted_owners(condition: Any) -> FrozenSet[str]:
     return frozenset(owners)
 
 
-def _check_field_value(value: Any) -> None:
+def _check_field_value(value: Any, field: Optional[str] = None) -> None:
+    """אופרטורים על ערך שדה. ``field`` נמסר כשיש לו הגבלה משלו.
+
+    שדה שמופיע ב-``RAW_QUERY_FIELD_OPERATORS`` חייב להגיע כמילון של
+    אופרטורים מתוך הרשימה הצרה שלו — ולא כערך שוויון ישיר. ראו שם למה.
+    """
+    restricted = RAW_QUERY_FIELD_OPERATORS.get(field) if field else None
     if not isinstance(value, dict):
+        if restricted is not None:
+            # ``{"code": "<תוכן הקובץ>"}`` — בדיוק מה שהרשימה הצרה מונעת.
+            raise _RawQueryWithheld(f"unsupported_field_value:{field}")
         return
     for op, inner in value.items():
         op = str(op)
         if op not in RAW_QUERY_ALLOWED_OPERATORS:
             raise _RawQueryWithheld(f"unknown_operator:{op}")
+        if restricted is not None and op not in restricted:
+            raise _RawQueryWithheld(f"unsupported_field_operator:{field}{op}")
         if op == "$elemMatch" and isinstance(inner, dict):
             if all(str(k).startswith("$") for k in inner):
                 _check_field_value(inner)
@@ -751,7 +777,7 @@ def _check_condition(condition: Any) -> None:
         else:
             if key not in RAW_QUERY_ALLOWED_FIELDS:
                 raise _RawQueryWithheld(f"unknown_field:{key}")
-            _check_field_value(value)
+            _check_field_value(value, key)
 
 
 def _stage_entries(pipeline: Any) -> List[Tuple[str, Any]]:
diff --git a/tests/test_profiler_raw_query_families.py b/tests/test_profiler_raw_query_families.py
index dd10f864f..2bc0fc026 100644
--- a/tests/test_profiler_raw_query_families.py
+++ b/tests/test_profiler_raw_query_families.py
@@ -173,3 +173,48 @@ def test_a_vector_search_is_still_withheld(self, svc):
         _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
 
         assert reason == "vector_query"
+
+
+class TestCodeIsAllowedOnlyAsASearchPattern:
+    """‏``code`` נכנס לרשימה כדפוס חיפוש — ורק ככזה.
+
+    זה נתפס בריוויו: רשימת האופרטורים הכללית מתירה לכל שדה גם ``$eq``,
+    ``$in`` ו-``$all``. ההערה שכתבתי טענה ש-``code`` "תמיד בצד השמאלי של
+    ``$regex``", אבל זו הייתה טענה על הקוראים של **היום** ולא אילוץ. תנאי
+    שוויון על ``code`` הוא דבר אחר לגמרי — הוא נושא את **תוכן הקובץ**.
+    """
+
+    def test_an_equality_on_code_is_withheld(self, svc):
+        """‏``{"code": "<תוכן הקובץ>"}`` — הצורה שהייתה שומרת קוד מקור.
+
+        בלי ההגבלה, עד ``PROFILER_UNREDACTED_MAX_BYTES`` של קוד היו נשמרים
+        ב-``slow_queries_log`` לשבוע, מוצגים בדשבורד, ונכנסים לטקסט
+        "העתק דוח ל-AI".
+        """
+        pipeline = [{"$match": {"user_id": ME, "code": "def secret():\n    return 1"}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == "unsupported_field_value:code"
+
+    @pytest.mark.parametrize("operator", ["$eq", "$in", "$all", "$ne"])
+    def test_other_operators_on_code_are_withheld(self, svc, operator):
+        pipeline = [{"$match": {"user_id": ME, "code": {operator: "def secret(): ..."}}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason == f"unsupported_field_operator:code{operator}"
+
+    def test_the_search_pattern_itself_still_passes(self, svc):
+        """ההגבלה לא סוגרת את מה שהיא נועדה לאפשר."""
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": SEARCH_REGEX_PIPELINE})
+
+        assert reason is None
+
+    def test_the_restriction_applies_only_to_code(self, svc):
+        """שדה אחר ממשיך לקבל את מלוא רשימת האופרטורים."""
+        pipeline = [{"$match": {"user_id": ME, "file_name": {"$in": ["app.py", "main.py"]}}}]
+
+        _raw, _owner, reason = _decide(svc, "aggregate", {"pipeline": pipeline})
+
+        assert reason is None
diff --git a/tests/test_query_profiler_service.py b/tests/test_query_profiler_service.py
index 3adf17bb6..4d281b81e 100644
--- a/tests/test_query_profiler_service.py
+++ b/tests/test_query_profiler_service.py
@@ -830,11 +830,12 @@ def test_nin_never_asserts_ownership(self, raw_values_service):
     "is_pinned": (False, None),
     "pinned_at": (datetime(2026, 9, 6), None),
     "pin_order": (1, None),
-    # ``code`` מופיע בשאילתות **כדפוס חיפוש**, לא כתוכן קובץ — תמיד בצד
-    # השמאלי של ``$regex``. הדגימה כאן היא מחרוזת פשוטה בכוונה: הטסט הזה בודק
-    # את הסיבוב של הערך, וצורת ה-``$regex`` המלאה נבדקת ב-
+    # ``code`` הוא היחיד ברשימה שיש לו הגבלת אופרטורים משלו
+    # (``RAW_QUERY_FIELD_OPERATORS``): הוא מותר **רק** כדפוס חיפוש. ערך
+    # שוויון עליו נושא את תוכן הקובץ, ולכן הוא נדחה — וזו ההתנהגות שהשורה
+    # הזו מתעדת. צורת ה-``$regex`` שכן עוברת נבדקת ב-
     # ``test_profiler_raw_query_families.py`` על השאילתה האמיתית.
-    "code": ("סטיקי", None),
+    "code": ("סטיקי", "unsupported_field_value:code"),
 }
 
 
diff --git a/tests/test_search_fallback_is_logged.py b/tests/test_search_fallback_is_logged.py
index 54f9a2a76..dca91e2be 100644
--- a/tests/test_search_fallback_is_logged.py
+++ b/tests/test_search_fallback_is_logged.py
@@ -54,10 +54,12 @@ def app_module(monkeypatch):
     return webapp_app
 
 
-def _run(app_module, monkeypatch, fail_times):
+def _run(app_module, monkeypatch, fail_times, search_type=None):
     collection = _RaisingCollection(fail_times)
     monkeypatch.setattr(app_module, "get_db", lambda: _FakeDB(collection), raising=True)
-    results = app_module._safe_search(6865105071, "סטיקי", limit=50)
+    results = app_module._safe_search(
+        6865105071, "סטיקי", limit=50, search_type=search_type
+    )
     return results, collection
 
 
@@ -67,7 +69,7 @@ def test_a_failing_text_pipeline_is_logged(app_module, monkeypatch, caplog):
         _results, collection = _run(app_module, monkeypatch, fail_times=1)
 
     assert collection.calls >= 2, "הפולבאק לא רץ, אז אין מה לבדוק"
-    assert any("$text" in r.getMessage() for r in caplog.records), (
+    assert any("primary aggregation pipeline failed" in r.getMessage() for r in caplog.records), (
         f"אין שורת לוג על כשל המסלול המהיר: {[r.getMessage() for r in caplog.records]}"
     )
 
@@ -81,7 +83,7 @@ def test_the_failure_carries_the_exception_itself(app_module, monkeypatch, caplo
     with caplog.at_level(logging.WARNING):
         _run(app_module, monkeypatch, fail_times=1)
 
-    failed = [r for r in caplog.records if "$text" in r.getMessage()]
+    failed = [r for r in caplog.records if "primary aggregation" in r.getMessage()]
     assert failed and failed[0].exc_info is not None, "השורה אינה נושאת את החריגה"
 
 
@@ -98,3 +100,42 @@ def test_falling_all_the_way_down_is_logged_too(app_module, monkeypatch, caplog)
     assert any("no results" in m for m in messages), (
         f"חיפוש שנשבר לגמרי חזר שקט: {messages}"
     )
+
+
+def test_the_second_fallback_failure_is_logged_too(app_module, monkeypatch, caplog):
+    """‏**הפער שריוויו תפס.**
+
+    אף אסרשן לא בדק את שורת הלוג האמצעית, ולכן מוטציה שמחזירה שם ``pass``
+    הייתה משאירה את כל הטסטים ירוקים — כלומר אחד משלושת ה-``except``
+    שהשינוי הזה מתקן היה מוגן ברשת שאינה מסוגלת ליפול.
+    """
+    with caplog.at_level(logging.WARNING):
+        _run(app_module, monkeypatch, fail_times=99)
+
+    messages = [r.getMessage() for r in caplog.records]
+    assert any("$regex pipeline failed" in m for m in messages), (
+        f"הירידה מ-$regex לפייפליין הישן לא נרשמה: {messages}"
+    )
+
+
+def test_a_regex_search_does_not_claim_a_text_fallback(app_module, monkeypatch, caplog):
+    """‏**הודעה שאינה יכולה לשקר.**
+
+    מסלול ה-``$regex`` מותנה ב-``not is_regex``. הגרסה הראשונה של השורה
+    הזו הכריזה ללא תנאי "falling back to $regex on code", ולכן בחיפוש
+    REGEX שנכשל היא טענה שני דברים שלא קרו: שהייתה שאילתת ``$text``,
+    ושרץ פולבאק ``$regex``.
+
+    ובאותו מסלול בדיוק הקוד נפל ל**פולבאק השלישי בלי שום שורת לוג** — סוג
+    הנפילה השקטה שהשינוי הזה בא לחסל, רק בענף אחר.
+    """
+    with caplog.at_level(logging.WARNING):
+        _run(app_module, monkeypatch, fail_times=1, search_type="regex")
+
+    messages = [r.getMessage() for r in caplog.records]
+    assert not any("$text" in m for m in messages), (
+        f"הלוג מזכיר $text בחיפוש שלא בנה $text: {messages}"
+    )
+    assert any("not applicable" in m for m in messages), (
+        f"הירידה לפייפליין הישן הייתה שקטה: {messages}"
+    )
diff --git a/webapp/app.py b/webapp/app.py
index d9a0381ca..352e2f419 100644
--- a/webapp/app.py
+++ b/webapp/app.py
@@ -9556,10 +9556,15 @@ def _safe_search(user_id: int, query: str, **kwargs):
         # ונפסל**: ‏``search_text_idx`` קיים, ואותה שאילתת ``$text`` בדיוק רצה
         # מול הקלאסטר ומחזירה תוצאות. הסיבה האמיתית הייתה בלתי נראית, וזה מה
         # שהשורה הבאה מתקנת.
+        #
+        # ⚠️ ההודעה **אינה** מצהירה מה יקרה הלאה. מסלול ה-``$regex`` שמתחתיה
+        # מותנה ב-``not is_regex``, ולכן בחיפוש REGEX שנכשל הודעה כזו הייתה
+        # אומרת שני דברים שלא קרו. שורת לוג ששקרית באותה מידה שהיא מועילה
+        # היא בדיוק מה שהחלפנו כאן.
         logger.warning(
-            "search fallback: $text pipeline failed, falling back to $regex on code",
+            "search fallback: primary aggregation pipeline failed",
             exc_info=True,
-            extra={"event": "search_text_pipeline_failed", "is_regex": is_regex},
+            extra={"event": "search_primary_pipeline_failed", "is_regex": is_regex},
         )
         try:
             if (not is_regex) and isinstance(match_stage, dict) and ('$text' in match_stage):
@@ -9594,6 +9599,14 @@ def _safe_search(user_id: int, query: str, **kwargs):
                         lines_count=int(doc.get('lines_count') or 0),
                     ))
                 return results2
+            # ⚠️ הגענו לכאן בלי חריגה, כלומר תנאי ה-``if`` היה שקר: או שזה
+            # חיפוש REGEX (ואז אין ``$text`` להחליף), או שהפייפליין לא נבנה
+            # כצפוי. בלי השורה הזו זו הייתה ירידה **שקטה** לפולבאק השלישי —
+            # בדיוק סוג הנפילה שהשינוי הזה בא לחסל, רק במסלול אחר.
+            logger.warning(
+                "search fallback: $regex path not applicable, going to the legacy pipeline",
+                extra={"event": "search_regex_path_skipped", "is_regex": is_regex},
+            )
         except Exception:
             # אותו נימוק בדיוק: כשל כאן מוביל לפולבאק **שלישי**, ובלי שורה
             # אחת בלוג אין שום דרך לדעת שירדנו עוד מדרגה.
diff --git a/webapp/templates/profiler_dashboard.html b/webapp/templates/profiler_dashboard.html
index 048d91954..1bb3d00cf 100644
--- a/webapp/templates/profiler_dashboard.html
+++ b/webapp/templates/profiler_dashboard.html
@@ -566,6 +566,8 @@ <h2 class="section-title">💡 המלצות אופטימיזציה</h2>
     unknown_stage: 'שלב לא מוכר',
     unsupported_type: 'טיפוס שאינו ניתן להרצה חוזרת',
     malformed_stage: 'ערך מבני לא תקין בשלב',
+    unsupported_field_value: 'שדה שמותר רק כדפוס חיפוש, והגיע כערך',
+    unsupported_field_operator: 'אופרטור שאינו מותר לשדה',
   };
 
   function describeWithheldReason(reason) {