What’s New

2026-11-15

  • feat (WebApp, MCP, docs): הלוחות ממוינים לפי הא«-ב« — לוח ברירת המחדל ראשון, אחריו הלוחות בעברית ואחריהם באנגלית לפי ABC. עד היום עמוד /boards הציג את הלוחות לפי סדר היצירה, מהישן לחדש, ולוח חדש תמיד נוסף בסוף. אחרי: לוח ברירת המחדל נשאר ראשון; אחריו הלוחות שהאות הראשונה בשם שלהם עברית, לפי הא«-ב«; ואחריהם כל השאר לפי ABC, בלי הבדל בין אותיות גדולות לקטנות. האות הראשונה היא שקובעת, לא התו הראשון, ולכן אימוג’י או ספרה בהתחלה לא נספרים, ושם כמו מCLAUDE.md נמצא עם הלוחות בעברית. אות סופית נחשבת כמו הרגילה, וניקוד ואקסנטים לא נחשבים. המיון נעשה בשרת, ב-_board_sort_key (note_boards.py), שממנו מקבלים את הסדר גם החלונות בתוך לוח וגם הכלי codekeeper_list_boards. הסדר המלא — בשורה ”סדר הלוחות“ בסעיף ”לוחות פתקים“ ב-פתקים דביקים (Sticky Notes).

  • fix (WebApp, docs): ערך פגום בסדר היצירה של לוח כבר לא מפיל את רשימת הלוחות, את ייצוא הלוחות בגיבוי ואת השחזור. השדה order נכתב תמיד כמספר שלם, אבל ערך אחר יכול להגיע מעריכה ביד במסד, ו-int זורק עליו. לפני: מסמך לוח אחד כזה הפיל את /api/note-boards (500, ועמוד /boards בלי אף לוח); אינסוף בשדה רוקן את ייצוא הלוחות בגיבוי, ובשחזור עצר את איסוף הלוחות הקיימים, ולוח שכבר היה בחשבון שוחזר שוב. אחרי: כל מי שקורא את השדה ממסמך במסד עובר דרך board_order (note_boards.py), שמחזיר 0 על ערך כזה, ו-_safe_int של שירות הגיבוי, שלא תפס אינסוף, יצא.

  • feat (MCP, WebApp, docs): הפתק בתצוגה בתוך Claude מרונדר עם Markdown מלא — אותו מנוע ואותו עיצוב כמו בפתק בלוח, וקישורים שנפתחים דרך Claude. עד עכשיו הגוף הוצג כטקסט, שורה לכל שורת מקור. אחרי: כותרות, הדגשות, קוד, מרקר, ציטוטים, רשימות ומשימות, בלוקי קוד, טבלאות, אלרטים ובלוקים מתקפלים נראים כמו בפתק בלוח, כי זה אותו קוד: שרת ה-MCP מכניס לדף את sticky-md-render.js במצב קריאה בלבד ואת sticky-md-render.css ו-markdown-enhanced.css כמו שהם. בדיקה בדפדפן משווה את הסגנון המחושב של כל אלמנט לפתק בלוח, גם בערכה הכהה של Claude וגם בהגדלת טקסט של אנדרואיד. קישורים: כש-Claude מציע לפתוח קישורים (openLinks), לחיצה מבקשת ממנו לפתוח את הכתובת (ui/open-link), ובקונקטור מותאם הוא שואל קודם. אחרת הקישור אינו עושה דבר, והכתובת מופיעה בריחוף. בלוק מתקפל ארוך שנפתח מביא את ▲▼. הגדלת טקסט באנדרואיד: הפיצוי עבר ל-text-size-adjust, כך שגם הריווחים של ה-Markdown נשארים של הוובאפ, ו-WebView ישן שמתעלם מהתכונה מקבל את החלוקה של הגופנים כמו קודם. בוובאפ לא השתנה דבר: ל-sticky-md-render.css נוסף הבסיס שהכללים שלו נשענו עליו מ-base.html (בלי שוליים וריפוד של הדפדפן, ו-border-box), בספציפיות אפס. כל תבנית שטוענת את הקובץ יורשת מ-base.html, שבו אותו כלל באותם ערכים ובאותה ספציפיות, ובלוח הסגנון המחושב של פתקים נמדד זהה לפני ואחרי. ראו תצוגה בתוך Claude — MCP App.

  • refactor (WebApp, docs): העיצוב של ה-Markdown בפתק בקובץ משלו —sticky-md-render.css— הזוג של המנוע, משותף לכל מי שמרנדר פתק. העיצוב של מה שהמנוע בונה ישב בתוך sticky-notes.css, לצד השלד של הפתק בלוח. משטח אחר שמרנדר Markdown של פתק, כמו התצוגה של פתק בתוך Claude, היה צריך עותק משלו של כללים שחייבים להישאר זהים. אחרי: הכללים והטוקנים שהתוכן קורא, כולל הדיו של הפתק, הועברו כמו שהם, בסקריפט, לקובץ שנטען צמוד לפני sticky-notes.css בכל תבנית. בפתק לא השתנה דבר: הסגנון המחושב של כל אלמנט, בכל התכונות, נמדד בכרומיום לפני ההעברה ואחריה. המדידה כיסתה כל סוגי ה-Markdown, צבעי נייר, ערכות, גדלי גופן ורוחבי מסך, והוא זהה. הפרטים ב-העיצוב כקובץ משותף: sticky-md-render.css.

  • feat (WebApp, docs): ווי דריסה לערכה מיובאת בהירה — ”שולחן עבודה“, הכפתורים שמעל העורך, וסרגל החיפוש ומלבני הפרטים בתצוגת הקוד. בערכה מיובאת בהירה כמו Pen Paper Coffee הרכיבים האלה כמעט לא נראו: הכפתורים שמעל העורך (”עורך פשוט“, ”בטל“, ”בצע שוב“, ”בחר הכל“, ”העתק“, ”הדבק“ ו-MD) צבועים בטקסט לבן על רקע לבן שקוף, ובתצוגת הקוד הסרגל של שורת החיפוש, ”מסך מלא“ והמלבנים של גודל, שורות, נוצר ועודכן צבועים בלבן שקוף שנבלע ברקע. ”שולחן עבודה“ בעמוד הקבצים צבוע במעבר צבע שמסתיים ב---secondary, שהמייבא אינו לוקח מקובץ VS Code, ולכן בערכה מיובאת הוא נגמר בסגול הקבוע של האתר. אחרי: ווים חדשים ברשימה הלבנה (ALLOWED_VARIABLES_WHITELIST), וערכה מצהירה עליהם בבלוק variables שלה; --md-search-capsule-border-override צובע עכשיו גם את הגבול של שורת החיפוש בתצוגת הקוד, כי זה אותו רכיב בשני עותקים. כל וו נקרא בכלל שצובע היום את הרכיב, עם fallback לערך שנצבע בו (tests/services/test_theme_variables_light_import_hooks.py נועל את זה). במדידה בדפדפן ב-15.11.2026, מול הקוד שלפני השינוי — Classic, Dark, Rose Pine Dawn, High Contrast, ערכה מיובאת כהה, ערכה מיובאת בהירה בלי ווים, ותצוגה מקדימה של Ocean מתוך ערכה שמצהירה — הרכיבים זהים למה שהיו, במצב רגיל, בריחוף ובפוקוס. ל“שולחן עבודה“ המסגרת היא box-shadow דרך משתנה ביניים בלי fallback, כי גבול היה מגדיל את הכפתור בכל ערכה. הפירוט: ערכה מיובאת בהירה: שדות טופס, הדשבורד, שורת החיפוש, הכפתורים שמעל העורך ותצוגת הקוד. ערכה שכבר קיימת בחשבון מקבלת את הווים רק אחרי ייבוא מחדש.

  • fix (MCP, docs): הפתק בתצוגה בתוך Claude באותו גודל טקסט כמו בוובאפ גם כשאנדרואיד מגדיל טקסט, ושורה שמתחילה באנגלית מיושרת לימין כמו בפתק. נמצא בבדיקה באפליקציה בטאבלט. הגודל: WebView של אנדרואיד מגדיל כל גופן לפי גודל הגופן שנבחר במערכת, בזמן שהגובה הקבוע של התצוגה אינו גדל, ולכן נכנסו פחות שורות והטקסט נראה גדול מהפתק בוובאפ. אחרי: התצוגה מודדת בכמה המערכת מגדילה טקסט ומבטלת את ההגדלה, כך שהגוף, הכותרת והכפתורים בגודל של הוובאפ. בדסקטופ ובווב, בלי הגדלה, לא השתנה כלום. הכיוון: כל שורה בתצוגה הכריעה כיוון לפי התו הראשון שלה, ושורה שמתחילה במילה באנגלית הוצגה משמאל. בוובאפ כל השורות בפתק בכיוון ימין-לשמאל, ורק קוד בשורה ותאי טבלה מכריעים לפי התוכן. אחרי: כמו בוובאפ. הפרטים ב-תצוגה בתוך Claude — MCP App.

  • fix (MCP, docs): פתק ארוך בתצוגה בתוך Claude כבר לא נחתך — התצוגה בגובה קבוע, והגוף נגלל בתוכה; ושטח ריק מתחת לפתק אחרי פתיחה מחדש של האפליקציה נעלם. נמצא בבדיקה ב-claude.ai אחרי הדיפלוי. פתק ארוך: התצוגה ביקשה את כל הגובה שלה, Claude חתך אותה בתקרה שלו, ולא הייתה שום דרך לגלול לשאר. במכשיר מגע גם אי אפשר לגלול בתוך תצוגה בשיחה, כי גרירה אנכית שמתחילה בתוכה גוללת את השיחה. אחרי: התצוגה בגובה של פתק חדש בוובאפ, או בתקרה של Claude אם היא נמוכה יותר, ופתק קצר מתקצר עד השורה האחרונה שלו. הגוף נגלל בגלגלת, ובכפתורים ▲▼ שמופיעים רק כשהפתק ארוך מהגובה. כל לחיצה מזיזה שלושה רבעים מהגובה הגלוי, ברכות, כדי שהשורות האחרונות שנקראו יישארו על המסך. כשהמארח מציע מסך מלא, יש גם כפתור ”מסך מלא“, ושם הפתק ממלא את המסך. השטח הריק: אחרי סגירה ופתיחה של האפליקציה נשאר רווח בין סוף הפתק להודעה הבאה, שנעלם רק כשהתצוגה נפתחה מחדש. המארח הציב למסגרת גובה ישן, והתצוגה לא דיווחה שוב, כי היא דיווחה רק כשהתוכן שלה השתנה. עכשיו היא מדווחת את הגובה שלה גם בכל שינוי של המסגרת. ותיקון בתיעוד: נכתב שמסך מלא אינו זמין במובייל. שני עמודים של Claude אינם מסכימים על כך, ולכן הכפתור מופיע רק כשהמארח עצמו מציע מסך מלא. הפרטים ב-תצוגה בתוך Claude — MCP App.

  • refactor (WebApp, docs): מנוע התצוגה של הפתק בקובץ משלו — sticky-md-render.js — משותף לפתק ולתצוגה לקריאה בלבד. הפרסר ובניית התצוגה ישבו בתוך המחלקה של הפתק, קשורים לעריכה, ותצוגה של פתק במקום אחר הייתה צריכה עותק משלה. אחרי: StickyMdEngine ב-webapp/static/js/sticky-md-render.js, שמוצמד למחלקה של הפתק (mixInto) ולכן הפתק מתנהג בדיוק כמו קודם — אותו HTML לאותו טקסט, נמדד בכרומיום מול הקוד שלפני — ולצידו StickyMdRender.render, תצוגה לקריאה בלבד בלי היסטים, עם צ’קבוקס מושבת ובלי כפתור העתקה. כל תבנית שמארחת פתקים טוענת את הקובץ לפני sticky-notes.js. ראו המנוע כקובץ משותף: sticky-md-render.js.

  • feat (MCP, docs): פתק שנפתח בתוך Claude — הכלי codekeeper_show_note מציג פתק בתוך השיחה, עם הכותרת והצבע שלו. עד היום שרת ה-MCP יכול היה להחזיר לסוכן רק טקסט, ולכן כדי לראות פתק שהסוכן עדכן היה צריך לעבור ללשונית של הוובאפ. אחרי: במארח שמציג MCP Apps (claude.ai, Claude Desktop, והאפליקציות לנייד בתצוגה שבתוך השיחה) הפתק מוצג כנייר בצבע שלו, בגודל הטקסט של ברירת המחדל בוובאפ (”גדול מאוד“), וכל שורה בכיוון שלה. בינתיים הגוף מוצג כטקסט, בלי Markdown — החילוץ של מנוע ה-Markdown של הפתק הוא השלב הבא. אותו שער של codekeeper_get_note, ולקוח שאינו מציג תצוגה מקבל את הפתק המלא כטקסט. נבנה על mcp 1.28.1 בלי ספרייה חדשה, והכתובת של הדף נושאת את הגרסה שלו, כך שמארח ששומר אותו בקאש לא מגיש דף ישן אחרי דיפלוי. ראו תצוגה בתוך Claude — MCP App.

  • feat (WebApp, docs): בעמוד מדיניות הפרטיות יש סעיף על המחבר ל-AI, לקראת ההגשה לספריית המחברים של Anthropic. הטופס של הספרייה דורש כתובת של מדיניות פרטיות שמסבירה מה נאסף, איך משתמשים בזה, עם מי משתפים וכמה זמן שומרים, ועד היום /privacy דיבר רק על Google Drive. אחרי: סעיף חדש עם העוגן mcp: איך מתחברים ומה מותר, מה המחבר מקבל (כולל המשפט working_on שהסוכן כותב בתגובה על פתק), מה נשמר (רק hash של כל טוקן, שעה לטוקן גישה ו-30 יום לטוקן רענון, העלאה עד 10 דקות), מה נשלח ל-PostHog ומה לא, לוגים והתראות, שיתוף, וניתוק ומחיקה. הטסטים ב-tests/test_privacy_page.py מצמידים לקוד את משכי הזמן, את שמירת ה-hash ואינדקס ה-TTL, את האופציות ש-PostHog מקבל, את working_on ואת היעדר כלי המחיקה. הלוגים, השיתוף והניתוק כתובים בלי טסט, והסיבה לכל אחד ב-מדיניות הפרטיות של המחבר (/privacy#mcp).

  • fix (MCP): כשל ביצירת אינדקס אחד של OAuth כבר לא מדלג על אינדקסי ה-TTL של הטוקנים. OAuthStore._ensure_indexes החזיק את כל שמונה הקריאות ל-create_index ב-try אחד, ולכן כשל באחת מהן (למשל אינדקס unique שכפילויות חוסמות) דילג על כל מה שאחריה, כולל אינדקסי ה-TTL על expires_at — המנגנון שמאחורי ”Expired token records are deleted automatically“ במדיניות הפרטיות. והכשל נרשם כ-WARNING אחד לכולם. אחרי: כל אינדקס נוצר לבד, וכשל של unique או של TTL נרשם כ-ERROR, עם האוסף, המפתח והאפשרויות (oauth_index_failed). אינדקס הביצועים היחיד נרשם כ-WARNING. כשהמסד לא עונה (ConnectionFailure), הלולאה עוצרת אחרי הניסיון הראשון ורושמת שורת ERROR אחת עם כל האינדקסים שלא נוסו — אחרת העלייה הייתה מחכה את ה-timeout של בחירת השרת פעם אחת לכל אינדקס. רק PyMongoError נתפס, וחריגה אחרת עולה. ראו מדיניות הפרטיות של המחבר (/privacy#mcp).

  • change (משפיע על לקוחות MCP): לכידת הכוונה כובתה, והפרמטר context יצא מהסכימה של כל הכלים. עד היום כל כלי ביקש מהסוכן משפט על מה הקריאה באה לעשות, והמשפט נשלח ל-PostHog. מדיניות הספרייה של Anthropic אוסרת לאסוף נתוני שיחה שאינם נחוצים, ”even for logging purposes“. אחרי: instrument_mcp_server מעביר context=False במפורש, כי ברירת המחדל של ה-SDK היא True. לקוח ששמר את רשימת הכלים הישנה ועדיין שולח context לא נדחה, והמשפט שלו לא נשלח. המשפט היחיד שעוד נשלח הוא הדיווח של get_more_tools, שבו המשפט הוא הדיווח עצמו, ולכן טאב היכולות שסוכנים ביקשו ב-/admin/mcp ממשיך לעבוד. טור הכוונה בטבלת הסשנים כבר לא מקבל משפט מקריאת כלי רגילה. ראו לכידת הכוונה (context) — כבויה.

  • fix (CI, WebApp, docs): אינדקס החיפוש בתיעוד שלא התעדכן אחרי פריסה של האתר — בקשת המעבר נשלחת שוב, ואם זה לא עוזר מגיעה התראה לטלגרם. ה-webhook של הפריסה נשלח פעם אחת, ומיזוג ל-main פורס גם את האתר וגם את הוובאפ בהפרש של דקות. ב-13.11.2026 ה-webhook של 87fa366 הגיע בזמן שהוובאפ עלה מחדש והלך לאיבוד, והאינדקס נשאר מאחור שעתיים, עד ”בדוק עכשיו“ ידני. לא נשלחה שום התראה: כל ההתראות של האינדקס נשלחות מתוך מעבר, ומעבר שלא רץ לא מדווח. ההתראה היחידה ב-CI הייתה על כשל של ייצוא הסעיפים, והוא לא נכשל. אחרי: ג’וב חדש ב-documentation.yml (check-docs-index) רץ אחרי הפריסה ומריץ את scripts/docs_index_check.py, שממתין שהאינדקס יגיע לקומיט שנפרס. כשאין מעבר חי הוא שולח שוב את בקשת המעבר. הוא מתריע לטלגרם, דרך הסודות של ה-CI, כשמעבר עצר לאישור, כשהניסיונות נגמרו, או כשהזמן עבר, וההודעה כוללת את הסטטוס והקוד של המעבר האחרון. הוא פונה לשני נתיבים חדשים בוובאפ, חתומים כמו ה-webhook של GitHub: /api/webhooks/docs-index/status ו-/api/webhooks/docs-index/pass. צריך להגדיר ב-GitHub את המשתנה WEBAPP_URL ואת הסוד CODEBOT_WEBHOOK_SECRET (אינדקס התיעוד).

2026-11-14

  • fix (WebApp, docs): פתק חדש שנוצר ממקום אחר מופיע מעל כל הפתקים, ולא מתחת לפתקים שנגעו בהם. פתק שסוכן יצר דרך ה-MCP הגיע ללוח בעדכון בזמן אמת בשכבת הבסיס, ולכן נכנס מתחת לפתק שנגעו בו באותו מקום — ורק אחרי רענון עלה. אחרי: פתק חדש מהשרת עובר באותו מסלול של פתק שנוצר כאן (_addNewNote), ועולה מעל השאר; פתק קיים שהתעדכן נשאר בשכבה שלו. ראו עדכון בזמן אמת: הבסיס, הפיוס, ו-409 שאינו דורס.

  • fix (WebApp, docs): טקסט שהקלדתם בפתק שעדכון מחכה בו להחלטה שורד סגירה ופתיחה מחדש של הלשונית. עדכון מהשרת בזמן עריכה, הקלדה, סגירת הלשונית ופתיחה מחדש — מה שהוקלד נעלם, והגרסה מהשרת נטענה בלי בחירה. השמירה לשרת מוחזקת כשבחירה ממתינה, והטיוטה נכתבה לדפדפן רק בפירוק המנהל; בסגירת לשונית ההגנה היחידה הייתה שאלת beforeunload, שדפדפן בטאבלט אינו מציג. אחרי: כל עוד הבחירה ממתינה הטיוטה נשמרת בדפדפן (_syncHeldDraft: כשההתראה מופיעה, בכל עריכה, וכשהלשונית מוסתרת), ובפתיחה הבאה של העמוד הפתק מוצג עם הטקסט וההתראה. הבחירה מוחקת את הטיוטה. הטיוטה נבדקת מול מה שהשרת מחזיק ולא מול הקאש של הפתקים, שישן ממנו: בטעינה מהקאש היא מוצגת מיד והשמירות מוחזקות, והקריאה הטרייה הראשונה מכריעה. לכל טיוטה מפתח משלה, כך שלשונית שבה הפתק נקי אינה מוחקת טיוטה של לשונית שבה הוקלד; ואחסון חסום אינו עוצר את השמירה בהסתרת הלשונית. ראו עדכון בזמן אמת: הבסיס, הפיוס, ו-409 שאינו דורס.

  • feat (WebApp, docs): ערכת מסמך — ערכה מיובאת שחלה רק על תצוגת ה-Markdown, והממשק נשאר בערכה הפעילה. ערכה כמו Pen Paper Coffee נראית מצוין במסמך ופחות בממשק, והדרך היחידה להשתמש בה הייתה להחיל אותה על הכל. אחרי: בגלריית הערכות, בלשונית ”ייבוא“, בוחרים ערכה אישית או ציבורית לתצוגת המסמך — או מסמנים ”רק על תצוגת המסמך“ בייבוא, או עוברים ל“ערכת מסמך“ במודאל ערכות הנושא שבתפריט קיצורי הדרך, ולוחצים על ערכה או על ”ללא ערכת מסמך“ — והכרטיס ”תצוגת Markdown“ ב-/md/<id> נראה בדיוק כמו כשהיא ערכת הממשק, כולל הדגשת התחביר, בזמן שהממשק סביבו נשאר בערכה הפעילה. פועל כשערכת הממשק מותאמת או ציבורית; לכל המכשירים או רק במכשיר הזה; כיבוי ב“ללא ערכת מסמך“. הבחירה ב-ui_prefs.md_doc_theme, והיא נכנסת ל-ETag של העמוד. בלי ערכת מסמך העמודים זהים למה שהיו — נמדד בדפדפן מול הקומיט הקודם בעמוד המסמך, בעמוד הקבצים ובלוח פתקים, בכל הערכות המובנות ובערכה מיובאת כהה, בהירה וציבורית. ראו ערכת מסמך: ערכה שחלה רק על תצוגת ה-Markdown.

  • fix (WebApp, docs): שמירה של פתק על גרסה ישנה כבר לא דורסת את מה שהשתנה בינתיים. סוכן עדכן פתק דרך ה-MCP, המשתמש נכנס לעריכה בלי לרענן, והשמירה האוטומטית כתבה את הגרסה שבמסך מעל העדכון. השרת דווקא דחה את השמירה (409 על prev_updated_at ישן), אבל הלקוח שלח אותה שוב עם האסימון מהתשובה — _sendUpdate מיד, והמסלול המרוכז בשמירה הבאה. אחרי: 409 חוזר לתור ומוחזק, הפתק נמשך מהשרת, והכרעה אחת (_resolveSaveConflict) מחליטה: שמירה שלנו שהתשובה עליה אבדה מיישרת את האסימון, ושינוי ממקום אחר בשדה שהמשתמש שינה מעלה את ההתראה ”יש עדכון חדש לפתק“ ושום דבר לא נכתב. האסימון נשלח עם השמירה ברגע השליחה ולא נשמר בתור, והשרת קובע את updated_at ברזולוציה שהמסד שומר (_stored_now), כך שתשובת הכתיבה נותנת את אותה מחרוזת שהמסד יחזיר — גם בתשובת היצירה — ובפורמט אחד בכל תשובה (_updated_at_iso). ועוד שלושה מסלולים שהיו יכולים לדרוס: שמירה אחת בכל רגע לכל פתק — שתי שמירות באוויר שהשרת עיבד בסדר הפוך החזירו את הישנה מעל החדשה; שליחה אחת כשהלשונית מוסתרת — אותו מטען יצא פעמיים, ואחד מהם קיבל 409 והציג התראה על הטקסט של המשתמש עצמו; ו**פתק לא יורד מהמסך עם החלטה פתוחה או עם שמירה שנכשלה או נדחתה** — סגירה של פתק מעל עמוד, העברה לארכיון והסרה מעמוד הקבצים נעצרות עם הסבר, כי מטען שנשאר בתור אחרי שהפתק ירד יצא בלי אסימון ודרס את העדכון. וסגירת הלשונית שואלת גם כשעריכה מחכה מאחורי שמירה שבאוויר. ראו עדכון בזמן אמת: הבסיס, הפיוס, ו-409 שאינו דורס.

  • feat (WebApp, docs): פתק שהשתנה ממקום אחר מתעדכן במסך בלי רענון, וכניסה לעריכה מביאה את הגרסה האחרונה. אחרי: התוכן, השם והצבע מתעדכנים לבד — בלוח, בפתקים על קובץ Markdown, בדפדפן הריפו, ובפתק שנפתח מעל הארכיון או עמוד הקבצים — בבדיקה כל כמה שניות כשהלשונית גלויה, ומיד בחזרה אליה. פתק חדש מופיע בשלושת המשטחים הראשונים; מעל הארכיון ועמוד הקבצים נבדק רק הפתק הפתוח. פתק שנמחק או עזב יורד, אחרי בדיקה ישירה שלו — חוץ מפתק שהמשתמש באמצע עבודה עליו, שנשאר, ומשטח שכל הפתקים בו נמחקו בבת אחת, שמתיישר רק ברענון. בכניסה לעריכה הפתק נבדק מול השרת, ואם עוד לא הוקלד כלום התוכן מתחלף והסמן נשאר על אותו טקסט. פתק בעריכה, או עם שינוי שלא נשמר, אינו מוחלף: מופיעה בו ההתראה עם ”עדכן“ (טקסט שהוקלד נשמר כצעד ביטול אחד; שם — לא) ו“התעלם“ (הגרסה שבמסך נשמרת מעל העדכון), יציאה מעריכה בלי שינוי טוענת את העדכון, וסגירת הלשונית עם שינוי מוחזק מבקשת אישור. בדפדפן הריפו, מעבר קובץ עם טקסט שהשרת לא אישר שומר אותו בדפדפן, והוא חוזר כשהפתק מוצג שוב — עם ההתראה, כשהפתק השתנה בינתיים. השוואה בין התיבה לשרת מנרמלת שורות חדשות (asTextareaValue), כך שפתק שסוכן כתב ב-\r\n אינו נראה ”משונה“. תשובה של קריאה שיצאה לפני מה שבמסך נזרקת (_nextReadSeq), כך שעדכון ישן אינו מוחל מעל חדש. תוכן מהשרת מתחיל את הביטול מחדש. השרת מוסיף ?versions=1 לרשימות של לוח, קובץ וריפו (מזהה, אסימון וצבע, בלי הגוף) ו-GET /api/sticky-notes/note/<id>. מנגנון הדגימה של בועת התזכורות עבר ל-utils/visible-poll.js (VisiblePoll), והפתקים דוגמים באותו מנגנון. מיקום, גודל ומיזעור אינם מתעדכנים בזמן אמת. התיאור למשתמש: פתק שהשתנה ממקום אחר; הנימוק: עדכון בזמן אמת: הבסיס, הפיוס, ו-409 שאינו דורס, ההתראה ”יש עדכון חדש לפתק“: פריט flex, הדיו של הפתק, והפוקוס נשאר בתיבה ו-ההיסט של לחיצה כשהתוכן מתחלף מתחתיה.

  • feat (WebApp, docs): ”כלי MD“ בתפריט ⋮ של הפתק — קישור, בלוק מתקפל ואלרט נכנסים לתוכן במקום הסמן, והטקסט למילוי מסומן. עד היום כל קישור, בלוק מתקפל או אלרט בפתק הוקלד ביד. אחרי: הפריט הראשון בתפריט ⋮ פותח חלונית — בלי רקע, כדי שהפתק יישאר גלוי — עם כפתור לכל תבנית, אייקון ושם בעברית; האלרטים נבנים מאותה רשימת סוגים שהפתק מזהה. התבנית נכנסת במקום שבו הסמן היה (ובסוף התוכן כשאין מקום כזה), טקסט מסומן נכנס אליה במקום הטקסט למילוי, ואחרי ההזרקה מסומן מה שצריך למלא — https:// בקישור, כך שהדבקה אחת מכניסה את הכתובת. ↶ מבטל בלחיצה אחת. החלונית נפתחת מעל הפתק, ובלי מקום שם — בצד שיש בו הכי הרבה מקום, כדי לא להסתיר אותו. בפתק ממוזער הפריט אינו מוצג. התיאור למשתמש: כלי MD; הנימוק: כלי MD: חלונית בלי מודאל, הסמן שהדפדפן זוכר, ומה מסומן אחרי.

  • fix (WebApp): Enter שממשיך רשימה בפתק ועובר את תקרת האורך מציג את האזהרה מיד. המשך הרשימה כתב לתיבה מהקוד, ורשם לביטול ושמר, אבל לא בדק אורך — והאזהרה הופיעה רק בהקלדה הבאה. אחרי: כל כתיבה מהקוד לתוכן הפתק עוברת ב-_commitProgrammaticEdit, שעושה את שלושתם.

  • fix (tests): בדיקות הדפדפן מוצאות את Chromium גם בתיקייה chrome-linux64 של Chrome for Testing. _locate_chromium ב-tests/conftest.py חיפש רק chrome-linux, ובסביבה שבה הבנייה של Chrome for Testing יושבת ב-chrome-linux64 כל בדיקות הדפדפן דולגו.

  • feat (MCP, docs): הזוגות של codekeeper_multi_edit_file יכולים לעלות כקובץ, ומפוענחים פעם אחת. סוכן שתיעד escape מילולי — טקסט שהוא לוכסן ואחריו u200F — דרך edits קיבל לפעמים את הטקסט, ולפעמים את התו הבלתי-נראה עצמו. הסיבה: edits הוא רשימה, ומחרוזת בתוך זוג עוברת פענוח JSON אחד כשהרשימה הגיעה כמערך, ושניים כשהגיעה כמחרוזת JSON (נמדד על mcp 1.28.1). השרת עקבי בכל אחת מהצורות, ואינו יכול לדעת איזו מהן הלקוח שלח. אחרי: edits_upload_id במקום edits. הזוגות נכתבים לקובץ JSON, עולים ב-PUT /api/agent/upload כבתים, והשרת מפענח את הקובץ פעם אחת בדיוק ומעביר אותו באותו מסלול של edits. הקובץ עצמו הוא JSON, ולכן לוכסן שנועד להיות טקסט נכתב בו כשני לוכסנים. קובץ שאינו מערך JSON נענה invalid_edits_upload, עם מיקום במספרים בלבד. סירוב שבא לפני השמירה משאיר את ההעלאה, וכשל של השמירה עצמה שורף אותה (upload_consumed). edits נהיה רשות, עם רשימה ריקה כברירת מחדל: קריאה ששולחת edits מתנהגת כמו קודם — חוץ מטקסט ש-UTF-8 אינו יכול לקודד, שעליו העדכון הבא ברשימה — וקריאה בלי edits ובלי edits_upload_id, שעד היום נדחתה בוולידציה של ה-SDK, נענית missing_edits. תיאורי הכלים מפרידים בין העדפה לנכונות, ומחלקים לפי הטקסט ולא לפי הלקוח: כמה עריכות בגרסה אחת — הכלי הזה, וזו העדפה; לוכסן שאינו escape של יוניקוד — codekeeper_edit_file; ו-escape של יוניקוד שנועד להיות טקסט, שיכול להפוך לתו לפני שכלי כלשהו רואה אותו, בכל ארגומנט — בקובץ, למי שיכול להעלות אחד, ולמי שלא, דרך שער שמסרב לפני הכתיבה (escape של יוניקוד שהגיע כטקסט — expected_unicode_escapes). בתיאורים עצמם ה-escape נכתב במילים. תיאור edits מבקש לשלוח מערך ולא מחרוזת. ה-hint-ים של עוזרי ההעלאה מקבלים את שמות הפרמטרים של כל כלי (_UploadParam ב-mcp_server/handlers.py), והשומר המבני ב-tests/test_mcp_uploads.py גוזר את הכלים לפי כל פרמטר ששמו מסתיים ב-upload_id. ראו הזוגות כקובץ — edits_upload_id.

  • fix (MCP, docs): טקסט ש-UTF-8 אינו יכול לקודד נדחה לפני הכתיבה, עם הסיבה. מחרוזת עם surrogate בודד — חצי של זוג, שנוצר מ-escape של JSON בלי החצי השני — הגיעה עד המסד, שם מקודד ה-BSON של pymongo מסרב לה, והכלי ענה save_failed בלי סיבה. במסלול של העלאה זה קרה אחרי שהשער כבר שרף אותה, וה-hint אמר להעלות שוב את אותו קובץ. אחרי: כלי הכתיבה של קבצים דוחים את הטקסט לפני השער — invalid_utf8, אותה מילה של ראוט ההעלאה — ב-codekeeper_save_file וב-_resave_edited, שכל כלי העריכה עוברים בו; וב-codekeeper_multi_edit_file זוג כזה נענה invalid_edit עם index והשדה. שום דבר לא נכתב, וההעלאה נשארת. הכלל כתוב פעם אחת, ב-note_threads.utf8_encodable, שתגובות על פתקים כבר נבדקו בו. גוף של פתק, תיאור ושם קובץ אינם נבדקים בו עדיין. ראו טביעת אצבע לתוכן — content_sha256 ו-content_changed.

  • feat (MCP, docs): כלי העריכה מסרבים לכתוב כש-escape של יוניקוד לא הגיע אליהם כטקסט. סוכן שכותב escape של יוניקוד כטקסט — לוכסן, u וארבע ספרות הקס, למשל בדוגמת קוד — יכול לגלות שהלקוח הפך אותו לתו לפני שהקריאה יצאה. הכלי קיבל את התו, שמר אותו, וענה content_changed: false, כי מבחינתו נשמר בדיוק מה שהגיע. אחרי: expected_unicode_escapes ב-codekeeper_edit_file, וכשדה בכל זוג של codekeeper_multi_edit_file. הסוכן מצהיר כמה escapes כאלה יש ב-old_string וב-new_string יחד: ב-new_string המרה כותבת את התו במקום הטקסט, וב-old_string היא מחפשת את התו, וכשהוא קיים בקובץ ההחלפה נעשית במקום הלא נכון. השרת סופר את אותה תבנית בשתי המחרוזות כפי שהגיעו, וסכום אחר נענה unicode_escapes_mismatch עם expected, received, ו-received_in_old_string ו-received_in_new_string שאומרים איזו מחרוזת הומרה — מספרים בלבד — ובזוג גם index. שום דבר לא נכתב, והקובץ אינו נקרא מהמסד. בלי הפרמטר אין בדיקה. החוזה, שכתוב בתיאור הפרמטר: escape שנכתב בקריאה נספר כטקסט, ומי שרוצה את התו עצמו שולח את התו. ערך שאינו מספר שלם, 0 ומעלה, נענה invalid_expected_unicode_escapes, ובזוג invalid_edit. הבדיקה המקדימה שהתיאורים שלחו אליה — query של codekeeper_get_file — יצאה מהם: היא מדדה קריאה אחת, ואינה אומרת דבר על קריאת הכתיבה שאחריה. הענפים בתיאורים עכשיו: מי שיכול להעלות קובץ (bash, רשת ו-CODEKEEPER_PAT) ← edits_upload_id; מי שלא ← codekeeper_edit_file עם הפרמטר; סורב ← שליחה אחת נוספת, ואחריה לומר למשתמש. codekeeper_save_file, codekeeper_append_file וכלי הפתקים אינם נושאים את הפרמטר עדיין (#3692). ראו escape של יוניקוד שהגיע כטקסט — expected_unicode_escapes.

  • fix (WebApp, docs): שם קובץ עברי בממשק מוצג עם הסיומת בקצה השמאלי — ברשימת הקבצים, בכותרת של עמוד הקובץ, בחיפוש, באוספים, בדשבורד ובעוד מקומות. ב-מדריך-תצוגת-Markdown-RTL.md הסיומת נדבקה לחלק הלטיני והוצגה באמצע השם. מאותה סיבה, בכרטיס תוצאת החיפוש ובכותרות של שני הצדדים ב-/compare, שהם בהקשר שמאל-לימין, גם ערכות.md ו-2026-סיכום.md הוצגו עם הסיומת מימין לשם. עכשיו כל שם הוא <bdi>: מפורק לשם ולסיומת כשצריך, ומבודד מהטקסט שסביבו תמיד. ההחלטה עברה ל-webapp/static/js/utils/file-name.js (FileName), ויש לה תאום בשרת — הפילטר file_name (webapp/file_name_display.py) — לעמודים שהשרת בונה, עם טסט שמשווה את שניהם על כל תו ביוניקוד. escapeHtml ב-collections.js, ב-collection_shared.js וב-global_search.js מקודד עכשיו גם מרכאות: באוספים השם נקרא מ-data-open / data-file-name, ובחיפוש הוא נכנס ל-title של הקישור — ושם עם " היה יוצא מהמאפיין. ההסבר המלא: כיוון של קוד בשורה ותאי טבלה.

  • fix (WebApp, docs): שם קובץ עברי בממשק מוצג עם הסיומת בקצה השמאלי — ברשימת הקבצים, בכותרת של עמוד הקובץ, בחיפוש, באוספים, בדשבורד ובעוד מקומות. ב-מדריך-תצוגת-Markdown-RTL.md הסיומת נדבקה לחלק הלטיני והוצגה באמצע השם. מאותה סיבה, בכרטיס תוצאת החיפוש ובכותרות של שני הצדדים ב-/compare, שהם בהקשר שמאל-לימין, גם ערכות.md ו-2026-סיכום.md הוצגו עם הסיומת מימין לשם. עכשיו שם של קובץ שלך הוא <bdi> בכל מקום שאפשר לשים בו תגיות — כולל עמוד הקבצים ששותפו בקישור, שהמיפוי הראשון החמיץ ונמצא בריוויו: מפורק לשם ולסיומת כשצריך, ומבודד מהטקסט שסביבו תמיד — dir="rtl" לשם שיש בו עברית, ו-dir="auto" לשם בלי. גם קוד בשורה שנראה כמו שם קובץ עם עברית מקבל dir="rtl" (FileName.codeDir): מאז dir="auto" שנוסף לקוד בשורה ב-13.11, שם כמו pdf-עברי-ל-markdown-אפיון-גרסה-ראשונה.md בתוך גרשיים הפוכים הוצג משמאל לימין, עם המילים בסדר הפוך. ההחלטה עברה ל-webapp/static/js/utils/file-name.js (FileName), ויש לה תאום בשרת — הפילטר file_name (webapp/file_name_display.py) — לעמודים שהשרת בונה, עם טסט שמשווה את שניהם על כל תו ביוניקוד. escapeHtml ב-collections.js, ב-collection_shared.js וב-global_search.js מקודד עכשיו גם מרכאות: באוספים השם נקרא מ-data-open / data-file-name, ובחיפוש הוא נכנס ל-title של הקישור — ושם עם " היה יוצא מהמאפיין. ההסבר המלא: כיוון של קוד בשורה ותאי טבלה.

  • change (WebApp): בווידג’ט ”קבצים שדורשים טיפול“ בדשבורד אין עוד קבוצה ”לא עודכן זמן רב“. הוסרו הקבוצה, החלק שלה במונה, השורה ”קובץ נחשב ישן אחרי 60 ימים“ והקישור ”הגדרות“ לידה (עוגן שלא היה קיים), והשאילתה והספירה שלה בכל טעינה של הדשבורד. stale_days ו-show_stale_files הוסרו מ-PUT /api/settings/attention ומהשחזור של גיבוי אישי: אף קוד לא קרא אותם. בקשה שעדיין שולחת אותם לא נכשלת — השדות פשוט לא נשמרים.

2026-11-13

  • fix (WebApp, docs): שם קובץ עברי בקוד בשורה מוצג עם הסיומת בקצה השמאלי. ב-מדריך-תצוגת-Markdown-RTL.md הנקודה יושבת בין שתי אותיות לטיניות, והדפדפן הדביק אותה ואת הסיומת לחלק הלטיני — ולכן .md הוצג באמצע השם, צמוד לעברית, גם אחרי ש-dir="auto" תיקן את הכיוון של קוד בשורה. אחרי: קוד בשורה כזה מקבל dir="rtl", והסיומת נכתבת ב-<bdi> ועוברת לקצה השמאלי — בתצוגת המסמך, בתצוגה החיה, בדפדפן הריפו, בפתקים ובשם של פתק על כרטיס. גם שם שמתחיל באנגלית (Report-דוח-Q3.md). שם בלי עברית, שם שנגמר בעברית, שם עם נקודה נוספת אחרי העברית ונתיב — כמו קודם. ההחלטה מתי מפרקים, והבנייה לצמתים, כתובות פעם אחת ב-utils/rtl-code.js (fileNameParts, fillInlineCode), ותוסף ה-markdown-it בונה את אותו מבנה כ-HTML. פרטים: כיוון של קוד בשורה ותאי טבלה.

  • fix (WebApp, docs): החיפוש בתוך פתק, במסמך ובדפדפן הריפו מוצא גם מילה שעוברת בין עיצובים. ההדגשה (highlightWithin ב-utils/text-highlight.js) בדקה כל צומת טקסט לבדו, ולכן מילה שחציה מודגש לא נמצאה — וגם שם קובץ עברי שהסיומת שלו מבודדת לא היה נמצא כשמחפשים את כולו. אחרי: החיפוש עובר על הטקסט המחובר של כל שורה, וכל צומת שההתאמה עוברת בו מקבל עטיפה משלו; ביטוי שממשיך לשורה, לתא או לפריט הבא עדיין אינו נמצא. התאמה מפוצלת נספרת פעם אחת, והפעילה נצבעת על כל החלקים שלה — דרך hitsWithin ו-setActive במודול, ששלושת הצרכנים עוברים דרכם. פרטים: עקרונות להוספת פיצ’ר לסטיקי-נוטס — הממשק בדפדפן: גאומטריה, אינטראקציה וניגודיות, בסעיף על ההדגשה.

  • fix (WebApp, docs): קוד בשורה בפתק, ובשם של פתק על כרטיס, מוצג לפי הכיוון של התוכן שלו. .sticky-md-code כפה direction: ltr עם unicode-bidi: embed על כל קוד בשורה בפתק, והכרטיס של פתק — בארכיון ובפתקים הנעוצים בעמוד הקבצים — כתב dir="ltr" על קוד בשם. לכן שם קובץ בעברית הוצג הפוך: ב-הפניות-שלא-חלו.md הסיומת עברה לצד ימין, לפני השם, וב-מדריך-תצוגת-Markdown-RTL.md החלק הלטיני עבר לפני העברי. ובטבלה, תא שמתחיל בקוד ואחריו משפט בעברית התהפך כולו לשמאל לימין, כי הקוד קבע את הכיוון של התא. אחרי: dir="auto" על הקוד (_appendInlineSegments בפתק, fillTitle בכרטיס), כמו בתצוגת המסמך, ובלי direction או unicode-bidi ב-CSS של שניהם. תא שכל התוכן שלו קוד בעברית מיושר עכשיו לשמאל, והקוד בו נקרא נכון. tests/sticky-notes-target.test.js בודק את ה-DOM מול markdown-it עם md-auto-dir-plugin.js ושומר שה-CSS לא יחזור, ו-tests/test_sticky_inline_code_dir_browser.py מודד בכרומיום את הסדר של התווים על המסך, עם ריצת בקרה. פרטים: קוד בשורה: יחידה אחת, שקודמת לכל מפריד.

  • fix (WebApp, docs): קוד בתוך שורה ותאי טבלה במסמך Markdown מוצגים לפי הכיוון של התוכן שלהם. העמודים הם dir="rtl", וקוד בשורה ותא בטבלה ירשו את הכיוון הזה: --flag הוצג flag--, foo() הוצג ()foo, ובטבלה C++ הוצג ++C ומיושר לימין. כותרת של עמודה הייתה ממורכזת. אחרי: webapp/static/js/md-auto-dir-plugin.js כותב dir="auto" על כל קוד בשורה ועל כל תא, בכל מקום שיוצר את markdown-it — תצוגת המסמך, התצוגה החיה, הייצוא המעוצב, דפדפן הריפו וכרטיסי החיפוש בתיעוד — והדפדפן מחליט על הכיוון של כל אחד מהם לפי האות החזקה הראשונה שבו. כלל הטבלה של כל משטח מיישר ל-start, ולכן כל תא מיושר לפי הכיוון שנקבע לו. שם קובץ בעברית, כמו הפניות-שלא-חלו.md, נשאר בסדר הקריאה הטבעי — ולכן זה dir="auto" ולא direction: ltr כמו בפתקים. ב-live-preview.js הוסר כלל code_inline שלא כתב את מאפייני הטוקן, ומחק את dir בשקט. ראו כיוון של קוד בשורה ותאי טבלה.

  • change (WebApp, docs): קישור במסמך Markdown נפתח בלשונית חדשה. עד היום לחיצה על קישור החליפה את העמוד: בתצוגת המסמך זה איבד את המקום בקריאה, ובתצוגה החיה בעמוד העריכה זה גם עזב את העורך. אחרי: קישור שמוביל לעמוד (https://, http:// או נתיב באתר) נפתח בלשונית חדשה, עם rel="noopener noreferrer". זה חל בתצוגת המסמך, בתצוגה החיה, בעורך הציבורי, בדפדפן הריפו, בכרטיסי החיפוש בתיעוד, בייצוא המעוצב ובקישור השיתוף, וגם ב-Reader Mode. עוגן בתוך המסמך (תוכן עניינים, , הערות שוליים) ו-mailto: נשארים באותה לשונית. הכלל כתוב פעם אחת לדפדפן (webapp/static/js/md-link-target-plugin.js, שכל מקום שיוצר את markdown-it מתקין) ופעם אחת לשרת (services/md_link_target.py), ושני העותקים נבדקים מול אותה טבלה. ראו קישור נפתח בלשונית חדשה.

  • fix (WebApp, docs): שם של קובץ במסמך Markdown כבר לא מוצג כקישור לאתר. markdown-it נוצר עם linkify: true, ו-linkify-it ניחש כתובות גם בלי פרוטוקול: כל מילה.XX שבה XX הוא קוד מדינה. לכן myAgent-spec.md, app.py ו-run.sh הוצגו בתצוגה החיה, בתצוגת המסמך ובדפדפן הריפו כקישור ל-http://myAgent-spec.md, והלחיצה הובילה לדף שגיאה של הדפדפן. שם בעברית אף הומר לכתובת מקודדת (xn--…). אחרי: webapp/static/js/md-linkify-plugin.js מכבה את הניחוש (fuzzyLink) בכל מקום שיוצר את markdown-it עם linkify: true. קישור נוצר רק מכתובת עם פרוטוקול (https://, http://, ftp://, mailto:, //), מכתובת מייל ומ-[טקסט](כתובת). גם www.example.com ו-example.com בלי פרוטוקול נשארים טקסט — החלטה של בעל הפרויקט. ראו קישורים אוטומטיים.

  • fix (WebApp): התראת פוש מוצגת מימין לשמאל גם כשהכותרת או הגוף מתחילים באנגלית. אנדרואיד קובע את כיוון השורה בהתראה לפי האות החזקה הראשונה בה, והאימוג’י שבתחילת הכותרת אינו נחשב. לכן 💬 CC הגיב על "…" הוצגה משמאל לימין: CC בקצה השמאלי, וקטעי העברית והאנגלית בשורה השנייה בסדר הפוך. אותו דבר קרה לגוף של תזכורת שמתחיל בכותרת Markdown או בקוד (# `is_latest` …), ולשם קובץ שמתחיל באנגלית (Handoff: שרשורי…), שבו .md נצמד ל“שרשורי“. אחרי: כל בוני ההתראות עוברים ב-_notification_text (webapp/push_api.py): לטקסט שיש בו עברית נוסף RLM בתחילתו, וכל שם — כותב, פתק, קובץ — מבודד, ב-RLI כשיש בו עברית וב-FSI כשאין. טקסט בלי עברית נשלח כמו שהוא. הסימנים נוספים רק ב-payload, אחרי הקיצור לתצוגה, ואינם נספרים בתקרות. dir של showNotification נבדק ונפסל: Chrome אינו מעביר אותו להתראה. ראו כיוון הטקסט בהתראה.

  • fix (WebApp, MCP, docs): פתק שרק נפתח ממזעור כבר לא קופץ לראש ”פתקים אחרונים“. כל כתיבה לפתק קידמה את updated_at — מזעור ופתיחה, הזזה, שינוי גודל, צבע, מצב, שינוי מה-MCP, וגם הפתיחה האוטומטית של פתק ממוזער כשנכנסים אליו מקישור — וגם העברה לארכיון, שינוי שם של הקובץ ומעבר בין לוחות. ”פתקים אחרונים“, החיפוש והייצוא לגיבוי ממיינים לפיו. אחרי: updated_at זז רק כשהתוכן או השם באמת משתנים (sticky_notes_target.NOTE_EDIT_FIELDS). הכלל במקום אחד, drop_unchanged_edits, ששלושת הכותבים של פתק קיים — PUT, batch ו-update_note של ה-MCP — קוראים לו: תוכן ששווה למה ששמור יוצא מהעדכון, ועדכון שאינו משנה דבר אינו כותב. ההגנה מדריסה בין לשוניות נשארת: עריכה עם אסימון ישן עדיין מקבלת 409. פתקים שכבר קפצו נשארים עם הזמן הזה עד העריכה הבאה שלהם. ראו updated_at: רק כשהתוכן או השם משתנים.

  • change (WebApp): בכרטיס ”פתקים אחרונים“, הקישור לפתק נפתח בלשונית חדשה, ורק הטקסט של השם הוא הקישור. הקישור נפתח באותה לשונית, והיה display: block, ולכן כל רוחב השורה — גם השטח הריק אחרי השם — פתח את הפתק. אחרי: target="_blank", והקישור הוא inline. ראו ”פתקים אחרונים“ בדשבורד.

  • feat (WebApp, docs): ב“פתקים אחרונים“ בדשבורד — איפה כל פתק יושב, וקישור אליו. הכרטיס הכיר רק פתקים על קובץ: פתק לוח, פתק ריפו ופתק בארכיון הוצגו ”ללא קובץ“, וגם פתק על קובץ גדול, כי השם חופש רק ב-code_snippets. הקישור היחיד היה ”פתח קובץ“, לגרסה שעליה הפתק נוצר, ובסוף הרשימה ”ועוד N פתקים ממתינים“ ספר בעצם את כל הפתקים. אחרי: מתחת לכל פתק כתוב איפה הוא יושב — שם הלוח (”לוח רעיונות“; לוח ששמו מתחיל במילה ”לוח“, כמו ”לוח עבודה“, מוצג כמו שהוא), שם הקובץ (גם קובץ גדול), ”ריפו:“ עם הנתיב, או ”ארכיון“ — והשם של הפתק מקשר ל-/note/<id>, הקישור הקבוע שפותח את הפתק במקום שלו. ”פתח קובץ“ ו“ועוד N“ הוסרו, וכותרת המשנה היא ”הפתקים שעודכנו לאחרונה“. שמות הלוחות נקראים בשאילתה אחת, ב-note_boards.board_names_by_id, ששורת התגובות הממתינות בפריימר של ה-MCP עברה גם היא להשתמש בה. ראו ”פתקים אחרונים“ בדשבורד ו-איפה הפתק יושב: שורת המיקום ב“פתקים אחרונים“.

2026-11-12

  • fix (WebApp, docs): מחיקת פתק מוחקת גם את התזכורת שלו, והדשבורד מציג שוב את התזכורת הבאה. delete_note מחק את הפתק ואת השרשורים שלו, ולא נגע ב-note_reminders, ולכן התזכורת של פתק שנמחק נשארה פעילה. כשהיא הייתה הקרובה ביותר, כרטיס ”הגדרות פוש“ בחר בה כ“התזכורת הבאה“, לא מצא את הפתק וכתב ”אין תזמון עתידי“, גם כשתזכורת אמיתית חיכתה אחריה; וכשהגיע מועדה נשלחה עליה התראה בלי שם, והיא הופיעה בפעמון בלי שם. אחרי: delete_note מוחק את כל מסמכי התזכורת של הפתק, רק אחרי שהפתק עצמו נמחק, וכשל שם נרשם בלוג ואינו מכשיל את המחיקה. האירוע sticky_note_deleted נושא עכשיו גם reminders_deleted. set_note_reminder קורא את הפתק שוב אחרי הכתיבה, כך שתזכורת שנקבעת ממכשיר אחר בדיוק ברגע המחיקה לא נשארת אחריה, והתזכורת נשמרת תחת ה-_id של הפתק ולא תחת המזהה כמו שהגיע בכתובת (ObjectId מקבל אותיות גדולות). תזכורות יתומות שנוצרו לפני התיקון לא נוקו אוטומטית (מצב התזכורת: שדה אחד מתאר, שניים סוטים).

  • fix (WebApp): ביטול תזכורת של פתק מבטל גם מסמך כפול שלה. ל-user_note_idx אין unique, ושתי קביעות מקבילות יכולות להשאיר שני מסמכים לאותו פתק; delete_note_reminder מחק אחד, והשני נשאר לירות אחרי הביטול. אחרי: הביטול מוחק את כולם, וחלון התזכורת מציג את זו שיורה ראשונה.

  • ci (docs): בנייה של PR נכשלת על אזהרה בתיעוד, גם כש-Read the Docs לא זמין. הבנייה של ה-PR ב-documentation.yml רצה בלי -W והציגה ✅ גם כשהיו אזהרות, והבדיקה היחידה שהכשילה PR על אזהרה הייתה של Read the Docs. ב-12.11.2026 הבנייות שלהם נקטעו שוב ושוב ב-”Build terminated due to inactivity“, ולפני מיזוג לא היה מי שיאמר אם יש אזהרה. אחרי: הצעד sphinx_pr רץ עם -W -E. -W מכשיל אותו על כל אזהרה, ו--E קורא מחדש את כל העמודים, כדי שגם קישור שנשבר בעמוד שה-PR לא שינה ידווח. הבנייה של main, שמפרסמת את האתר, לא השתנתה: אזהרה לא עוצרת את הפרסום. ושני דברים שהיו מרוקנים את הבדיקה מתוכן: suppress_warnings ב-docs/conf.py השתיק כל אזהרה של autodoc, גם חתימה לא תקינה ותכונה חסרה, ועכשיו רק את הרעש של מודולים מדומים (והערך autodoc.mocked, שלא התאים לשום אזהרה, הוחלף ב-autodoc.mocked_object); ולכל מלאי intersphinx נוסף עותק שמור ב-docs/_intersphinx/, שנטען רק כשהאתר החיצוני לא זמין, כדי שאתר כזה לא יכשיל PR. ראו Doc Authoring Guide (Sphinx/RTD), בסעיף ”טיפים מהירים“.

  • change (WebApp): החיפוש בתצוגת קובץ ובתצוגת Markdown רץ רק באנטר. עד היום כל הקלדה חיפשה, הדגישה וגללה לתוצאה. אחרי: ההקלדה לא מחפשת; Enter מחפש ומסמן את ההתאמה הראשונה, Enter נוסף עובר לבאה ו-Shift+Enter לקודמת; ▼ ו-▲ על טקסט שעוד לא חיפשו — מחפשים; ושינוי הטקסט אחרי חיפוש מנקה מיד את ההדגשות והמונה, כמו בתיבת החיפוש של דפדפן הריפו. הכלל יושב במודול אחד, webapp/static/js/utils/search-submit.js (window.SubmitSearch), ששני העמודים — ובתצוגת הקוד שני המנועים, הבסיסי ו-CodeMirror — רק מבצעים דרכו. עד היום שלושה מקומות החזיקו אותו בנפרד: התצוגה המתקדמת יירטה את האירועים לפני הבסיסית, ובבסיסית המאזינים של Enter ושל ▼ היו רשומים פעמיים, ולכן כל לחיצה קידמה שתי התאמות ועם מספר אי-זוגי של התאמות האחרונה לא הוצגה אף פעם — ממצא 1 ב-#3477, שמתוקן כאן. גם ממצא 2 שם מתוקן: המנוע של התצוגה הבסיסית תפס את ה-pre של מספרי השורות כקוד — מספר שמופיע רק כמספר שורה נמצא כהתאמה, וכל חיפוש, גם החלפת תצוגה תוך כדי, כתב מחדש את מספרי השורות מהעותק שנשמר בטעינה ומחק את סימוני ה-🔖 של הסימניות. עכשיו הוא לא נוגע בעמודת מספרי השורות (codeRoots ב-view_file.html). ממצאים 3–4 פתוחים. החלפה בין ”בסיסי“ ל“מתקדם“ מחפשת שוב את מה שחיפשו בפועל (window.CodeSearch.rerun), ולא טקסט שהוקלד ועוד לא חיפשו. אנטר בזמן הרכבה של מקלדת IME שייך להרכבה ואינו מחפש — אותה בדיקה של החיפוש בתוך פתק. לשתי התיבות נוסף enterkeyhint="search", שקובע רק את התווית של מקש האנטר במקלדת וירטואלית, וכשהמודול לא נטען מושבתים גם ▲▼✕ ולא רק התיבה. tests/search-submit.test.js בודק את הכלל ב-CI, ו-tests/test_search_on_enter_browser.py בודק בכרומיום את העמודים האמיתיים בשתי התצוגות. החיפוש בתוך פתק דביק לא השתנה.

  • fix (WebApp): אחרי פעולה מרובה שהצליחה בעמוד הקבצים, תיבות הסימון נעלמות. כל פעולה על הנבחרים ניקתה רק את הבחירה, ומצב ”בחירה מרובה“ נשאר דלוק — וגם נשמר ב-sessionStorage, כך שאחרי ”הוסף תגיות“, שמרענן את העמוד, התיבות חזרו. ”הוסף לאוסף“ לא ניקה אפילו את הבחירה. אחרי: הצלחה של מועדפים, תגיות, ZIP, שיתוף, אוסף או מחיקה קוראת ל-finishBulkAction ב-multi-select.js, שיוצא מהמצב; בהוספה לאוסף רק אחרי שהשרת אישר (onSuccess של openBulkAddToCollectionModal ב-base.html). גם בקשה שחוזרת אחרי שהחלון נסגר: ה-onSuccess והפתיחה של החלון נלכדים לפני שהבקשה יוצאת, ותשובה לפתיחה קודמת לא סוגרת חלון שנפתח אחריה — והבחירה מתנקה רק אם היא עדיין זו שנשלחה. ו-ok מהשרת אינו ”הכול נוסף“: CollectionsManager.add_items מדלג על פריט שנכשל ומחזיר added ו-updated, וכשהסכום שלהם קטן מהמבוקש החלון מציג ”נוספו X מתוך Y“ ומשאיר את החלון ואת הבחירה לניסיון נוסף. עד היום ההודעה ספרה את מה שנשלח ולא את מה שנוסף. sessionStorage חסום או מלא כבר לא עוצר את היציאה מהמצב באמצע — כל הגישה אליו עוברת ב-selectionStorage, שלא זורק. כשל משאיר את הבחירה לניסיון נוסף, ושלוש פעולות שלא הציגו כלום כשהשרת ענה success: false — ”הסר ממועדפים“, ”הוסף תגיות“ ו“שתף“ — מציגות עכשיו שגיאה. ”ביטול בחירה“ לא השתנה: מנקה את הבחירה ומשאיר את המצב. multi-select.js ו-bulk-actions.js נטענים עכשיו עם ?v=, אחרת הקוד החדש לא היה מגיע למי שכבר ביקר בעמוד. ראו Bulk actions (בחירה מרובה).

  • fix (WebApp): סימניות מוסתרות בהגדרות לא נוצרות בנגיעה. ”הצגת כפתור סימניות“ ← הסתר הסתיר רק את הכפתור הצף, ונגיעה במספר שורה או בכותרת המשיכה ליצור סימניות. אחרי: ”מוסתר“ מכבה את כל דרכי היצירה — מספר שורה, כותרת ב-Markdown, עוגן בתצוגת HTML, תפריט הצבע ו-Ctrl+B — דרך isEnabled ב-BookmarkUI; נגיעה במספר שורה לא עושה כלום, גם לא קופצת לשורה. סימניות קיימות נשארות מסומנות, והפאנל נפתח ב-Ctrl+Shift+B. שינוי בעמוד ההגדרות חל מיד גם בלשונית שבה קובץ כבר פתוח (אירוע storage). bookmarks.js נטען עכשיו עם ?v=, ו-tests/test_bookmarks_setting_key.py משווה את המפתח שעמוד ההגדרות כותב לזה ש-bookmarks.js קורא. ראו הסתרת הסימניות.

  • change (WebApp): כפתור הלוחות בשורת הקטגוריות של עמוד הקבצים נקרא ”לוחות פתקים“. עד היום ”סטיקי נוטס“ — שם אחר מזה של עמוד הלוחות, של קיצורי הדרך ושל הכפתור בשורת הכלים. הצ’קליסט ”צעדים ראשונים“ (webapp/first_steps.py) מפנה לכפתור בשמו החדש, ו-tests/test_files_notes_buttons.py בודק שהשם שבצ’קליסט הוא השם שהעמוד מציג.

  • fix (WebApp): שם משתמש בטלגרם מוצג עם ה-”@“ לפניו. העמודים כתובים מימין לשמאל, ו-”@“ שנכתב ביד לפני השם נצמד לכיוון העברי — ”moominAmir@“ בפרטי החשבון בעמוד ההגדרות, ובאותה צורה בעמודי האדמין: סטטיסטיקות, תצוגת סניפט ושני עמודי ההמתנה לאישור. אחרי: כל המקומות עוברים במאקרו אחד, telegram_username ב-webapp/templates/components/telegram_username.html, שמבודד את השם ב-<bdi dir="ltr"> ומוריד ”@“ כפול. בסטטיסטיקות, משתמש בלי שם מוצג ”ללא שם“ ולא ”@ללא שם“. tests/test_telegram_username_macro.py נכשל על ”@“ ידני בתבנית, ו-tests/test_telegram_username_browser.py מודד בכרומיום שה-”@“ משמאל לשם.

2026-11-10

  • feat (WebApp, docs): ערכה מיובאת או ציבורית יכולה לצבוע את שם הקובץ, התיאור והמטא של כרטיס הקובץ. בערכה מיובאת שם הקובץ נצבע בכלל הכותרות, התיאור בכלל הפסקאות, והשורות, הגודל והתאריכים בכרטיס יורשים את צבע הטקסט — וכשהערכה נותנת לשני צבעי הטקסט אותו ערך, כמו morass, הכרטיס כולו בצבע אחד. אחרי: --file-name-color-override צובע את שם הקובץ בכרטיס בעמוד הקבצים ובראש תצוגת הקוד, ה-Markdown וה-HTML; --file-description-color-override את התיאור, בכרטיס ובתצוגת הקוד; ו---file-card-meta-color-override את השורות, הגודל והתאריכים בכרטיס. ערכה מצהירה עליהם בבלוק variables, וערכה שאינה מצהירה נשארת כמו שהייתה. בתצוגת ה-HTML נצבע רק השם, בלי התחילית ”תצוגת דפדפן:“. התגיות לא השתנו. ראו שם הקובץ ותיאורו: כרטיס הקובץ ותצוגות הקובץ.

  • feat (WebApp, MCP, docs): פתקי לוח אפשר לנעוץ בראש עמוד הקבצים. בתפריט ⋮ של פתק לוח יש עכשיו 📎, מתג שנועץ את הפתק בראש ”הקבצים שלי“ ומסיר אותו משם. הפתק נשאר בלוח שלו, ובעמוד הקבצים הוא כרטיס בצבע שלו, בשורה של הכותרת; לחיצה פותחת אותו במרכז המסך, כמו בארכיון. עד MAX_FILES_PAGE_PINNED_NOTES פתקים (ארבעה), והחמישי נדחה בלי להוריד פתק ישן. מוצגים כרטיסים מלאים, כמה שנכנסים בשורה אחת, ומה שלא נכנס — מאחורי ”+N“; ומכשיר שבו נכנסים פחות כרטיסים אינו יכול לנעוץ פתק שאצלו היה מוצג רק כ-”+N“. בחלון נמוך, או כשיש הכרזה בראש העמוד, הכרטיסים הופכים לפס של שמות. העברה לארכיון מסירה את הנעיצה. גיבוי ושחזור שומרים אותה כשיש מקום בתקרה; פתק שבזמן השחזור אין לו מקום חוזר ללוח שלו בלי הנעיצה, וסיכום השחזור אומר כמה כאלה היו. ב-MCP, codekeeper_get_note מחזיר את files_page_pinned_at. ראו נעיצה בראש עמוד הקבצים, נעיצה לעמוד הקבצים: שדה לצד היעד, ולא יעד ו-עמוד הקבצים: שורה אחת של כרטיסים, ”+N“, ופס רק כשאין גובה.

  • fix (WebApp): העברה לארכיון שהשרת לא עונה עליה כבר לא משאירה את 🗃️ מת. הבקשה נשלחה בלי תקרת זמן, בזמן שהפתק מסומן ”בהעברה“, ולכן בקשה שלא חזרה השאירה את 🗃️ של אותו פתק בלי תגובה עד רענון. אחרי: הבקשה עוברת באותה פונקציה של השרשורים (_apiFetch, שנקראה עד היום _threadFetch), עם תקרה של API_FETCH_TIMEOUT_MS, ומי שהבקשה שלו נתקעה מקבל הודעה ו-🗃️ חוזר לעבוד. ראו שרשורי תגובות: השרת והממשק בוובאפ.

  • change (WebApp): קוד בשם של פתק מוצג על כרטיס הארכיון כקוד. שם עם קוד בשורה — טקסט בין גרשיים הפוכים, כמו שם של פונקציה — הוצג על הכרטיס עם הגרשיים. אחרי: הקוד מוצג כקוד, בלי הגרשיים, לפי אותו כלל של קוד בשורה בגוף הפתק — וכך גם בכרטיסים של עמוד הקבצים, שנבנים באותו רכיב. ראו ארכיון: המנהל במצב ארכיון, העמוד וחלון השם.

  • fix (WebApp): שם כרטיס בארכיון עם מילה לטינית מוטעמת, כמו café, מוצג בסדר הנכון. הרצפים הלטיניים בשם עברי זוהו לפי ASCII בלבד, ולכן café התפצל ל-caf מבודד ול-é שנשאר בטקסט העברי וצויר משמאל לו. אחרי: הזיהוי לפי הכתב הלטיני (\p{Script=Latin}), כולל סימן טעם צמוד. ראו ארכיון: המנהל במצב ארכיון, העמוד וחלון השם.

  • fix (WebApp): הריחוף על כרטיס בארכיון מונפש גם בערכות הכהות, ו“פחות תנועה“ מבטל את המעברים. כלל ה-transition של הכרטיס נדרס בידי הכלל הגורף של dark-mode.css ([data-theme="dark"] *), שנטען אחריו באותה ספציפיות: הכרטיס קפץ בלי הנפשה, ובהעדפת ”פחות תנועה“ נשארו המעברים של הערכה. אחרי: הכלל כתוב בשם המחלקה פעמיים, כמו .ck-toast.ck-toast, ונמדד בכרומיום בשני המצבים.

  • fix (WebApp): בפתקים על קובץ בריפו יש אזהרת אורך בזמן ההקלדה. דפדפן הריפו הזריק לדף רק את תקרת התגובה בשרשור ולא את תקרת התוכן של הפתק, ולכן פתק ארוך מהתקרה נדחה רק בשמירה, בלי אזהרה קודם. אחרי: כל עמוד שמארח פתקים מזריק את שתי התקרות, ובדיקת חיווט ב-tests/sticky-notes-target.test.js אוכפת את זה.

  • fix (WebApp): גוף JSON פגום או null בראוטי הפתקים נדחה, ולא מטופל כגוף ריק. _json_object הפך כל None של get_json למילון ריק — גם JSON שלא פוענח — ולכן בקשה שנשלחה עם נתונים נענתה כאילו נשלחה בלי כלום, למשל דחיית תזכורת בשעה במקום מה שנשלח. אחרי: רק גוף ריק באמת הוא ”ברירות מחדל“, וגוף שנשלח ולא פוענח לאובייקט ← 400 invalid_payload. חל על התזכורות, הדחייה, האישור, ההעברה לארכיון, השרשורים והנעיצה לעמוד הקבצים.

  • feat (WebApp, docs): תוויות בתרשימי Mermaid נשברות לשורה חדשה רק אחרי 400 פיקסלים. עד היום רוחב הגלישה היה ברירת המחדל של Mermaid, 200, ולכן גם משפט קצר כמו ”מלכודת שכבר נפלו בה עם הסימפטום שלה“ (285 פיקסלים) נשבר לשתי שורות. אחרי: בתצוגת המסמך ובתצוגה החיה (עמוד העריכה, העורך הציבורי והייצוא המעוצב) הרוחב הוא MERMAID_WRAPPING_WIDTH, והתצורה כולה של Mermaid באתר — הרוחב, securityLevel: 'strict' ו-startOnLoad — באה ממקור אחד, mermaidSiteConfig ב-webapp/static_build/mermaid-site-config.mjs, שהבאנדל חושף כ-window.mermaidSiteConfig; עד היום md_preview.html ו-live-preview.js כתבו כל אחד את התצורה בעצמו. היא עוברת בכל קריאה ל-mermaid.initialize, כי ב-mermaid@11.12.0 הקריאה הזו מחליפה את כל התצורה. תרשים בודד יכול לקבוע רוחב אחר עם %%{init: {"flowchart": {"wrappingWidth": ...}}}%%, וזה גובר לתרשים ההוא בלבד (מדריך סגנונות וארכיטקטורת Markdown). המחיר בטלפון: תרשים שהצמתים שלו התרחבו מוקטן יותר כדי להיכנס לרוחב המסך — בתרשים לדוגמה, ברוחב 390, הטקסט ירד מ-6.9 ל-5.5 פיקסלים בפועל; ברוחב 1280 שני התרשימים שנמדדו לא מוקטנו בכלל. ובתצוגת המסמך, כשל באתחול של Mermaid נרשם עכשיו בקונסול ולא נבלע. tests/md-preview-mermaid-site-config.test.js שומר ב-CI על התצורה, על הבאנדל ועל שני המקומות שמאתחלים, ו-tests/test_mermaid_label_wrap_browser.py מודד בדפדפן שתווית בינונית נשארת בשורה אחת, שארוכה נשברת ברוחב האתר, ושהנחיה של תרשים גוברת. מצב הקריאה טוען Mermaid משלו ולא השתנה.

  • fix (WebApp): תוויות ארוכות בתרשימי Mermaid נשברות לשורות ולא נחתכות, גם בטאבלט. בתצוגת המסמך ובתצוגה החיה, בטאבלט עם יחס פיקסלים 2.2, תווית שארוכה מרוחב הגלישה של Mermaid נשארה בשורה אחת ונחתכה בקצה — בעברית, סוף המשפט (”לארכיו“ במקום ”לארכיון“). הסיבה ב-Mermaid עצמו (mermaid-js/mermaid#7794, פתוח, ועדיין כך גם ב-mermaid@12.3.0): addHtmlSpan עובר למצב גלישה רק כשרוחב התווית שנמדד שווה בדיוק לרוחב הגלישה, וביחס פיקסלים שאינו שלם כרומיום מחזיר שארית של נקודה צפה — נמדד 200.00010681152344 מול 200. אין לזה הגדרה ב-Mermaid וגם CSS לא עוזר, ולכן התיקון בבנייה של md_preview.bundle.js: התוסף mermaidLabelWrapFix ב-webapp/static_build/mermaid-label-wrap-fix.mjs מחליף את הבדיקה בבדיקה עם סובלנות של פיקסל, והבנייה נכשלת עם הסבר אם שדרוג של Mermaid ישנה את הנוסח שהוא מחליף (STRICT_WRAP_CHECK). ביחסי פיקסלים 1, ‏1.5 ו-2 התרשים מהדיווח נמדד זהה לפני ואחרי; ההבדל היחיד ביחס שלם הוא בתווית שצרה מרוחב הגלישה בפחות מפיקסל: היא עוברת עכשיו למצב גלישה, נשארת בשורה אחת, והתיבה שלה רחבה בשבר פיקסל. tests/md-preview-mermaid-label-wrap.test.js שומר ב-CI שהבאנדל שבריפו נבנה עם התוסף, ו-tests/test_mermaid_label_wrap_browser.py מודד בכרומיום עם יחס 2.2 שאף תווית אינה נחתכת. מצב הקריאה (reader_mode.html) טוען Mermaid מ-CDN ולא את הבאנדל, ולכן התיקון לא חל עליו.

  • feat (WebApp, docs): ערכה מיובאת או ציבורית יכולה לצבוע את כותרות המסמך, ההדגשה, הקוד בשורה והציטוט. בתצוגת ה-Markdown ובתצוגה החיה ערכה מיובאת מבדילה בין חלקי המסמך רק ב---text-primary וב---text-secondary, וכששניהם זהים בקובץ — כמו ב-morass — כל המסמך יוצא בצבע אחד. בקובץ הערכה אין לזה מקור: התצוגה המרונדרת של VS Code צובעת כותרות והדגשה ב-editor.foreground, ו-markup.* ב-tokenColors צובעים את מקור ה-Markdown בעורך ולא את המסמך. אחרי: חמישה ווי דריסה, --md-heading-color-override (H1–H2), --md-subheading-color-override (H3–H6), --md-strong-color-override, --md-inline-code-color-override ו---md-blockquote-border-override, שערכה בודדת מצהירה עליהם בבלוק variables. הם נקראים ב-md-content-colors.css רק בתוך #md-content ורק בערכה מיובאת או משותפת, ובלעדיהם כל אחד נופל לערך של היום: בדפדפן, לפני ואחרי, על תשע ערכות ובשתי התצוגות, ערכה שאינה מצהירה לא זזה בשום ערך שנמדד, וכותרות הממשק לא זזות גם כשהטוקנים מוצהרים. הקישור כבר נקרא מ---link-color. tests/test_md_document_colors_hook_browser.py מודד את זה בערכה אישית ובערכה שפורסמה. ובבדיקות הדפדפן, custom_theme מחיל עכשיו גם את בלוק ה-variables של הקובץ, כמו import_theme. ראו צבעי המסמך: כותרות, הדגשה, קוד בשורה וציטוט.

  • fix (WebApp): בלוק טקסט בתוך בלוק קוד עברי נשאר מימין, כמו בלוק טקסט רגיל. בבלוק קוד שהתוכן שלו עברי, למשל דוגמת Markdown בתוך ````markdown, כל גדר פנימית הוצגה משמאל לימין כקוד, גם ``` בלי שם שפה, ```text או ```md שהתוכן שלהם טקסט עברי. innerFences ב-webapp/static/js/utils/rtl-code.js החליטה לפי המבנה בלבד: כל מה שבין גדר פותחת לסוגרת נחשב קוד. עכשיו גדר פנימית מוכרעת באותו כלל כמו בלוק רגיל ב-applyRtlIfHebrew: שם שפה שאינו מצהיר על קוד (hasExplicitLanguageName, מול PLAIN_LANGUAGE_NAMES), ותוכן שעובר את HEBREW_THRESHOLD — טקסט. בלוק כזה נשאר עם כיוון הבלוק שסביבו, כולל שורות הגדר שלו: הגרשיים מצוירים בתחילת השורה, בקצה הימני, באותו קו של האות הראשונה של הטקסט שהם תוחמים. כל גדר אחרת היא קוד, ומוצגת משמאל לימין מהגדר הפותחת עד הסוגרת. ההחלטה נשאלת בכל רמה, ולכן בתוך בלוק טקסט כזה דוגמת קוד (```python) שוב מוצגת משמאל לימין. שם השפה נגזר משורת הגדר כמו ש-markdown-it 14.1.0 גוזר אותו למחלקה של בלוק רגיל, חוץ מהבדל אחד מתועד: markdown-it מפענח ישויות HTML ו-\ בשם (&#116;ext הוא text שם), וכאן לא. החלוקה נעשית במעבר אחד על השורות, עם מחסנית של הגדרות הפתוחות, ולכן היא ליניארית גם בשרשרת של גדרות מקוננות, והתצוגה החיה מרנדרת אותה בכל הקלדה. הספירה של האותיות משותפת עכשיו ל-isHebrewMajority ולחלוקה (letterCounts), ו-fenceEnd, שנשארה בלי צרכן, הוסרה. השומרים: tests/rtl-code-inner-fences.test.js משווה את ההחלטה על 20,000 בלוקים אקראיים להחלטה שאותו בלוק מקבל כש-markdown-it מרנדר אותו כבלוק רגיל, בודק שבתוך בלוק טקסט החלוקה זהה לחלוקה של התוכן שלו לבד, ומשווה את סוף הגדר ל-markdown-it דרך innerFences עצמה. tests/test_rtl_inner_fences_browser.py מודד בכרומיום שבלוק טקסט פנימי מימין, שהגרשיים בתחילת השורה, ושהקוד בתוכו משמאל. הפתקים, שיש להם רנדרר משלו, והעורך לא השתנו.

2026-11-09

  • fix (WebApp, docs): ערכה ציבורית צובעת בלוקי קוד כמו הערכה האישית שממנה פורסמה. בפרסום לציבורית ה-syntax_css של הערכה עבר דרך sanitize_codemirror_css, שמכיר רק את כללי CodeMirror, ולכן כללי highlight.js ו-Pygments נזרקו בשקט: בבלוק JSON ב-Markdown, למשל, המפתחות והמחרוזות של morass נצבעו בפלטה שנגזרת ממשתני הממשק ולא בתכלת ובחום של הערכה. אחרי: הפרסום והעדכון של ערכה ציבורית, וגם הוספת ערכה מוכנה, עוברים דרך sanitize_syntax_css, שמקבל את שלוש הקבוצות ש-parse_vscode_theme מייצר ואת הכלל הבסיסי .hljs עם הרקע של העורך, ו-tests/services/test_sanitize_syntax_css.py נכשל אם מחולל כותב כלל שהניקוי לא מכיר. כלל שבכל זאת לא עובר נספר: התשובה מחזירה syntax_rules_dropped, ובונה הערכות מציג אזהרה במקום הודעת הצלחה. syntax_css ארוך מהתקרה כבר לא נחתך באמצע אלא נדחה (syntax_css_too_long), וסוג שאינו מחרוזת כבר לא נשמר כ-CSS ריק (invalid_syntax_css). בדיקת הדפדפן של התצוגה החיה ושל תצוגת המסמך מודדת עכשיו גם ערכה ציבורית, ומשווה את בלוק הקוד שלה לזה של הערכה האישית. ערכה ציבורית שכבר פורסמה מתוקנת רק בפרסום מחדש. ובתיעוד: רשימת המשתנים המותרים ב-ערכות נושא מותאמות אישית – מדריך מקיף נמשכת מהקוד ולא מועתקת ביד. ראו הדגשת התחביר בפרסום.

  • fix (WebApp, docs): תמונה מאתר אחר במסמך Markdown מוצגת. ![alt](https://...) הוצג כתמונה שבורה בכל עמוד שמציג Markdown של המשתמש — תצוגת המסמך (/md/<id>) והשיתוף הציבורי שלה, התצוגה החיה בעריכה, בהעלאה ובעורך הציבורי, דפדפן הקוד וכרטיסי החיפוש בתיעוד. הסיבה: ה-CSP שכל עמוד מקבל כשאין לו מדיניות משלו (_add_default_csp ב-webapp/app.py) התיר תמונות רק מהאתר עצמו, והדפדפן חסם כל תמונה אחרת בלי שום עקבה בשרת. אחרי: img-src מתיר כל כתובת http/https, כמו בייצוא ובקישור השיתוף המעוצב (editor_export_meta_csp, ‏``styled_share_page_csp``). ההיתר במדיניות הגורפת ולא לכל עמוד לחוד: ההגבלה לא הגנה על אף עמוד, כי עם 'unsafe-inline' ב-script-src ובלי form-action קוד מוזרק כבר רץ ושולח מידע החוצה בטופס — נמדד ב-Chromium תחת המדיניות הקודמת: התמונה נחסמה, והטופס יצא. בדפדפן הקוד, עמוד rst מציג עכשיו את התמונות שלו במקום קישור ”תמונה: …“: scripts/docs_export_sections.py משאיר תמונה כתמונה בכתובת מלאה באתר, ו-_shown_text ב-services/docs_index_service.py לא סופר את ה-alt כטקסט של העמוד. עמוד שנכנס לאינדקס לפני השינוי מציג את הקישור עד שהאתר נבנה מחדש והאינדקס מתעדכן. ב-alt, סוגר מרובע לא יוצג בוובאפ: markdown-it 14.1.0 משמיט מה-alt כל תו שעבר escape (ההסבר בסקריפט). כרטיס בחיפוש בתיעוד מודד שוב את הגובה כשתמונה בו נטענת (settleDocsClip ב-webapp/static/js/global_search.js): עד עכשיו המדידה הייתה רק לפני הטעינה, וסעיף קצר עם תמונה גבוהה נשאר פתוח לכל גובהה, בלי קיפול. tests/test_markdown_external_images_browser.py פותח את /md/<id> ואת השיתוף הציבורי בכרומיום, עם הכותרת שהשרת שולח ותמונה ממקור אחר, ונכשל על הקוד הקודם בהפרת CSP.

  • fix (WebApp, docs): בכותרות העמודים ובאתר התיעוד השם הוא CodeKeeper. בתצוגה המקדימה של קישור לעמוד שדורש התחברות היה כתוב התחברות - Code Keeper Bot: מי שבונה את התצוגה המקדימה (וואטסאפ, טלגרם) אינו מחובר, ולכן הוא מופנה לעמוד ההתחברות, ולעמודים האלה אין תגיות og:, כך שהתצוגה לוקחת את ה-<title> של login.html. השם הוחלף בכותרות של כל עמודי הוובאפ, כולל ברירת המחדל ב-base.html והכותרת שלוח הפתקים קובע ב-JS. השם עם הרווח, Code Keeper, נשאר בסרגל העליון ובטקסטים של שיתוף, והקבצים שמייצאים מהאתר לא השתנו. באתר התיעוד התעדכנו הכותרת והפתיח של העמוד הראשי, ו-project ב-docs/conf.py: ממנו נגזרת ברירת המחדל של html_title ב-Sphinx, שממנה docs/_templates/layout.html בונה את כותרת הלשונית, ואת project עצמו התבנית מציגה בראש התפריט (נבדק בבנייה עם Sphinx 8.2.3 ו-sphinx-rtd-theme 3.0.2). העוגן של הכותרת בעמוד הראשי הוא עכשיו #codekeeper-api, והעוגן הקודם, #code-keeper-bot-api, נשמר בתווית מעל הכותרת, כך שקישור ישן ממשיך להגיע אליה. השם הישן הוחלף גם בתקצירים ובטקסטים של עמודי תיעוד אחרים, ובטקסט שמוצג באתר הוא נשאר רק בשם ה-workflow 🚀 Code Keeper Bot CI/CD, שמצוטט כמו שהוא כתוב ב-deploy.yml, וביומן הזה. tests/test_page_titles_brand.py מבקש בלי התחברות עמודים שדורשים התחברות ובודק את הכותרת שמגיעה אחרי ההפניה, ונכשל גם כשתבנית קובעת כותרת עמוד עם השם הישן.

  • fix (tests): הבדיקה שמדמה ספריות חסרות כבר לא משאירה את Pillow בלי פורמטים. tests/test_code_processor_optional_deps.py מחק את Pillow ועוד ספריות אופציונליות מ-sys.modules כדי לבדוק את החלופות ב-code_processor.py, ולא הגיע אליהן אף פעם, כי מחיקה לא מדמה ספרייה חסרה. הוא כן השאיר אחריו PIL.Image מחוק ותוספים טעונים, והבדיקה הבאה שייבאה את Pillow קיבלה PIL.Image בלי אף פורמט רשום. בריצה הסדרתית של deploy.yml, אחרי המיזוגים של #3663 ו-#3664, זה הפיל את test_link_preview_tags_point_to_absolute_urls_and_a_servable_image (ב-tests/test_home_page.py) על UnidentifiedImageError. עכשיו הבדיקה חוסמת את הספריות עם None ב-sys.modules דרך monkeypatch, טוענת עותק טרי של code_processor, ובודקת שכל החלופות באמת נכנסו לפעולה. ראו Testing Guide.

  • fix (CI): כשל בטסטים שרצים ברצף אחרי מיזוג פותח עכשיו אישו. notify-post-merge-issue.yml האזין רק ל-CI/CD Pipeline (ci.yml), שמריץ את הטסטים בכמה תהליכים במקביל. כשל שמופיע רק בריצה הסדרתית של deploy.yml (🚀 Code Keeper Bot CI/CD), כמו הכשל של UnidentifiedImageError שבעדכון שלמעלה, לא פתח אישו. עכשיו הוא מאזין לשניהם, וג’וב שדולג (skipped) כבר לא נחשב כשל: ב-deploy.yml יש ג’ובים שמדולגים בכל ריצה על main, ובלי זה כל מיזוג תקין היה פותח אישו, ואף אישו לא היה נסגר. לכל workflow יש אישו משלו, וריצה מוצלחת סוגרת אותו רק כשהקומיט שלה מכיל את הקומיט שנכשל. ב-deploy.yml ריצות של קומיטים סמוכים רצות במקביל, ובלי הבדיקה הצלחה של קומיט ישן, שמסתיימת אחרי הכשל, הייתה סוגרת את האישו של קומיט חדש יותר. ראו CI/CD Guide.

2026-11-08

  • fix (WebApp): הערה או מחרוזת בעברית בתוך בלוק קוד נקראת מימין לשמאל. כל שורה בבלוק קוד מוצגת משמאל לימין, ולכן הערה כמו // הצורה המינימלית של צומת hast שהתוסף צריך התפרקה לשני קטעים עבריים משני צדי hast, והם הוצגו בסדר הקריאה ההפוך. כשמחרוזת עברית והערה עברית היו באותה שורה, הן נדבקו לרצף אחד, וההערה הוצגה בתוך המחרוזת. עכשיו הגוף של הערה או מחרוזת שהעברית בה עוברת את הסף (isHebrewMajority, אותו סף כמו לבלוק שלם) נעטף ב-<span dir="rtl">, והדפדפן מבודד אותו מהשורה בלי שורת CSS. ההזחה, סימני ההערה (//, #, --, /*, *, <!--, */, -->, וגם ;, %, !, ' ו-REM של ini, ‏vbnet ושפות דומות — COMMENT_OPENERS) והשלד של המחרוזת (התחילית והגרשיים, כמו f" ו-""", וב-C++ גם ה-tag של R"tag( … )tag") נשארים בחוץ ובמקומם. החלוקה לגוף ולשלד סורקת תווים ולא ביטוי רגולרי: הביטוי של הבלוג גדל בחזקה שלישית באורך רצף רווחים, והערה עם כמה אלפי רווחים הייתה תוקעת את העמוד. ההחלטה היא לכל שורה, גם בהערה או ב-docstring של כמה שורות. מילה בודדת לא נעטפת: highlight.js צובע ערך YAML בלי גרשיים כטוקן לכל מילה, ועטיפה של כל מילה לבד הייתה הופכת את הסדר של מילים עבריות צמודות. בלוק עברי בלי שפה (pre.rtl-code) לא משתנה. העטיפה רצה בסוף SafeHighlight.highlightBlock (RtlCode.isolateHebrewTokens ב-webapp/static/js/utils/rtl-code.js), ולכן היא חלה בכל מקום שמדגיש דרכו: תצוגת ה-Markdown, התצוגה החיה, הייצוא המעוצב, דפדפן הריפו וספריית הסניפטים. הטקסט של הבלוק לא משתנה, וכפתורי ההעתקה מעתיקים את המקור. הרעיון הועבר מהבלוג של הפורטפוליו, עם שני שינויים, כי highlight.js בונה את הטוקנים אחרת מ-Shiki: טוקן אחד יכול להימשך על כמה שורות, והתחילית של מחרוזת היא חלק ממנו. בדרך: העטיפה של קוד בתוך בלוק עברי (wrapInnerFences) והעטיפה החדשה עוברות עכשיו באותה פונקציה, wrapTextRanges, במעבר אחד. הגרסה הקודמת גזרה כל קטע ב-Range משלו, וזה היה ריבועי באורך הטוקן: docstring עברי של אלפי שורות, עם קטע לכל שורה, לקח שניות ארוכות. תצוגת הסניפט של האדמין (admin_snippet_view.html) מדגישה עכשיו דרך SafeHighlight ולא ישירות דרך highlight.js, וספריית הסניפטים טוענת את rtl-code.js. השומרים: tests/rtl-code-tokens.test.js בודק מה נבחר מכל שורה, שהחלוקה הסורקת עונה בדיוק כמו הביטוי של הבלוג על הסימנים שהיו בו, ושהזמן ליניארי גם עם 20,000 רווחים באמצע הערה. tests/test_rtl_code_tokens_browser.py מודד בכרומיום, בדפדפן הריפו (בשני המסלולים שלו) ובספריית הסניפטים, מול ריצת בקרה בלי העטיפה, שכל ביטוי נקרא כמו פסקה עברית, שהשלד של השורה נשאר משמאל לימין, ושהקצה השמאלי של אף שורה לא זז. תצוגת ה-Markdown, התצוגה החיה בעמוד העריכה ותצוגת הסניפט של האדמין לא נמדדו בדפדפן: הן דורשות מונגו אמיתי, והן מדגישות דרך אותה פונקציה. tests/sticky-notes-target.test.js בודק שכל עמוד שטוען את safe-highlight.js טוען גם את rtl-code.js, ושאף קובץ לא מדגיש ישירות דרך highlight.js.

  • feat (WebApp): קישור לעמוד הבית מקבל תצוגה מקדימה עם תמונה — בוואטסאפ, בטלגרם, בלינקדאין ובאתרי אינדקס. עד היום לא היו ב-index.html תגיות Open Graph, ולכן קישור ל-/ הוצג בלי תמונה, ואתר אינדקס כמו bulit-ai.com הציג איור ברירת מחדל במקום תמונה של המוצר. עכשיו לעמוד יש description, תגיות og: עם כתובת מלאה ב-og:url וב-og:image (_webapp_base_url, כמו בגלריה), תמונה ב-webapp/static/og/og-image.jpg עם מזהה הגרסה (?v=), ו-twitter:card מסוג summary_large_image. og:title נפתח בתו RLM (U+200F): בתצוגה המקדימה, הכיוון של השורה נקבע לפי האות החזקה הראשונה, והכותרת מתחילה ב-”CodeKeeper“, ולכן בלי התו כל השורה הוצגה משמאל לימין, והמילה ”AI“ שבאמצע העברית הפכה את ”ול-AI שלך“. בגלריה אין מילה באנגלית באמצע, ולכן היא לא צריכה את התו. התו הוא ”אות“ מימין לשמאל שאינה נראית, והנוסח עצמו וה-<title> של הלשונית לא השתנו. tests/test_home_page.py מבקש את התמונה מהכתובת שב-og:image, ובודק שהיא בגודל ובסוג שהתגיות מצהירות ובתקרות של וואטסאפ, ושהתגיות בתוך החלון של ה-HTML שוואטסאפ קורא.

  • feat (WebApp): קישור לעורך הציבורי מקבל תמונה בתצוגה המקדימה. לעורך שב-/markdown-editor כבר היו כותרת, תיאור וכתובת לתצוגה המקדימה, אבל בלי תמונה. עכשיו יש og:image מ-webapp/static/og/markdown-editor.jpg — צילום של העורך עם התצוגה החיה — בכתובת מלאה ועם מזהה הגרסה, יחד עם הסוג, הגודל והתיאור של התמונה, ו-twitter:card מסוג summary_large_image. הבדיקות של התמונה, המשותפות לעמוד הבית ולעורך, עברו לקובץ אחד, tests/_link_preview.py. ראו העורך הציבורי (/markdown-editor).

  • fix (tests): המונה של בלוקי ה-CSS בטסטים של האאוטליין מתעלם מהערות Jinja. _style_bodies ב-tests/test_mcp_outline.py סופר את בלוקי ה-CSS שבתבנית בנפרד מהסורק, כדי לבדוק אותו. הוא לא מחק הערות Jinja, ולכן <title> שהוזכר בהערה בעמוד הבית נראה לו כתגית שגוף שלה נמשך עד סוף הקובץ, והוא ספר אפס בלוקים בעמוד מול מה שהסורק מצא. הסורק צדק: Jinja מוחק את ההערה בזמן הרינדור, והדפדפן לא רואה אותה. עכשיו המונה מוחק הערות Jinja לפני שהוא מנטרל את מה שהדפדפן לא מפרש כ-HTML, ו-test_a_tag_named_inside_a_jinja_comment_does_not_hide_the_style_after_it נופל על המונה הקודם.

  • change (WebApp): עמוד הקישור הציבורי מהעורך — בלי ההודעה על תוכן של גולש, ותיאור קצר ליד ”צור קישור“. בראש עמוד הקישור הייתה הודעה שהמסמך נכתב על ידי גולש ולא נבדק, והיא הוסרה: הקישור נועד לשלוח עמוד מעוצב למי שצריך אותו, וההודעה פגעה בעמוד. noindex וסימון הקישורים כתוכן של גולש נשארו. ליד הכפתור כתוב עכשיו ”קישור ציבורי (של עמוד ה-HTML המעוצב) לשיתוף“. ראו הקישור הציבורי (”צור קישור“).

  • feat (WebApp): קישור ציבורי מהעורך הציבורי — ”צור קישור“. בעורך שב-/markdown-editor אפשר היה רק להציג או להוריד HTML מעוצב. אחרי: בשורה של ”HTML מעוצב“ יש ”צור קישור“, ששומר את הטקסט בשרת ונותן קישור קבוע לעמוד מעוצב בערכה שנבחרה, וקישור מחיקה שמוצג פעם אחת. זו הפעולה היחידה בעמוד ששולחת את הטקסט לשרת, ורק בלחיצה עליה. נשמר הטקסט ולא HTML, כי אי אפשר לסמוך על HTML שמגיע מהדפדפן: מי שפותח את הקישור מקבל את השלד של הערכה, והרינדור נעשה אצלו, באותו מנוע ועם אותן הגנות של העורך. בעמוד יש הודעה שהתוכן נכתב על ידי גולש, noindex, וה-CSP של קישורי המחוברים. מגבלות: עד 1MB למסמך, 3 קישורים לשעה ו-9 ליום לכל גולש, ו-30 ביום בכל האתר — התקרה הכוללת נספרת במסד, ולכן חלה גם על מי שעוקף את המגבלה לפי כתובת. היא מגבילה את קצב הגידול של המסד ולא את הגודל הכולל: הקישורים קבועים, ומה שלא נמחק מצטבר. אדמין מוחק קישור שדווח מ-/admin/styled-shares. ראו הקישור הציבורי (”צור קישור“).

  • change (WebApp): הכותרת של העורך הציבורי — ”עורך Markdown בעברית“. המשפט שמתחתיה הוא עכשיו ”בלי הרשמה. הטיוטה נשמרת בדפדפן, גם אם תצא ותחזור.“, בלי החלק על הצדדים: רואים אותם ממילא, ובטלפון, שבו העורך והתצוגה מוצגים אחד בכל פעם, הוא היה שגוי. ה-<title> והתיאור לגוגל לא השתנו.

  • fix (WebApp): טקסט ששותף כבר לא יכול לרוץ כסקריפט בעמוד של האתר — X-Content-Type-Options: nosniff בתשובות של הוובאפ. /share/<id>/download מגיש כ-text/plain את מה שבעל השיתוף כתב, ובלי הכותרת Chromium הריץ אותו כסקריפט כשעמוד באתר טען אותו ב-<script src>, גם תחת script-src 'self', כי הכתובת מהאתר שלנו (נמדד ב-8.11.2026 ב-Chrome for Testing 153, tests/test_nosniff_browser.py). אחרי: _add_nosniff ב-webapp/app.py מוסיף את הכותרת לכל תשובה שעוברת דרך Flask, והדפדפן מסרב להריץ סקריפט שהסוג שלו אינו JavaScript ולהחיל גיליון סגנון שהסוג שלו אינו text/css. נתיב שקבע את הכותרת בעצמו (raw_html, ‏``raw_svg``) נשאר עם מה שקבע, בלי עותק שני. הסקריפטים וגיליונות הסגנון של האתר כבר מוגשים בסוג הנכון, וטסט בודק כל קובץ .js ו-.css תחת webapp/static. ראו סוג התוכן בלי ניחוש — X-Content-Type-Options: nosniff.

  • fix (חיפוש סמנטי): שגיאת 5xx רגעית מ-Gemini כבר לא מחזירה קובץ לתור ההטמעה. בלוגים נראתה ריצה של ה-worker שבה 13 בקשות הטמעה עברו והבקשה ה-14 קיבלה 503. generate_embedding_with_status ניסה שוב רק אחרי 429 ואחרי timeout, ולכן ה-503 חזר מיד, ה-worker החזיר את הקובץ לתור עם needs_embedding=True, ובסבב הבא נשלחו שוב כל הצ’אנקים שלו, גם אלה שכבר הצליחו. אחרי: גם 5xx מקבל ניסיון חוזר, בתוך MAX_RETRIES ועם השהיה שגדלה מניסיון לניסיון (_retry_backoff_seconds, אותה הסלמה כמו אחרי 429). כל 4xx מלבד 429 — ובהם 400 ו-404 — חוזר מיד, כמו שחזר עד היום. גם החיפוש של המשתמש עובר דרך הפונקציה הזו: על 503 רגעי הוא מקבל עכשיו תוצאות סמנטיות במקום לרדת לחיפוש טקסט, וב-5xx מתמשך הוא יורד לחיפוש טקסט אחרי MAX_RETRIES בקשות, וההמתנה שנוספת לו היא סכום ההשהיות של _retry_backoff_seconds בין הבקשות.

  • perf (חיפוש סמנטי): ה-worker של ההטמעות שולח את הצ’אנקים של קובץ באצוות, ולא בקשה לכל צ’אנק. קובץ של 14 צ’אנקים היה 14 בקשות ל-embedContent, עם מרווח של EMBEDDING_MIN_INTERVAL_SECONDS ביניהן. אחרי: הצ’אנקים נשלחים ב-batchEmbedContents (EmbeddingService.embed_batch), עד paced_batch_size בקריאה. ב-8.11.2026, בהרצה ידנית של ה-worker מול ה-API החי, קובץ של 18 צ’אנקים נשמר בבקשה אחת של 0.84 שניות, וקובץ של 36 בשתי בקשות. הקצב: התיעוד של Gemini לא אומר איך אצווה נספרת במכסות, ולכן כל צ’אנק תופס מרווח בשער, והקצב הממוצע של צ’אנקים — וגם של טוקנים — נשאר כמו קודם. אצווה מוגבלת ל-PACED_BATCH_WINDOW_SECONDS של מרווחים, כדי שהפרץ בדקה אחת לא יעבור פי 1.5 מהממוצע. ה-worker מחכה לשער לפני שהוא בודק שהקובץ הוא עדיין הגרסה האחרונה, ולא בין הבדיקה לכתיבה. מה נשמר: טקסט ארוך מדי נדחה לפני השליחה. אצווה שנדחתה ב-400 (Gemini דוחה אצווה שלמה בגלל פריט אחד) נחצית עד שהצ’אנק הפסול מבודד, ורק הוא מדווח ב-embedding_chunk_rejected. אבל 400 מגיע גם על בקשה פסולה כולה, למשל מפתח לא תקף או מימד שהמודל לא תומך בו. לכן כשאף בקשה של הקובץ עוד לא התקבלה, ה-worker שולח קודם בקשת ביקורת עם טקסט תקין באותן הגדרות. אם גם היא נדחית, הבאץ« נעצר בלי לגעת בקבצים, נשלח האירוע embedding_request_rejected ברמת error, וה-worker ממתין EMBEDDING_QUOTA_PAUSE_SECONDS, כמו במכסה. עד היום, גם בבקשה לכל צ’אנק, 400 כזה דחה את כל הצ’אנקים של כל קובץ בתור, מחק את הצ’אנקים הקיימים שלו וסימן אותו כגמור. 429 עוצר את הבאץ«, 404 מפעיל self-heal ומתחיל את הקובץ מחדש, ו-422 של מימד שונה שולח את האצווה ואת שאר הקובץ בלי מימד קבוע. קובץ לא נשמר אף פעם עם וקטורים בשני מימדים. בדרך: הבקשה, בדיקת הקלט והפענוח של אצווה משותפים ל-SyncEmbeddingClient ולגרסה האסינכרונית, וללקוח האסינכרוני יש עכשיו לולאת ניסיונות אחת (_post_with_retries). generate_embeddings_batch, ששלח טקסט אחד בכל פעם ושאף קוד לא קרא לו, הוסר. לא נכלל: כשקובץ מתחלק לכמה קריאות ואחת מהן נכשלת זמנית, מה שהצליח נשמר, אבל בסבב הבא כל הצ’אנקים של הקובץ נשלחים שוב.

  • change (חיפוש סמנטי): ה-worker של ההטמעות לא שולח יותר בקשה נפרדת למטא-דאטה של הקובץ. אחרי הצ’אנקים של כל קובץ נשלחה עוד בקשה, על שם הקובץ, התיאור, התגיות והשפה בלבד, והתוצאה נשמרה ב-snippetEmbedding — שדה שאף קוד בריפו לא קרא: החיפוש הווקטורי רץ על chunkEmbedding, והמטא-דאטה כבר נכנסת לכל צ’אנק דרך create_embedding_text. הבקשה עלתה קריאה ל-Gemini לכל קובץ, וכשל זמני בה החזיר לתור קובץ שכל הצ’אנקים שלו כבר נשמרו. אחרי: הבקשה הוסרה, ו-update_snippet_embedding_status כבר לא מקבל את הווקטור. מסמכים שעובדו לפני כן עדיין נושאים את השדה, וההיטלות וה-MCP ממשיכים להחריג אותו — ראו SNIPPET_SEMANTIC_FIELDS ב-database/schemas.py.

2026-11-06

  • feat (WebApp): קישור השיתוף המעוצב נבנה בדפדפן של מי שפותח אותו. ”העתק קישור“ שמר עמוד שהשרת בנה ב-Python-Markdown, ולכן מי שקיבל את הקישור ראה משהו אחר ממה שבעל הקובץ ראה בתצוגה ובקובץ שהוריד. אחרי: הקישור שומר את הטקסט של הגרסה ששותפה ותמונה של הערכה ברגע השיתוף, והעמוד מרנדר אותם באותו מנוע כמו התצוגה החיה (styled-share-view.js). העמוד מוגש עם CSP מחמיר — default-src 'none', ‏``script-src »self«`` עם ה-hash של סקריפט ההעתקה, בלי טפסים ובלי הטמעה — כשכבה שנייה מעל המנוע, ועם no-cache במקום max-age של שעה. טקסט מעל STYLED_SHARE_MAX_MARKDOWN_BYTES נדחה ב-413, כי הרינדור קורה אצל מי שפותח. סקריפט ההעתקה משאיר עכשיו window.ckAttachCopyButtons לתוכן שנכנס אחריו, וה-hash הקודם שלו נשמר לקישורים שכבר נוצרו. קישורים קיימים מוגשים כמו שנשמרו, ו-STYLED_EXPORT_BROWSER_RENDER=false יוצר שוב קישורים בצורה הקודמת. ראו קישור השיתוף.

  • feat (WebApp): רשימת הקישורים המעוצבים של קובץ, וביטול. עד היום אי אפשר היה לבטל קישור מעוצב — גם קישור קבוע, בלי תוקף. אחרי: בחלון הייצוא יש לשונית ”קישורים“ עם כל הקישורים שהמשתמש יצר לאותו שם קובץ, מכל הגרסאות שלו, ומכל אחד אפשר להעתיק או לבטל. הביטול מוחק את הקישור (POST, רק בעל הקישור), ומי שיפתח אותו יקבל 404. נוסף אינדקס styled_shares_by_file לרשימה. ראו הרשימה והביטול.

  • fix (WebApp): שיתוף מעוצב של קובץ גדול שומר את התוכן, ול-styled_shares יש TTL ואינדקס ייחודי. קובץ גדול שומר את הטקסט ב-content ולא ב-code, ושיתוף שלו שמר עמוד ריק. קישור זמני שפג נשאר במסד לתמיד, כי אף אינדקס לא מחק אותו, ו-token לא היה ייחודי. אחרי: השיתוף קורא את הטקסט משני השדות, ושני האינדקסים מוצהרים בעלייה (styled_shares.py), עם אירוע db_styled_shares_index_missing כשאחד מהם נכשל.

  • feat (WebApp): ייצוא HTML מעוצב מעמוד הקובץ נבנה בדפדפן, באותו מנוע כמו התצוגה החיה. ”תצוגה מקדימה“ ו“הורד HTML“ בחלון הייצוא של המחוברים המירו את הקובץ בשרת, ב-Python-Markdown, שאינו מכיר חלק מהתחביר של התצוגה — התראות, מארקר, צ’קליסט, נוסחאות ותרשימים יצאו אחרת ממה שנראה בעורך. אחרי: הדפדפן מרנדר את הקובץ ב-renderForExport, כמו בייצוא מהעורך הציבורי, והשרת מגיש רק שלד עם שם הקובץ והערכה (/export/styled/<file_id>/skeleton, תחת אותן הרשאות). הטקסט נלקח מהעמוד, ובקובץ מעל 1MB מ-/download, שמחזיר את אותה גרסה. המנוע יושב בעמוד בתוך <template> ונטען רק בייצוא הראשון. ערכת ה-Mermaid מגיעה עם רשימת הערכות (export_mermaid_theme, הכרעה אחת עם העורך), וצבעי התחביר בכל סוג של ערכה הם של highlight.js — של הערכה, של ערכת VS Code שיובאה, או הפלטה שנגזרת מהמשתנים. STYLED_EXPORT_BROWSER_RENDER=false מחזיר את שני הכפתורים לייצוא שבשרת, שנשאר כמו שהוא, והמתג נכנס ל-ETag של עמוד הקובץ כדי שגם עמוד שמור יקבל אותו. ”העתק קישור“ עדיין נבנה בשרת. ראו ייצוא HTML מעוצב מעמוד הקובץ.

2026-11-05

  • change (WebApp): הכפתור ”ייצוא HTML“ בעורך הציבורי נקרא עכשיו ”HTML מעוצב“. הכפתור נשאר כמו שאר הכפתורים (btn-secondary, עם אותה מסגרת, אותו צבע טקסט ואותו אייקון), ומתחת לטקסט נוסף לו רקע עדין של שלושה גוונים מהערכה (--primary, ‏``–btn-primary-bg`` ו---warning, כל אחד ב-30%), שנע לאט מצד לצד, הלוך וחזור. מי שביקש במכשיר פחות תנועה (prefers-reduced-motion) רואה את אותו רקע בלי תנועה. ראו ייצוא HTML מעוצב.

  • feat (WebApp): ערכת ייצוא חדשה בעורך הציבורי — Everforest Dark. ב“ייצוא HTML“ של /markdown-editor אפשר לבחור עכשיו גם ב-Everforest Dark: כהה ורכה, בגווני יער, עם כותרות תכלת. היא נוספה ל-EXPORT_PRESETS ול-EXPORT_THEME_IDS, ולכן היא מופיעה גם בחלון הייצוא של המחוברים. בדיוק כמו morass ו-Pen Paper Coffee UI: המשתנים הם הערכים שייבוא קובץ הערכה (everforest-dark-v2.json ב-CodeKeeper) נותן להם, כולל רקע הקוד #1e1e1e, ברירת המחדל הכהה של הייבוא, כי בקובץ אין terminal.background. הקו מתחת ל-H2 וצבעי הכותרות של התבנית נשארים, ההתראות מקבלות את הצבעים ממשתני הערכה, והתרשימים מצוירים בערכה הכהה של Mermaid. צבעי התחביר נגזרים מה-tokenColors של הערכה, אבל כמחצית מהרשומות שם כתובות כמחרוזת של כמה scopes מופרדים בפסיק, והמחוללים ב-services/theme_parser_service.py עוד לא מפצלים מחרוזת כזו. לכן חלק מהקוד לא נצבע, למשל ההערות. על טקסט ההדגמה, 76% מהתווים ש-highlight.js מסמן בבלוקי הקוד מקבלים צבע של הערכה, ובשתי הערכות האחרות לפחות 90% (נמדד ב-5.11.2026 ב-test_the_downloaded_file_works_on_its_own_without_network, שהסף שלו נקבע עכשיו לכל ערכה בנפרד). הרשימה נשמרה בדיוק כמו בקובץ, כדי שתיקון במחוללים יחול עליה. הפירוט בכרטיס ”מחוללי צבעי התחביר — scope עם פסיקים וכיוון ההתאמה“ בלוח ה-issues ב-CodeKeeper. ראו ייצוא HTML מעוצב.

  • change (WebApp): מתחת לתצוגה החיה בעמודי העריכה וההעלאה — רק הודעת שגיאה. שורת המידע (markdown • 8.6 KB • 207ms) ו“התצוגה מעודכנת.“ הוסתרו, כמו בעורך הציבורי. כשהרינדור נכשל ההודעה כן מוצגת, כדי שתצוגה ישנה לא תיראה תקינה. הכלל עבר מהעורך הציבורי ל-split-view.css, ולכן הוא אחד לשלושת העמודים. ראו מערכת ערכות הנושא והטוקנים החדשה, בסעיף על Split View.

  • feat (WebApp): ייצוא HTML מעוצב בעורך הציבורי, בלי שהטקסט נשלח לשרת. ב-/markdown-editor נוסף ”ייצוא HTML“: בוחרים ערכה — morass או Pen Paper Coffee UI — ו“הצג“ פותח את הקובץ בטאב חדש, או ”הורד HTML“ מוריד אותו. השרת מגיש רק שלד מעוצב בלי תוכן (/api/markdown-editor/export-skeleton/<theme_id>), והדפדפן מרנדר את המסמך באותו מנוע כמו התצוגה החיה, ברינדור נפרד, ומכניס אותו לשלד — כך שהייצוא עובד גם כשהתצוגה כבויה, והתרשימים מצוירים בערכה של הקובץ. בקובץ אין באנר עליון, הכיתוב בתחתית הוא ”נוצר אוטומטית ע“י Code Keeper“, יש בו CSP שחוסם הכול חוץ מסקריפט ההעתקה, העיצוב שבתוכו, הגופנים ותמונות, ו-KaTeX עם הגופנים נכנס רק כשיש נוסחה. עוגן מפורש נבדק מול התוכן ולא מול העמוד, כי התצוגה החיה כבר מחזיקה את אותם מזהים. שתי הערכות נוספו ל-EXPORT_PRESETS ומופיעות גם בייצוא של המחוברים, וצבעי התחביר של כל אחת נגזרים מה-tokenColors שלה: על טקסט ההדגמה, ב-highlight.js של הייצוא מהעורך 98% מהטוקנים ב-morass ו-99% ב-Pen Paper Coffee UI מקבלים צבע של הערכה (נמדד ב-5.11.2026; test_the_downloaded_file_works_on_its_own_without_network דורש לפחות 90%); בייצוא של המחוברים, שעובר דרך Pygments, הכיסוי נמוך יותר עד שתתוקן הירושה בין סוגי הטוקנים ב-generate_pygments_css_from_tokens. בדרך: כל הרינדורים של Mermaid עוברים בתור אחד, והמזהים שלהם ממונה אחד, כדי שייצוא במקביל לתצוגה לא יערבב ערכות ומזהים — ורינדור של התצוגה שכבר הוחלף לא מצייר את מה שנשאר לו, כדי שלא יעכב את התור; וסקריפט ההעתקה של HTML מעוצב מעתיק ב-textContent — innerText הוסיף שורה ריקה סביב קטע קוד בתוך בלוק קוד בעברית — וקישורי שיתוף מעוצבים שכבר נוצרו ממשיכים להתיר את הגרסה הקודמת שלו. בייצוא של המחוברים השתנה רק הסקריפט: ב-5.11.2026, על שש ערכות (ארבע ערכות הייצוא הקודמות, ערכה מהגלריה וה-fallback) ושני מסמכים, עם תוכן עניינים ובלעדיו, ה-HTML זהה בייט-לבייט לזה שלפני השינוי מחוץ לסקריפט. ראו ייצוא HTML מעוצב.

2026-11-04

  • feat (WebApp): גלילה מסונכרנת בין העורך לתצוגה החיה. בעורך הציבורי ובעמודי העריכה וההעלאה, גלילה בעורך מביאה את התצוגה לאותו מקום בטקסט, וגלילה בתצוגה מביאה את העורך. ההתאמה היא לפי שורות ולא לפי אחוזים, כמו בגלילה של /compare/paste: כל בלוק בתצוגה מסומן בשורות המקור שלו, ולכן גם אחרי תמונה, תרשים או טבלה שני הצדדים מראים את אותו טקסט. על טקסט ההדגמה, גלילה לפי אחוזים הייתה מראה מקום אחר במרחק של עד 704px, והסנכרון סוטה בעד 1.5px (נמדד ב-4.11.2026 ב-test_scrolling_the_editor_brings_the_preview_to_the_same_heading). גם הכותרת של קונטיינר (::: note, ::: details) ושל אלרט (!!! note) מתיישרת, ובזמן רינדור הצד השני מחכה לסופו וזז פעם אחת. בהתחלה ובסוף שני הצדדים מתיישרים יחד, והצד שגוללים בו לא נמשך אחורה. בעורך הפשוט, ובטלפון במעבר בין הלשוניות, אין סנכרון (החלטת המשתמש). ההסבר ב-מערכת ערכות הנושא והטוקנים החדשה, בסעיף על Split View. הסימון של השורות עבר מתוך md_preview.html לקובץ משותף, md-source-lines-plugin.js, ותצוגת המסמך מקבלת ממנו בדיוק את אותו HTML — נבדק על כל קובצי ה-Markdown בריפו.

  • feat (MCP): קריאה לפי איידי אומרת אם הגרסה שנקראה עדיין האחרונה — file.is_latest ב-codekeeper_get_file. קריאה לפי file_id מחזירה גרסה מסוימת גם כשכבר נשמרה חדשה, ושום דבר בתשובה לא אמר את זה — סוכן שהחזיק איידי מסשן קודם עבד על תוכן ישן בלי לדעת. עכשיו כל תשובה של קריאה לפי file_id נושאת file.is_latest: true כשזו הגרסה שקריאה לפי השם מחזירה, false כשיש אחרת (ואותה קוראים לפי file_name), null כשאי אפשר לקבוע (השאילתה נכשלה, או שני מסמכים פעילים חולקים את המספר העליון), ונעדר לגרסה שבסל. בכל מצבי הקריאה ובסירובים שנושאים file. ההשוואה היא על _id, בשאילתה שמחזירה רק מזהים ומספרי גרסה, מה-primary ולא מהקאש, באותו מסנן ובאותו מיון של הקריאה לפי שם. קריאה לפי file_name, עם version או בלעדיו, לא השתנתה. ”בסל“ מוגדר עכשיו במקום אחד (ACTIVE_VERSION_FILTER ו-is_active_version ב-file_versions.py), והמסלול של Repository._fetch_latest_version לאוסף בזיכרון, שרץ בטסטים, מסנן לפיו כמו השאילתה. ראו האם זו הגרסה האחרונה — is_latest.

  • fix (WebApp): פתק על קובץ נפתח בגרסה האחרונה של הקובץ, ולא בגרסה שעליה נוצר. הקישור הקבוע /note/<id> — שהתראת התזכורת, התראת התגובה והפעמון פותחים — הפנה ל-file_id שבפתק, כלומר לגרסה שהייתה האחרונה כשהפתק נוצר; כל שמירה של קובץ יוצרת גרסה עם מזהה חדש. אחרי: ההפניה היא לגרסה הפעילה האחרונה לפי שם הקובץ שבפתק (שינוי שם בבוט מעדכן אותו), ובפתק ישן בלי שם — לפי השם של הגרסה השמורה. קובץ בסל, וקובץ גדול (שאין לו גרסאות), נפתחים כמו קודם. ”הגרסה האחרונה“ היא עכשיו הגדרה אחת, _LATEST_VERSION_SORT, שמכריעה גם בין שתי שמירות עם אותו מספר גרסה — ובאנר הגרסה וההיסטוריה עונים על ”האם זו הנוכחית“ לפי _id של המסמך שנבחר, כך שבתיקו רק אחד מהשניים נחשב נוכחי, והאחר מקבל באנר ”זה עותק נוסף של גרסה N“. ראו הקישור הקבוע של פתק על קובץ: הגרסה האחרונה, בזמן הקריאה.

  • feat (WebApp): גם בדשבורד — שם הפתק בכרטיס ”הגדרות פוש“, בציר הזמן וב“פתקים אחרונים“. ”שליחה אחרונה“ ו“התזכורת הבאה“ בכרטיס, שורות התזכורת בציר הזמן והרשימה של הפתקים האחרונים הציגו תמיד את השורה הראשונה של הפתק, גם כשיש לו שם: לדשבורד היה עותק משלו של הכלל (_extract_note_preview), וההיטלה של _lookup_notes_map לא שלפה את title. אחרי: שלושתם נשענים על sticky_notes_target.note_label, כמו הפוש והפעמון. ראו השם של פתק בשורה אחת: פונקציה אחת לפוש, לפעמון ולדשבורד.

  • change (WebApp): פתק בלי שם מוצג בשורה הראשונה שלו, עד 80 תווים — בהתראה, בפעמון ובדשבורד. בהתראת התזכורת ובחלונית הפעמון הוצגו שש המילים הראשונות, ובדשבורד השורה הראשונה. אחרי: כלל אחד בכל המקומות — השורה הראשונה שיש בה טקסט, ברווחים מכווצים, עד NOTE_LABEL_MAX_CHARS תווים (התקרה של שם), ו“…“ כשהיא ארוכה יותר.

  • fix (WebApp): ”דחה 10 דק׳“ בהתראת תזכורת רק דוחה, ולא פותח את הפתק. הלחיצה קבעה דחייה של 10 דקות וגם פתחה את הפתק, כי snooze_10 היה ברשימת הפתיחה של ה-Service Worker כפולבק ל“מיפוי כפתורים שגוי“ (נוסף בינואר 2026). מיפוי כזה לא קיים: לחיצה על כפתור מגיעה ל-SW עם השם שלו. אחרי: דחייה שולחת את בקשת הדחייה ובזה הלחיצה נגמרת, וההתראה נסגרת. SW_VERSION 2.3.0; מכשיר עם SW ישן מתעדכן בכניסה הבאה לאתר. ראו הלחיצה על ההתראה.

  • fix (WebApp): לחיצה על התראת פוש פותחת תמיד לשונית חדשה, ולא משתלטת על לשונית פתוחה. ”פתח פתק“ בתזכורת של פתק לוח, ולחיצה על התראת תגובה של סוכן, ניווטו את הלשונית של האתר שהייתה אחרונה בפוקוס — כלומר הלשונית שעבדו בה. והתראת קובץ מה-MCP ניווטה לשונית שכבר הציגה את אותו קובץ. אחרי: בכל סוגי ההתראות הפתיחה היא clients.openWindow, לשונית חדשה, ושום לשונית פתוחה לא זזה. זה גם סוגר מקרה שבו לשונית שה-SW אינו שולט בה גרמה לפתיחת דף הבית במקום הפתק. וגם הדיווחים של ה-SW לשרת כבר לא עומדים לפני הפתיחה: ב-Chromium יש לחלון עשר שניות מהלחיצה, ודיווח שממתינים לו ברשת איטית יכול היה לאכול אותן.

  • feat (WebApp): בהתראת התזכורת ובחלונית הפעמון — שם הפתק, ובלעדיו תחילת התוכן. שתיהן הציגו את 6 המילים הראשונות של התוכן גם לפתק שיש לו שם, כי הן נכתבו לפני שלפתקים היו שמות, כל אחת בעותק משלה. אחרי: שתיהן נשענות על sticky_notes_target.note_label — שם הפתק, ובלעדיו תחילת התוכן כמו קודם — עם תקרה בתווים, כי ”מילה“ יכולה להיות קישור ארוך. בחלונית כבר לא מתווסף ”…“ קבוע לכל שורה; ”…“ מופיע רק כשהשורה קוצרה. ראו השם של פתק בשורה אחת: פונקציה אחת לפוש, לפעמון ולדשבורד.

  • fix (WebApp): שמירה עם שם חדש בעמוד העריכה יוצרת קובץ חדש, שלא יורש מהקובץ שנערך. השמירה כותבת את הקובץ תחת השם החדש, והקובץ שנערך נשאר פעיל עם כל הגרסאות שלו. אבל עד היום עברו לקובץ החדש תאריך היצירה של הקובץ שנערך — ולכן הוא לא הופיע בראש /files, שממוין לפי created_at — כל הפתקים שלו, השיוך שלו לאוספים, סימון המועדף והנעיצה, והנעיצה גם הוסרה ממנו. אחרי: בשם שעדיין לא קיים נוצר קובץ בגרסה 1, עם תאריך יצירה של זמן השמירה, בלי פתקים, אוספים, מועדף ונעיצה, ועם מה שבטופס: תגיות, תיאור, קישור למקור ותמונות. שדה תגיות או תיאור שנמחק בטופס נשאר ריק, ותיאור שנשאר נחשב ”נקבע עכשיו“ (description_age_versions שווה 0). הקובץ שנערך לא משתנה. בשם שכבר תפוס על ידי קובץ אחר השמירה נכנסת כגרסה הבאה שלו, וממלאת שדות ריקים, תאריך יצירה, מועדף ונעיצה רק ממנו. לא השתנו שמירה באותו שם, ועריכה של קובץ גדול — שם החלפת השם היא שינוי שם של אותו מסמך, והפתקים והאוספים עוברים איתו. favorite_fields_for_new_version ו-file_is_favorite מקבלות עכשיו שם קובץ אחד. ראו מבנה נתונים מפורט (Detailed Database Schema).

  • fix (WebApp): הלשוניות ”עורך“ / ”תצוגה חיה“ בטלפון — רק כשהתצוגה דלוקה, ועם סימון ברור בכל ערכה. בכל עמודי העורך (העורך הציבורי, העריכה וההעלאה), עד 767px. הלשוניות הוצגו גם כשהתצוגה החיה כבויה, והשנייה, ”תצוגה“, פתחה אז פאנל ריק. והנבחרת קיבלה את צבע הטקסט של התצוגה החיה, כמעט לבן: בערכה בהירה היא כמעט נעלמה (ניגודיות 1.42 ב-Rose Pine Dawn), ובניגודיות גבוהה שתי הלשוניות נראו אותו דבר. אחרי: השנייה נקראת ”תצוגה חיה“, ושתיהן מוצגות רק כשהתצוגה דלוקה. הנבחרת בצבע הטקסט של שורת הכלים, מודגשת, עם קו תחתון באותו צבע ורקע של אותו צבע בעוצמה נמוכה; בניגודיות גבוהה היא הפוכה, לבן ושחור עליו. נמדד ב-2026-11-04, בדגימת פיקסלים, בעשר ערכות (שבע מובנות, מיובאת בהירה, מיובאת כהה, והערכה הציבורית של העורך): הטקסט של הנבחרת ב-3.98 לפחות (ב-Rose Pine Dawn 4.77), הקו באותה ניגודיות, והלא נבחרת כמו לפני השינוי. סטייה מהתוכנית: התוכנית הייתה קו בצבע ההדגשה של הערכה (--primary), לא נבחרת דהויה, ורקע חזק יותר; במדידה הקו נבלע ב-Classic וב-Forest (1.0), הדהייה הורידה את הלא נבחרת מתחת ל-4.5 בארבע ערכות, והרקע החזק הוריד את הנבחרת ל-3.6 ב-Classic וב-Dim. ראו מערכת ערכות הנושא והטוקנים החדשה, בסעיף על Split View.

  • fix (WebApp): בטלפון ”הדבק“ ברוחב הטקסט שלו, וכפתור ה-MD באותה שורה איתו. בעמודי העריכה וההעלאה הכפתורים התרחבו למלא את השורה, ו“הדבק“, שירד לשורה שנייה לבד, תפס את כולה; כפתור ה-MD ירד לשורה שלישית, וברוחב שבו ”הדבק“ נכנס לשורה הראשונה (390 ו-430) — לשורה משלו. אחרי: כל כפתור ברוחב הטקסט שלו, ו“הדבק“, ההודעה הזמנית ו-MD הם יחידה אחת שלא נשברת: בשורה הראשונה ”בטל / בצע שוב / בחר הכל / העתק“, ובשנייה ”הדבק“ ו-MD (נמדד ב-360, 390 ו-430). גם ההודעה הזמנית צפה עכשיו בטלפון, ולא מורידה את העורך (עד היום: 13px בעורך הציבורי, 25px בעמוד העריכה). במחשב, כשהתצוגה החיה כבויה, השורה זהה לקודמת בכל רוחב שנמדד (820 עד 1366); כשהיא דלוקה והשורה בחצי של העורך, MD באותה שורה עם ”הדבק“, בקצה — ולא לבד מעל הכפתורים (1024 עד 1180) או בשורה אחרת מ“הדבק“ (820 ו-900). ראו ⌨️ עורך קוד (WebApp Editor).

  • change (WebApp): בעורך הציבורי, גלילה בסוף העורך או התצוגה ממשיכה לגלול את העמוד. מאוקטובר 2026 הגלילה נעצרה בסוף (overscroll-behavior: contain), והכלל הוסר לבקשת המשתמש — עכשיו זה כמו בעמודי העריכה וההעלאה.

  • fix (WebApp): בעמודי העריכה וההעלאה אין יותר שורה עם המילה ”קוד“ מעל העורך. זו התווית של שדה הקוד, והיא נשארה, מוסתרת מהעין (sr-only), כמו בעורך הציבורי: קורא מסך עדיין מקריא את שם השדה, ושורת הכפתורים של העורך ממוקמת מיד אחריה.

  • feat (WebApp): כפתורי ”בטל“ ו“בצע שוב“ בכל עמודי העורך. בשורה של ”בחר הכל / העתק / הדבק“, בעורך הציבורי ובעמודי העריכה וההעלאה, נוספו בהתחלה שני כפתורים, אייקון בלי טקסט: ”בטל“ מחזיר למצב הקודם, ו“בצע שוב“ קדימה. הם עובדים על ההיסטוריה של העורך, אותה ש-Ctrl+Z ו-Ctrl+Y מפעילים, וכל כפתור מושבת כשאין לו מה לעשות. נגיעה בהם לא מכניסה את הסמן לעורך, ולכן בטאבלט לא נפתחת מקלדת; ובעמוד מימין לשמאל החץ של ”בטל“ פונה ימינה. בעורך הפשוט הכפתורים מוסתרים: שם ה“בטל“ של הדפדפן משותף לכל השדות בעמוד, ונמדד שהוא ביטל הקלדה בשדה שם הקובץ במקום בעורך. החבילה של CodeMirror נבנתה מחדש כדי לחשוף את הפקודות. ראו ⌨️ עורך קוד (WebApp Editor).

  • fix (WebApp): בשורת הכפתורים של העורך אין יותר ”קיצורי מקלדת זמינים“, וההודעה הזמנית צפה. התווית תפסה רוחב, ואחרי שנוספו ”בטל“ ו“בצע שוב“, בעורך הציבורי ברוחב 1024 עד 1180 ”הדבק“ ירד לשורה שנייה והעורך התקצר ב-16px. אחרי: התווית הוסרה מכל עמודי העורך, והכפתורים בשורה אחת (בעורך הפשוט נשארה ”עורך טקסט בסיסי“). ההודעה הזמנית (”כל הקוד סומן“, ”הטקסט הודבק“) ישבה עד עכשיו במקום התווית, שהחזיקה לה את המקום, ולכן היא צפה עכשיו ברווח שאחרי הכפתורים, בלי לתפוס מקום: העורך לא זז כשהיא מופיעה, ובעמודי העריכה וההעלאה היא לא מכסה את כפתור ה-MD, שנשאר אחרון בשורה. בשורה צרה הודעה ארוכה מכסה לכמה שניות חלק מהכפתור שלפניה. בטלפון חמשת הכפתורים לא נכנסים בשורה אחת, ו“הדבק“ יורד לשורה משלו. ראו ⌨️ עורך קוד (WebApp Editor).

  • fix (WebApp): גם בתצוגת המסמך אין כותרות H5 ו-H6. הן בוטלו קודם רק בתצוגה החיה, ובעמוד המסמך (/md/<file_id>) ובשיתוף שלו (/share/<share_id>?view=md) הן נשארו כותרות בגופן קטן מטקסט רגיל. אחרי: ##### ו-###### נשארים כמו שנכתבו, כפסקה, גם שם, ותוכן העניינים הצף בנוי מהכותרות שנשארו. הכלל עבר מ-live-preview.js לקובץ משותף, md-heading-level-plugin.js, ששתי התצוגות מתקינות. הפסקה מסומנת ברמה שבה נכתבה ונשארת יעד לעוגן מפורש: עוגן בשורה שלפני ##### או בתוכה נוחת על הפסקה שלה, ועוגן של כותרת שאחריה — על הכותרת שלו. עד התיקון, בתצוגה החיה עוגן שלפני ##### עבר לכותרת הבאה, ותגית <a id> בתוכה נשארה בטקסט. דפדפן הריפו וכרטיסי החיפוש בתיעוד לא השתנו. מה שנשען על כותרת כזו: קישור עם # למזהה שנגזר מהכותרת עצמה (לא עוגן מפורש) כבר לא קופץ אליה; ופתק דביק שמעוגן רק למזהה של כותרת כזו (anchor_id בלי line_start) לא מוצא אותה יותר, ולכן לא זז איתה (_updateAnchoredNotePosition ב-sticky-notes.js). ראו העורך הציבורי (/markdown-editor).

2026-11-03

  • feat (WebApp): בעורך הציבורי, רשימת ההתראות בעברית, ואייקונים חדשים למארקר ולהתראות. בסרגל של /markdown-editor המארקר מסומן 🟰 וההתראות ℹ️, וכל התראה ברשימה נקראת בשם שהיא מקבלת ככותרת במסמך — ”הערה“, ”טיפ“, ”אזהרה“ ועוד (ADMONITION_TITLES ב-admonition-icons.js). גם ההודעה אחרי ההוספה בעברית: ”הוזרק: התראה - הערה“. השמות כתובים גם בתבנית, ו-test_the_public_alert_menu_uses_the_document_titles משווה בין השניים. תפריט ”MD“ של עמודי העריכה וההעלאה לא השתנה. ראו העורך הציבורי (/markdown-editor).

2026-10-31

  • fix (WebApp): קו הפרדה דק בצבע הערכה, ובלי קו מתחת ל-H1 ול-H2 — בתצוגה החיה ובתצוגת המסמך. ל---- לא היה כלל, והדפדפן צייר קו ”בולט“ אפור, צמוד לטקסט, שעל נייר כהה נראה כמו פס לבן. ול-H1 ול-H2 היה קו תחתון בסגנון GitHub, בצבע אפור-בהיר קבוע שלא עקב אחרי הערכה. אחרי: הקו הוא פיקסל אחד בצבע הדיו של הנייר בשקיפות, עם מרווח מעליו ומתחתיו (#md-content hr ב-md-content-layout.css וב-md-content-colors.css), והקו מתחת לכותרות הוסר. ראו מערכת ערכות הנושא והטוקנים החדשה.

  • fix (WebApp): בעורך הציבורי הכל מימין לשמאל, חוץ מבלוקי קוד — ובלי מספרי שורות. כל שורה קיבלה את הכיוון של האות החזקה הראשונה בה, ולכן - [x] משימה, שורת היישור של טבלה (|---:|) וקישור באנגלית בתוכן העניינים יצאו משמאל לימין. אחרי: העורך כולו מימין לשמאל, ורק בלוק קוד — בין גדרות של שלושה גרשיים הפוכים, או מוזח — משמאל לימין, לפי מה שהמנתח של Markdown בעורך זיהה (rtlExceptCodeBlocks בחבילה של CodeMirror, שנבנתה מחדש). אין מספרי שורות ואין חיצי קיפול (createBasicSetup עם gutters: false), והטקסט כבר לא נצמד לגבול הימני: הריווח של השורה היה בצדדים פיזיים, ובעורך מימין לשמאל נשארו 2px בצד שבו הטקסט מתחיל. עמודי העריכה וההעלאה לא השתנו. ראו ⌨️ עורך קוד (WebApp Editor).

  • fix (WebApp): התצוגה החיה בלי **``¶`` **ליד כותרות, ובלי כותרות H5 ו-H6. הגופן של H5 ו-H6 היה קטן מטקסט רגיל (ברירת המחדל של הדפדפן, 13.28px ו-10.72px מול 16px). אחרי: בתצוגה החיה, בעורך הציבורי ובעמודי העריכה וההעלאה, ##### ו-###### נשארים כמו שנכתבו, כפסקה, ואין — וריאנט משלה של מנוע הרינדור (RENDERER_VARIANTS ב-live-preview.js). דפדפן הריפו, כרטיסי החיפוש בתיעוד ותצוגת המסמך לא השתנו, ומטקסט ההדגמה הוסרו שתי הכותרות. ראו העורך הציבורי (/markdown-editor).

  • fix (WebApp): בעמודי העורך הפאנלים לא מתכווצים במסמך ריק, והדבקה של מסמך שלם מציגה את תחילתו. הגובה של העורך והתצוגה, כשהתצוגה דלוקה, נקבע לפי אורך התוכן, ולכן אחרי ”ניקוי“ או מחיקה של כל הטקסט שניהם התכווצו (נמדד בעמוד העריכה: העורך מ-369px ל-89px). והדבקה לתוך עורך ריק, או אחרי ”בחר הכל“, השאירה את העורך בסוף מה שהודבק ואת התצוגה בתחילתו. אחרי: כשהתצוגה דלוקה הגובה שלהם קבוע (.split-view.is-active .split-panels ב-split-view.css); והדבקה שמחליפה את כל המסמך — מהמקלדת, בכפתור ”הדבק“ או בעורך הפשוט — מחזירה את הסמן, את העורך ואת התצוגה לתחילת המסמך. הדבקה לתוך טקסט קיים לא השתנתה. ראו ⌨️ עורך קוד (WebApp Editor).

  • fix (WebApp): הקו בין העורך לתצוגה הוסר — אחרי גרירה שלו במגע, כל גלילה שינתה את רוחב הפאנלים. הגרירה הסתיימה ב-pointercancel ולא ב-pointerup, ולכן מאזין התזוזה נשאר רשום, וכל החלקה בעמוד הזיזה את הקו (שוחזר במגע אמיתי: מ-0.54 ל-0.74 של הרוחב בהחלקה אנכית אחת). אחרי: הפיצ’ר הוסר מכל עמודי העורך, יחד עם הטוקנים --split-resizer-*, והעורך והתצוגה בחצי-חצי. ראו מערכת ערכות הנושא והטוקנים החדשה.

  • feat (WebApp): בעורך הציבורי הכפתור אומר ”הסתר תצוגה“, ומה שמתחת לעורך בבלוק מתקפל. הכפתור נשאר ”Live Preview“ גם כשהתצוגה פתוחה; עכשיו הכיתוב והאייקון מתחלפים לפי המצב. וכל מה שמתחת לעורך — מה אפשר לכתוב, איפה הטקסט נשמר — בבלוק מתקפל, סגור כברירת מחדל, בעיצוב של ”קיפול“ במסמך; והגלילה בעורך ובתצוגה לא עוברת לעמוד כשמגיעים לסוף המסמך. ראו העורך הציבורי (/markdown-editor).

  • fix (WebApp): בעורך הציבורי כל שורה בכיוון של הטקסט שלה — שורה בעברית מימין לשמאל, שורת קוד או אנגלית משמאל לימין. ב-/markdown-editor העורך היה משמאל לימין, כמו עורך קוד: שורות בעברית נצמדו לשמאל, ובשורה כמו ”ברוך הבא ל-CodeKeeper“ המילה CodeKeeper הופיעה בקצה הימני. אחרי: כל שורה מקבלת dir="auto", כלומר הכיוון שלה נקבע לפי האות הראשונה בה שיש לה כיוון (עברית או אנגלית), ו-CodeMirror מזיז את הסמן ואת החצים לפי הכיוון של כל שורה; מספרי השורות מימין. זו תוספת לחבילה המקומית של CodeMirror — perLineAutoDirection ב-webapp/static_build/codemirror.bundle.entry.mjs, ו-codemirror.local.js נבנה ממנו מחדש — ש-initEditor מפעיל עם textDirection: 'auto'. עמודי העריכה וההעלאה לא השתנו ונשארים משמאל לימין; כיוון לכל שורה שם יתוכנן בנפרד. ראו ⌨️ עורך קוד (WebApp Editor).

  • fix (WebApp): העורך הציבורי בלי שטח מת — כלי ה-MD ו-Live Preview בשורה אחת, ובלי כרטיס עוטף. עד עכשיו העורך והתצוגה ישבו בתוך כרטיס עם ריפוד משלו; כלי ה-MD תפסו שורה, ומתחתיה הייתה שורה נוספת שבה רק Live Preview והרמז Ctrl+Shift+Enter; מעל העורך ישבה שורה של התווית ”Markdown“; ומתחת לתצוגה — שורת מידע (שפה, גודל, זמן) והסטטוס ”התצוגה מעודכנת.“. אחרי: ה-Split View הוא המסגרת היחידה; כלי ה-MD בתחילת שורת הכלים שלו, ו-Live Preview בסופה, משמאל, עם הקיצור ב-title של הכפתור; התווית מוסתרת מהעין ונשארת לקוראי מסך; שורת המידע מוסתרת, והסטטוס מוצג רק בשגיאה. תפריט ”התראות ▾“ נפתח עכשיו מתוך ה-Split View, ולכן הוא מבטל את overflow: hidden שלו כשהוא פתוח, כמו התפריט של עמודי העריכה — בלי זה התפריט נחתך. ראו העורך הציבורי (/markdown-editor).

  • fix (WebApp): בכל עמודי העורך — הודעה זמנית שלא מזיזה את העורך, נגיעה במסגרת בלי מקלדת, ופס גלילה בקצה התצוגה. בקבצים המשותפים לעמודי העריכה, ההעלאה והעורך הציבורי: ההודעה הזמנית (”כל הקוד סומן“, ”הוזרק: טבלה“) ישבה בשורה משלה מתחת לכפתורים, ששמרה לה גובה גם כשלא הייתה הודעה; עכשיו היא מוצגת במקום התווית ”קיצורי מקלדת זמינים“, באותו תא, והעורך לא זז. נגיעה במסגרת — הריפוד שליד העורך או הגבול של ה-Split View — הכניסה את הסמן לעורך, ובנייד פתחה מקלדת: Chrome מציב את הסמן בטקסט הקרוב לנגיעה. עכשיו ה-Split View עצמו אינו ניתן לבחירה (user-select: none), והעורך והתצוגה כן; נמדד באמולציית מגע בעורך הציבורי ובעמוד העריכה. פס הגלילה של התצוגה צף בתוך שוליים, כי הריפוד ישב על המכל ולא על האזור שנגלל; עכשיו הריפוד בתוך האזור שנגלל (--split-preview-pad), והפס בקצה. ובנוסף, בתצוגה החיה ובתצוגת המסמך: לאלמנט הראשון אין margin עליון — מעל הכותרת הראשונה היה רווח מיותר, 52.8 פיקסלים בתצוגת המסמך, מעבר לריפוד. ראו מערכת ערכות הנושא והטוקנים החדשה.

  • feat (WebApp): צ’קבוקס של משימה בתצוגה החיה משנה את השורה שלו בעורך. עד עכשיו הצ’קבוקסים בתצוגה החיה היו מושבתים, ובלי הרווח וההגדלה של תצוגת המסמך: העיצוב ישב על מחלקה שרק תצוגת המסמך הוסיפה. אחרי: לחיצה על צ’קבוקס מחליפה בין [ ] ל-[x] בשורה שלו בעורך, בלי להעביר את הפוקוס לעורך (בנייד זה היה פותח מקלדת), והתצוגה מתרנדרת מהטקסט החדש. כל פריט משימה נושא את שורת המקור שלו, גם כשמעליו שורות של עוגנים בלבד, שהרינדור מסיר. אם הטקסט בעורך השתנה מאז הרינדור, הלחיצה לא כותבת: הצ’קבוקס חוזר למצבו והתצוגה מתרנדרת מחדש. בדפדפן הריפו ובכרטיסי החיפוש בתיעוד הצ’קבוקסים נשארים לקריאה בלבד, והעיצוב שלהם עבר ל-md-content-layout.css, המשותף לשתי התצוגות. ראו העורך הציבורי (/markdown-editor).

  • feat (WebApp): עורך Markdown ציבורי עם תצוגה חיה, ב-/markdown-editor, בלי התחברות. עמוד לגולשים שמחפשים עורך Markdown: העורך מימין, התצוגה החיה משמאל, ומעליהם שורה פתוחה של כלי Markdown — טבלה, קישור חכם, מארקר, קיפול, רשימת משימות ו“התראות ▾“. בכניסה הראשונה העורך מציג טקסט הדגמה של רכיבי ה-Markdown, הטקסט שכותבים נשמר בדפדפן ומחכה בביקור הבא, ויש כפתורים ל“הורד ‎.md“, ל“ניקוי“ ול“טען דוגמה“. הטקסט לא נשלח לשרת: הרינדור בדפדפן בלבד, והעמוד לא שומר העדפת עורך. העמוד מוצג בערכה ציבורית אחת לכל גולש, ומשתמש באותו עורך, אותה תצוגה חיה ואותו סרגל MD של עמוד העריכה, עם אפשרויות שרק הוא מפעיל; עמודי העריכה וההעלאה לא השתנו. לצד העמוד נוספו /robots.txt ו-/sitemap.xml, וקישורים אליו מעמוד הבית ומהגלריה. בדרך, העזרים שהיו מועתקים בין עמודי העורך — waitFor, debounce, קריאה וכתיבה של תוכן העורך ועוד — עברו לקובץ אחד, webapp/static/js/utils/editor-page-utils.js. ראו העורך הציבורי (/markdown-editor).

  • feat (WebApp): ווי דריסה לערכה מיובאת בהירה — שדות טופס, הפיד והפוש בדשבורד, ושורת החיפוש ב-Markdown. כל ערכה מיובאת מקבלת את העיצוב של הערכות הכהות, וכמה רכיבים צבועים שם בצבעים קבועים לרקע כהה, ולכן בערכה מיובאת בהירה (כמו Pen Paper Coffee) לא ראו אותם: השדות בעמודי העריכה וההעלאה ושדות הסינון בעמוד הקבצים היו בלי גבול, הבלוקים בפיד האחרון לא נבדלו, הטקסט של התג בפיד ושל הבאדג« בכרטיס הפוש היה כמעט לבן על רקע בהיר, ולשורת החיפוש בתצוגת ה-Markdown לא היה גבול. אחרי: כל רכיב כזה קורא וו דריסה, וערכה בהירה מצהירה עליו בבלוק variables שלה, באותו מסלול כמו שאר הווים. ערכה שאינה מצהירה לא משתנה — נמדד בשש ערכות, גם בפוקוס ובתצוגה המקדימה של ערכה מובנית — וההחלטה שכל ערכה מיובאת מקבלת את העיצוב הכהה נשארת כמו שהיא. ערכה שכבר קיימת בחשבון מקבלת את הטוקנים רק אחרי ייבוא מחדש. ראו ערכה מיובאת בהירה: שדות טופס, הדשבורד, שורת החיפוש, הכפתורים שמעל העורך ותצוגת הקוד.

  • fix (WebApp): התצוגה החיה של Markdown בפריסה של המסמך — בלוק קוד עם פס כותרת, וטבלה שקוד בשורה לא נשבר בה לאותיות. בעמודי העריכה וההעלאה בלוק קוד הוצג כמו בדפדפן הריפו — כפתור קטן בפינת הקוד, בלי פס כותרת ובלי שם השפה — ובטבלה, עמודה עם קוד בשורה התכווצה עד שהקוד נשבר כל אות או שתיים. בתצוגת המסמך אותו קוד נשאר בשורה אחת, והטבלה נגללת לרוחב. הסיבה: לתצוגה החיה היה עותק משלה של הפריסה ב-split-view.css, והוא נסחף מזה של המסמך — קוד בשורה קיבל שם word-break: break-word, שמאפשר לשבור אותו בין כל שתי אותיות, וטבלה מצמצמת עמודה עד הרוחב הקטן ביותר שהתוכן שלה מרשה. אחרי: הפריסה של המסמך עברה כמו שהיא מ-md_preview.html ל-webapp/static/css/md-content-layout.css, ששני העמודים טוענים; הבלוק נבנה בשתי התצוגות ב-webapp/static/js/md-code-blocks.js; והעותק ב-split-view.css נמחק. דפדפן הריפו וכרטיסי החיפוש בתיעוד, שמשתמשים באותו רינדור, נשארו עם הכפתור הקטן. המסמך עצמו לא השתנה: צילום של כל התכונות המחושבות של כל אלמנט בו, ב-9 ערכות, זהה לזה שלפני השינוי. התצוגה החיה זהה למסמך בצבע ובפריסה של כל אלמנט ש-tests/test_live_preview_paper_browser.py משווה, בכל ערכה שהוא בודק; מה שנשאר רק בתצוגת המסמך רשום בהערה בראש md-content-layout.css. ראו מערכת ערכות הנושא והטוקנים החדשה.

  • fix (WebApp): התצוגה החיה של Markdown בצבעים של המסמך, בכל ערכה — ולא על רקע כהה קבוע. בעמודי העריכה וההעלאה התצוגה החיה הוצגה על רקע כהה בכל הערכות, גם הבהירות, ובערכה מיובאת ב-#1e1e1e במקום הרקע של הערכה; בערכה מיובאת בהירה הטקסט הכהה שלה לא היה קריא בכלל. שתי סיבות. live-preview.js הציב על המכל data-theme="dark", וזה הכניס לתצוגה את כללי הטקסט של הערכות הכהות ב-dark-mode.css עם צבעי הטקסט של העמוד — ב-Classic וב-Ocean לבן — ולכן הרקע הוחזק כהה (PR 2087, אחרי ש-PR 2015 הציב את התווית). והצבעים של המסמך — הנייר, צבעי התחביר, קוד בשורה, ציטוט, טבלה, סימון וקישורים — ישבו בתוך ה-<style> של md_preview.html, ומה שהתצוגה החיה הציגה במקומם תוכנן לרקע כהה בלבד: על נייר לבן נמדדו קוד בשורה בניגודיות 1.32 וטקסט בבלוק קוד 1.75. אחרי: הצבעים של המסמך עברו כמו שהם ל-webapp/static/css/md-content-colors.css, ששני העמודים טוענים; --md-paper-bg ו---md-paper-text הם הנייר; התווית הוסרה; וכל אזור התצוגה החיה במצב Markdown צבוע בנייר. המסמך עצמו לא השתנה: צילום של כל התכונות המחושבות של כל אלמנט בו, ב-9 ערכות, עם ריחוף על קישור ועם הפחתת אנימציה, זהה לזה שלפני השינוי, חוץ משני הטוקנים החדשים. התצוגה החיה זהה למסמך בצבע של כל אלמנט שנמדד, בכל הערכות, כולל מיובאת כהה ובהירה (tests/test_live_preview_paper_browser.py). מה עוד לא זהה: פריסה — גדלי כותרות, הקו התחתון שלהן, ריווח — ופס הכותרת של בלוק קוד, שרק תצוגת המסמך בונה; ובורר הרקע (bg-sepia ודומיו), שקיים רק בתצוגת המסמך. ראו מערכת ערכות הנושא והטוקנים החדשה.

2026-10-30

  • fix (WebApp): קישורים במסמך Markdown בצבע של הערכה, ובניגודיות גבוהה הם כבר לא צהובים על לבן. עד היום הכללים של #md-content a ב-md_preview.html כתבו כחול קבוע, ולכן ערכה מיובאת עם צבע קישורים משלה (textLink.foreground) קיבלה את אותו כחול. עכשיו הם קוראים את --link-color, הריחוף קורא קודם --primary-hover, והקו שמתרחב בריחוף צבוע בצבע הקישור. לערכות המובנות נוסף --link-color בבלוק של כל אחת (ב-:root וב-Classic אותו כחול של היום). ב-High Contrast הקישורים במסמך יצאו עד היום צהובים על הדף הלבן, כי high-contrast.css צובע כל a ב-!important; עכשיו יש למסמך כלל !important משלו, עם בורר חזק יותר, והם כחולים עם קו תחתון (נמדד בכרומיום). שינוי נלווה שהתקבל: הקישורים המדומים בתצוגה המקדימה של גלריית הערכות קוראים כבר היום את --link-color, ולכן בערכה מובנית הם עוברים מצבע הטקסט המשני לצבע הקישור. tests/test_md_preview_link_color.py גוזר את כללי הערכה על a ודורש שיפסידו לכללי המסמך, ודורש --link-color בכל ערכה שבוחר הערכות מציע. הפירוק של בוררים והשקילה שלהם עברו ל-tests/_css_rules.py, במקום עותק בכל טסט.

  • docs (WebApp, MCP): המעבר לפרנקפורט הושלם, והתיעוד וקבצי ההגדרה מפנים לוובאפ ולשרת ה-MCP החדשים. הוובאפ רץ עכשיו ב-https://codekeeper-webapp.onrender.com, בשירות CodeKeeper-WebApp ב-Render, ושרת ה-MCP ב-https://codekeepermcp.onrender.com. השירותים הקודמים באורגון, https://code-keeper-webapp.onrender.com ו-https://codekeeper-mcp.onrender.com, מושהים. הקוד כבר קרא את כתובת הוובאפ מ-WEBAPP_URL בלבד, ולכן מה שהתעדכן הוא הכתובות הקבועות: ה-README, המדריך להתחברות עם טלגרם (גם הדומיין ב-BotFather), המדריך להוספת ריפו לדפדפן הקוד (ה-Payload URL של ה-webhook ב-GitHub, ושם השירות ב-Render), הדוגמאות בעמוד דשבורד הניטור, render.yaml, render.env.example וברירת המחדל של WEBAPP_HOST ב-docker/prometheus/entrypoint.sh; ובצד ה-MCP — הדוגמאות של MCP_SERVER_URL ושל MCP_ALLOWED_HOSTS ב-משתני סביבה - רפרנס, והדוגמה של MCP_SERVER_URL ב-mcp_server/README.md. webhook שהוגדר לפי הגרסה הקודמת של המדריך עדיין שולח לאורגון, וצריך לעדכן בו את ה-Payload URL. test_retired_hosts_appear_only_in_the_changelog (ב-tests/test_config_definitions_coverage.py) נכשל אם אחת משתי הכתובות של אורגון מופיעה בקובץ כלשהו בריפו חוץ מהיומן הזה.

  • fix (WebApp): לכל ריפו רץ ג’וב סנכרון אחד בכל רגע, וג’וב שה-worker שלו מת משתחרר. עד היום שני workers — כמה תהליכי gunicorn, או שני שירותים על אותו מסד בזמן מעבר — יכלו לסנכרן את אותו ריפו יחד, ו-base_moved רק גילה את זה בדיעבד. ו-worker שנהרג באמצע ג’וב, למשל בפריסה, השאיר אותו running לתמיד, ושירות ה-MCP ראה בו ”סנכרון רץ“. עכשיו אינדקס ייחודי חלקי על sync_jobs מאפשר ג’וב running אחד לכל ריפו, והתפיסה מדלגת על ריפו תפוס וממשיכה לריפו אחר. נמדד מול mongod 7.0.14 (test_workers_claiming_at_the_same_moment_run_one_job_per_repo ב-tests/test_repo_sync_claim.py): שמונה חוטים שתופסים יחד מתוך ארבעה ג’ובים של ריפו אחד — ג’וב אחד רץ, ושלושה נשארים pending. בזמן ג’וב חוט מעדכן heartbeat_at, וג’וב בלי דופק SYNC_JOB_STALE_SECONDS מסומן failed עם abandoned. הסנכרון הבא משלים את מה שהוא פספס. האינדקסים של sync_jobs נוצרים כשה-worker עולה, ולא רק ב-scripts/create_repo_indexes.py, כולל ה-TTL שמוחק ג’ובים ישנים, ו-TTL או ייחודי שלא נוצרו נשלחים כאירוע db_sync_jobs_index_missing. וה-worker עולה עכשיו עם שרת הוובאפ, אחרי המילוי (start_webapp_repo_threads): עד היום הוא עלה רק בתהליך שקיבל webhook, ולכן ג’ובים שנשארו pending מלפני פריסה, וג’ובים בשירות שה-webhooks לא מגיעים אליו, חיכו ל-webhook הבא. מתג חדש, WEBAPP_SYNC_WORKER=0, מכבה את ה-worker בשירות לזמן מעבר בין שירותים. ראו מה קורה לג’וב סנכרון.

  • feat (WebApp): שירות שעולה עם דיסק בלי mirrors משכפל לבד את הריפואים מהרשומות, וה-worker של הסנכרון מחכה לו. עד היום, וובאפ שעלה עם דיסק ריק — שירות חדש, כמו במעבר לפרנקפורט, או דיסק שנמחק — לא מצא אף ריפו בדפדפן הקוד, וכל ג’וב סנכרון נכשל עם mirror_missing עד ייבוא ידני של כל ריפו מחדש. הייבוא גם דורס את last_synced_sha, את repo_url ואת default_branch, ומאנדקס את כל הריפו. נמדד על ריפו git אמיתי (דיסק ריק, רשומה עם last_synced_sha = A, ואז push של B): בקוד הקודם הג’וב של B נכשל עם mirror_missing ושום קובץ לא נכנס לאינדקס. עכשיו חוט רקע בשם repo-mirror-fill עולה עם שרת הוובאפ ומשכפל כל ריפו שיש לו רשומה ב-repo_metadata ואין לו mirror, בלי לכתוב למסד, וה-worker של הסנכרון לא תופס ג’וב לפני שהמעבר הראשון של המילוי הסתיים. באותו תרחיש הג’וב של B מסתיים completed, b.py נכנס לאינדקס, ו-last_synced_sha מתקדם ל-B. ריפו שהוסר בזמן השכפול נמחק מהדיסק בסופו. מעבר שנכשל על תקלה שעשויה לחלוף, כמו מסד שעוד לא זמין או שכפול שנכשל, מנוסה שוב לבד, עם המתנה שמוכפלת, עד MIRROR_FILL_MAX_ATTEMPTS מעברים (בערך שעה). כשגם הניסיון השני נכשל נשלחת התראה לבוט, repo_mirror_fill_failing. כמה workers של gunicorn ממלאים פעם אחת, תחת נעילת flock. הקריאה של הרשומות והשכפול משותפים עכשיו לוובאפ ול-autosync של שירות ה-MCP (services/repo_mirror_fill.py), בלי שינוי בהתנהגות של ה-MCP. כיבוי: WEBAPP_REPO_AUTOFILL=0. ראו דיסק בלי mirrors: המילוי בעלייה.

  • fix (WebApp): ג’וב סנכרון של ריפו שלא בוצע מסומן failed, והסנכרון הבא משלים את מה שהוא פספס. עד היום ארבעה מצבי כשל ב-_run_sync_logic (אין mirror בדיסק, fetch שנכשל, אין last_synced_sha, רשימת שינויים שלא התקבלה) חזרו כתוצאה עם error, וה-worker סימן completed כל ג’וב שלא נזרקה בו חריגה. בנוסף, הבסיס של ההבדלים היה ה-SHA הקודם שה-webhook שולח, ולכן השינויים של push שהסנכרון שלו נכשל לא נכנסו לאינדקס החיפוש לעולם, וגם שירות ה-MCP לא זיהה SHA חדש עד ה-push הבא. נמדד על ריפו git אמיתי (A ← B שהסנכרון שלו נכשל ← C): בקוד הקודם הג’וב של B סומן completed, ואחרי C היה באינדקס רק c.py. עכשיו כל תוצאה נושאת סטטוס מפורש, והג’וב מסומן completed, failed (עם הסיבה ב-error) או skipped (push לריפו שהוסר). הבסיס של ההבדלים הוא last_synced_sha שבמסד, וסנכרון שמצליח משלים גם את מה שהג’ובים שלפניו פספסו. last_synced_sha נכתב רק אם הוא עדיין הבסיס שהסנכרון התחיל ממנו, ואחרת הג’וב failed עם base_moved. ראו מה קורה לג’וב סנכרון.

  • change (בוט, WebApp, MCP, התראות): כתובת ה-WebApp נקראת ממקום אחד, ממשתנה אחד, ובלי ברירת מחדל — שירות בלי WEBAPP_URL תקין לא מפנה יותר בשקט לשירות באורגון. עד היום הכתובת חושבה בכעשרה מקומות, משלושה משתנים (WEBAPP_URL, PUBLIC_BASE_URL, PUBLIC_URL) ובסדרי עדיפויות שונים, ובשישה מהם הכתובת code-keeper-webapp.onrender.com הייתה כתובה בקוד כברירת מחדל: שירות שלא קיבל את המשתנה לא נכשל, אלא המשיך להפנות לשם — וזה מה שהיה הופך את המעבר של ה-WebApp לפרנקפורט לקישורים מתים בלי שום שגיאה. עכשיו הקורא היחיד הוא webapp_url.py, והמשתנה היחיד הוא WEBAPP_URL, בפורמט https://<host>, בלי נתיב ובלי / בסוף. PUBLIC_BASE_URL ו-PUBLIC_URL בוטלו. חסר או פגום — שום צרכן לא בונה קישור: כפתורי ה-WebApp בבוט לא מוצגים, /webapp אומר שה-WebApp לא זמין, ובהתראות אין כפתור Dashboard (ההתראה עצמה נשלחת). כל שירות כותב שורת ERROR בעלייה, ה-/health של ה-WebApp מציג WEBAPP_URL_STATUS, וה-/healthz של ה-MCP מציג webapp_url, כי בלי כתובת הוא רץ במצב PAT בלבד. בתוך בקשה ל-WebApp, בלי כתובת, הקישורים נבנים מהכתובת שהבקשה הגיעה אליה, שהיא הכתובת של השירות עצמו. מה עוד השתנה בדרך: קובץ הידע של היועץ לא מכיל כתובת. הקטע שמציע קישור לגלריה מקבל אותה בטעינה, ובלעדיה יורד. הכפתור ”📱 קישור פנימי“ ב-/share נשלט עכשיו בדגל ENABLE_INTERNAL_SHARE_LINKS (כבוי), במקום ב-PUBLIC_BASE_URL, שלא הוגדר ולכן החביא אותו. שרת הווב הפנימי בבוט עולה לפי ENABLE_INTERNAL_SHARE_WEB בלבד, ולכן דגל דלוק מעלה אותו — ו-POST /alerts, GET /alerts ו-GET /incidents בשרת הזה, שהיו פתוחים, דורשים עכשיו DB_HEALTH_TOKEN כמו /api/db/, ובלעדיו הם חסומים. הודעות הטלגרם שהוובאפ שולח למישהו אחר — אישור לסניפט או לפריט באוסף הקהילה, והתראה לאדמינים על סניפט חדש — בונות את הקישור מ-WEBAPP_URL בלבד, ובלעדיו יוצאות בלי קישור; הכתובת שהבקשה הגיעה אליה משמשת רק לקישור שחוזר בתשובה לאותה בקשה. WEBAPP_WARMUP_BASE_URL הוסר מהתיעוד וממסך האדמין, כי אף קוד לא קרא אותו. test_webapp_url_has_one_reader ו-test_the_old_webapp_host_is_not_in_code_that_runs (ב-tests/test_config_definitions_coverage.py) נכשלים על קורא שני או על הכתובת הישנה בקוד שרץ.

2026-10-29

  • fix (MCP): ref ענק כבר לא מוחק את סיבת הסירוב — הוא נדחה בשם משלו, לפני שמשהו נקרא. עד היום invalid_ref החזיר את ה-ref כמו שהוא, וה-ref לא היה חסום בשום מקום לפני המראה. נמדד (2026-10-29, דרך call_tool על מראה אמיתית): ref של 300,000 תווים — גוף בקשה יכול לשאת אותו — הוליד סירוב גדול מ-OUTPUT_BYTE_BUDGET, והרשת ב-call_tool החליפה אותו ב-answer_too_large כללי, בלי repo, בלי path ובלי הסיבה. כך בשלושת הכלים שמקבלים ref: codekeeper_docs_get_section, codekeeper_get_repo_file ו-codekeeper_list_repo_tree. עכשיו ref מעל MAX_REF_CHARS (4,096, אותו מספר ומאותו נימוק כמו MAX_PATH_CHARS) נדחה ב-ref_too_long עם max_chars ו-actual_chars, בלי ה-ref. הבדיקה ב-RepoBackend (get_file ו-list_tree), שם עוברים שלושת הכלים — ולא ב-_validate_ref_with_git, כי השירות משרת גם את הוובאפ, ושם קוד חדש בלי שורה במפות של /repo/api/history ו-/repo/api/file-at-commit היה הופך ל-500. כל ref עד התקרה מקבל את התשובה של היום, כולל invalid_ref עם ה-ref; מעליה — ref_too_long גם כשהבקשה הייתה נכשלת אחר כך מסיבה אחרת, כמו ריפו פגום (עד היום invalid_input). טסט חדש בודק את האינווריאנט ולא רק את ה-ref: כל פרמטר מחרוזת של שלושת הכלים, נגזר מהסכימה, מקבל 300,000 תווים, והרשת אינה נדרשת. בסריקה נמצאו עוד שלושה מקומות שמחזירים קלט בלי תקרה, ולא תוקנו כאן: repo בכלי התיעוד (repo_not_allowed מחזיר את requested_repo; רשום בטסט כפער ידוע), query של codekeeper_get_file (נמדד), ו-query של codekeeper_search_repo (לפי הקוד; לא נמדד, כי אין מנוע חיפוש בעולם של הטסט). ענף שלא במראה, מול קובץ שלא קיים.

  • feat (MCP): כלי התיעוד מחזיר גם קובץ שלם, משורה 1 — לכל משתמש, ובלי לדעת מה הכותרת הראשונה. סוכן שקורא לפי טבלת טריגרים מגיע עם נתיב, ועד היום codekeeper_docs_get_section ידע להחזיר קובץ שלם רק דרך הכותרת הראשונה כ-section — שתי קריאות (מפה, ואז הכותרת), ולא תמיד הקובץ כולו: מה שלפני הכותרת הראשונה (front matter, הקדמה) וקובץ עם כמה כותרות עליונות לא הגיעו מאף סעיף. מי שאינו אדמין לא יכול היה לקרוא אותם בשום דרך. עכשיו whole_document=true מחזיר את הקובץ כולו, mode: document, מדופדף כמו סעיף ובאותה פונקציה (_text_page), עם encoding מהקריאה. בלי פרסור, ולכן גם קובץ שמפת הכותרות מסרבת לו (too_many_lines, too_many_tokens, inconsistent_line_endings, too_many_sections) נקרא שלם — עד היום ההפניה שם הייתה codekeeper_get_repo_file, שלאדמין בלבד. השער לא השתנה: content הוא מה ש-codekeeper_get_repo_file מחזיר על אותו קובץ ו-ref, ומדיניות הנתיבים, מדיניות הסודות ותקרת ה-500KB חלות כמו קודם, באותן תשובות. section או max_depth עם הדגל נדחים ב-section_and_whole_document וב-max_depth_and_whole_document. בלי הדגל התשובה לא זזה, ונבדק ב-2026-10-29: scripts/docs_section_zero_diff.py על כל עמודי ה-RST תחת docs/ — פלט זהה; והמפה וסעיפים (עד 60 לקובץ, בשלושה עימודים) בכל קובצי ה-Markdown בריפו — זהים בית-בית כפי שהם נשלחים. תיאור הכלי, בלוק ה-instructions, mcp_server/README.md ו-CLAUDE.md מפנים לדגל במקום ל“כותרת הראשונה“. וקריאה מלאה ב-codekeeper_get_repo_file שאינה נכנסת בתקציב (answer_too_large) מפנה עכשיו ל-whole_document=true — הקובץ כולו, מדופדף — ולא למפת הכותרות, שממנה היה צריך לבחור סעיף אחרי סעיף; אותה תשובה גם בפריט קובץ של codekeeper_read_batch. ההפניה של outline על קובץ בלי מפה נשארת למפה. איזה קובץ docs_get_section קורא, ובאיזה ריפו.

  • feat (WebApp): ערכה חדשה בייצוא ל-HTML מעוצב — GitHits Docs, תיעוד כהה ושקט עם ורוד אחד להדגשות. הערכה מחקה את אתר התיעוד של GitHits, ולא רק בצבעים אלא גם בצורה: inline code ורוד על אפור, בלוק קוד כהה עם פינות גדולות, קישור עם קו תחתון ורוד במקום underline, כותרת עליונה שטוחה בלי גרדיאנט, וטבלה, details, ציטוט ו-TOC רגועים יותר. בשביל הצורה נוסף לערכות שב-EXPORT_PRESETS מפתח אופציונלי, extra_css: CSS של עיצוב ופריסה שנטען רק כשהערכה נבחרה. get_export_theme מחזיר אותו רק מ-Export Presets שבקוד (ומה-fallback, שהוא אחד מהם) — לא מערכות משתמש שב-DB ולא מ-JSON של VS Code — ו-render_styled_html מעביר אותו דרך sanitize_css. התבנית שמה אותו בבלוק <style> אחרון, אחרי syntax_css, ועוטפת אותו ב-@media screen, כדי שכללי ההדפסה של התבנית יחולו גם על ערכה שדורסת את pre ו-code. הדגשת התחביר היא צבעי VS Code Dark+ של Tech Guide Dark, שעברו לתבנית משותפת אחת (_VSCODE_DARK_PLUS_SYNTAX_CSS) עם צבע כותרות לכל ערכה; מפתחות של JSON נצבעים בצבע של תגיות HTML, כי ב-Pygments הם אותו טוקן. ערכות קיימות לא השתנו: ב-2026-10-29, על מסמך דוגמה עם כל סוגי הבלוקים, ה-HTML של Tech Guide Dark, ‏Clean Light ו-Minimal יצא זהה בייט-לבייט לזה שלפני השינוי. נמדד באותו יום ב-Chromium: הערכה החדשה במסך רחב, במובייל ובהדפסה, ובהדפסה extra_css לא משפיע על אף אלמנט שנמדד. הטסטים ב-TestExtraCssAndGitHitsDocsPreset שב-tests/test_styled_export.py.

  • change (בוט + תיעוד): פקודת החיבור שהבוט מחזיר ל-Claude Code שומרת את CodeKeeper לכל הפרויקטים, ולא רק לתיקייה שממנה הורצה. עד היום /connect_claude החזיר claude mcp add בלי --scope, ולכן הרשומה נשמרה ב-scope ברירת המחדל, local: ב-~/.claude.json תחת הפרויקט שממנו הורצה הפקודה, ו-CodeKeeper היה זמין רק שם — למרות שמאגר אישי לא שייך לפרויקט אחד. עכשיו connect_claude_command ב-main.py מוסיף --scope user, והרשומה נכתבת ל-mcpServers שבראש הקובץ (code.claude.com/docs/en/mcp, ה-Tips של --scope, נקרא ב-2026-10-29; ונמדד באותו יום ב-Claude Code 2.1.312: הפקודה, כפי שהבוט מחזיר אותה, כתבה לראש הקובץ, ו-claude mcp get מפרויקט אחר דיווח ”User config (available in all your projects)“). tests/test_connect_claude_command.py מקבע את הדגל, גם ב-/connect_claude write, ונופל על הקוד הקודם. בתיעוד, הפקודה ב-Claude Code (טוקן) וב-mcp_server/README.md כוללת את הדגל, והמקבילה הידנית היא עכשיו בדיוק הרשומה שהפקודה כותבת. ובאותה הזדמנות: ההודעה של הבוט, סעיף האימות ושלב 2 בהפעלה בעמוד הזה, שני מקומות ב-mcp_server/README.md, FEATURES_SUMMARY.md וה-docstring של mcp_server/oauth_provider.py עוד אמרו שהטוקן האישי הוא ”ל-Claude Code / Desktop“ — עותקים של הטענה שתוקנה בעדכון שלמטה, שלא נמצאו אז. עכשיו כולם אומרים שהטוקן הוא ל-Claude Code שלא מחובר עם החשבון ב-claude.ai ולהוק של הפריימר, ושהמחבר מגיע לבד ל-Claude Desktop. ההודעה של הבוט גם אומרת שטוקן הקריאה הוא מה ששמים ב-CODEKEEPER_PAT.

  • change (WebApp + תיעוד): משתמשי Claude Desktop, ו-Claude Code שמחובר עם החשבון ב-claude.ai, לא מתבקשים עוד לטוקן — המחבר של Claude.ai מספיק. מחבר שמוסיפים ב-Claude.ai שייך לחשבון, ולכן הוא מגיע לבד לאפליקציית הדסקטופ (לצ’אט, ולסשנים המקומיים וה-SSH של טאב ה-Code) ול-Claude Code שמחובר עם מנוי claude.ai, גם בטרמינל (code.claude.com/docs/en/mcp, הסעיפים ”Use MCP servers from claude.ai“ ו-”How connectors reach Claude Code“, נקרא ב-2026-10-29). עד היום הלשונית ”Claude Code בטרמינל“ בהגדרות אמרה ”כאן צריך טוקן אישי“ בלי תנאי, והסעיף על הדסקטופ ב-שרת ה-MCP — חיבור Claude ל-CodeKeeper וב-mcp_server/README.md הציג רשומת "type": "http" ל-claude_desktop_config.json — קובץ שהתיעוד של Anthropic מתאר לשרתים מקומיים, ולא מצאנו מקור שאומר שרשומה מרוחקת עובדת בו. עכשיו: הלשונית נפתחת ב“מחוברים עם החשבון ב-claude.ai? לא צריך טוקן“, עם בדיקה ב-/mcp ועם מה עושים כשהמחבר לא מופיע שם (/status, ומחברים שכובו), ואחריה המקרים שבהם כן צריך טוקן, כדוגמאות; בלשונית Claude.ai נוספה שורה על הדסקטופ ועל הטרמינל; Claude Code (טוקן) מפרט את כל המקרים שבהם המחברים לא נטענים, ומחזיק את ה-JSON כמקבילה ידנית לפקודה, עם המיקום המדויק — בלי --scope הפקודה כותבת ל-~/.claude.json תחת הפרויקט שממנו הורצה, ורשומה בראש הקובץ שקולה ל---scope user; והסעיף על הדסקטופ מפנה למחבר. אותה עובדה תוקנה גם בטבלה ב-FEATURES_SUMMARY.md ובידע של מצב היועץ; ושם נוסף גם שההוק שטוען את ”הוראות לסוכן“ צריך טוקן קריאה ב-CODEKEEPER_PAT גם כשהמחבר מגיע מהחשבון, כי עד היום הידע אמר שההוראות ”נמשכות אוטומטית“ בכל סשן של Claude Code, בלי תנאי. העוגנים: נוספו שתי תוויות, mcp-clients-claude-ai ו-mcp-clients-claude-code. כותרות הסעיפים לא השתנו, ולכן הכתובות הקיימות שלהם (#claude-ai-custom-connector, #claude-code, #claude-desktop) ממשיכות לעבוד — נבדק ב-docutils 0.21.2: אף מזהה סעיף בעמוד לא נעלם.

  • docs (MCP): התקרות של Claude Code על תיאורי כלים — 4,096 תווים לכלי שנטען מראש, ו-16,384 לכלי שנטען דרך tool search. הפסקה ”כמה מהבלוק ומהתיאורים מגיע לסוכן“ ב-Claude Code (טוקן) אמרה שהתקרה של 4,096 חלה על התיאור של כל כלי, ושהעמוד code.claude.com/docs/en/mcp סותר את ה-changelog ועדיין אומר 2,048. בקריאה ב-2026-10-29 (הסעיף ”Tool search for MCP server authors“) העמוד כבר מתאים ל-changelog, ומבחין בין שתי תקרות: 4,096 ל-instructions של שרת ולתיאור של כלי שנטען מראש, ו-16,384 לתיאור של כלי שנטען דרך tool search; ו-CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH קובע מספר אחד לשתיהן, כך שערך נמוך מ-16,384 גם מקטין את התקרה הארוכה. הפסקה וההערה מעל CLIENT_INSTRUCTIONS_MAX_CHARS ב-mcp_server/server.py עודכנו, והמשפט על הסתירה נמחק משתיהן. אין שינוי בהתנהגות: _TOOL_DESCRIPTION_MAX_CHARS נמוכה משתי התקרות.

2026-10-28

  • fix (CI): טסטי היחידה כבר לא נכשלים אקראית בגלל MongoDB שלא עולה — כל שירות של מונגו משאיר את rseq אצל glibc. בימים האחרונים הג’וב Unit Tests נכשל בחלק מהריצות כבר בצעד Initialize containers (Service container mongodb failed), ועבר בהרצה חוזרת. אחרי מיזוג, כשל כזה ב-deploy.yml גם עצר את בניית ה-Docker ואת הפריסה ל-Render. הסיבה: GitHub מעבירים בהדרגה את ה-runners של ubuntu-24.04 לקרנל 7.0.0-1017-azure. mongod של 8.0 קוראת ממנו ”7.0.0“, מחשיבה אותו לקרנל שהמטמון לכל מעבד של TCMalloc קורס עליו, ומסרבת לעלות כשהמטמון הזה פעיל — וזה המצב שהתמונה הרשמית מגדירה. עכשיו GLIBC_TUNABLES: glibc.pthread.rseq=1 בשירות המונגו ב-ci.yml, ב-deploy.yml ובשני קובצי ה-compose מעביר את TCMalloc למטמון לכל חוט, ובדיקת הקרנל של מונגו לא עוצרת על אף קרנל. tests/test_mongo_services_glibc_rseq.py נכשל על שירות mongo בלי ההגדרה, וב-תווית ה-runner נוסף שתווית נעוצה אינה נועצת את התמונה שמאחוריה. GLIBC_TUNABLES בשירותי המונגו.

  • change (Claude Code): הפריימר נטען פעם אחת בכל סשן — ההוק עבר לפלאגין codekeeper-memory והוסר מהריפו. פלאגין שמופעל בחשבון ב-claude.ai מגיע עכשיו גם לסשן שרץ בדפדפן, ולכן ההוק שישב ב-.claude/ של הריפו רץ לצד ההוק של הפלאגין, והפריימר נכנס להקשר פעמיים (נמדד ב-27.10, בפתיחה מחדש של סשן על הריפו הזה). ההוק v2, עם ה-retry, הטסטים שלו וה-CI עברו לריפו של הפלאגין (codekeeper-plugin#4, גרסה 0.2.0), שם גם נוספה ברירת מחדל ל-CODEKEEPER_PRIMER_URL. מהריפו הוסרו .claude/settings.json, .claude/hooks/codekeeper-primer.sh ו-tests/test_codekeeper_primer_hook.py. בכרטיס ”הוראות לסוכן“ ב-/settings, הצעד הראשון של ”איך מחברים את זה ל-Claude Code?“ שולח עכשיו להוסיף את הפלאגין ב-claude.ai, או, למי שרוצה את הפריימר רק בריפו אחד, להעתיק את ההוק מריפו הפלאגין — לא את שניהם. פריימר לסוכן — GET /api/agent/primer.

2026-10-27

  • feat (WebApp, MCP): צבע חדש לפתקים — שנהב, בבורר מיד אחרי שני הצהובים. הגוון (#fffff0) הוא הבהיר בפלטה, והוא נבחר בהשוואה ידנית על פתקי בדיקה בין גוונים בהירים מהקיימים: על גוונים כהים יותר, המרקר, ::: details, קוד, ציטוט וקישור בתוך הפתק לא הסתדרו. אף צבע קיים לא השתנה, ואף פתק אינו משנה מראה. הבורר, הסינון לפי צבע בחיפוש הפתקים וכלי ה-MCP מכירים אותו כ-ivory; תיאור פרמטר הצבע ב-MCP נגזר מהפלטה ולכן התעדכן לבד. צבע הפתק, הצבעים והמדידה.

  • test (WebApp): בורר הצבע של הפתקים נמדד בדפדפן על כל צבע בפלטה. עד היום כל צבע חדש נמדד ביד: הטקסט על העיגול, הגבול שלו מול העיגול ומול הכרטיס, וטבעת הבחירה. tests/test_sticky_color_picker_browser.py דוגמת אותם בפיקסלים בכרומיום, על כל צבע ב-NOTE_COLOR_ORDER, ואוכפת את ספי WCAG. המספרים בתיעוד נמדדו מחדש באותה שיטה: מול הכרטיס, הצבע הבהיר ביותר הוא המקרה הגרוע, ועכשיו זה השנהב (4.08:1). הבדיקה אינה רצה ב-CI. הצבעים והמדידה.

  • fix (אבטחה): הבנייה והתלויות כבר לא סומכות על תעודות הביניים של eMudhra שהמפתחות שלהן נחשפו. ב-17.10.2026 התגלה שלשמונה תעודות ביניים של eMudhra (השורש emSign) היו מפתחות פרטיים חלשים, כך שמי שמחזיק אותם יכול להנפיק תעודת HTTPS מזויפת לכל אתר. requirements/base.txt מצהיר עכשיו על certifi>=2026.10.19, הגרסה שבה השורש שנפגע (emSign ECC Root CA - G3) חסר ושאר שורשי emSign, שהגרסה שלפניה הסירה גם הם, הוחזרו: עד היום certifi הגיע רק כתלות משנית בטווח פתוח, ולכן סביבה שכבר הותקנה בה גרסה ישנה נשארה איתה. ב-Dockerfile כל שלב משדרג את pip ל-PIP_MIN_VERSION לפני ה-pip install הראשון שלו (עד היום שלב הייצור התקין את Playwright עם ה-pip של תמונת הבסיס), ואת השדרוג עצמו, שה-pip הישן מוריד, בודק מול מאגר התעודות של מערכת ההפעלה (PIP_CERT) ולא מול ה-certifi שבתוכו. כל שלב גם מתקין ca-certificates במפורש, ועוצר את הבנייה אם הגרסה שלו ישנה מ-CA_CERTIFICATES_MIN_VERSION; פקודות ה-apt כבר לא בשרשרת &&, כי תחת set -e שרשרת שאחריה באה הבדיקה הייתה בולעת כישלון של ההתקנה. ‏Node בתמונה של הבוט וב-push_worker/Dockerfile עובר לקו 22, כי לקווים 18 ו-20 שהיו שם אין גרסה מתוקנת, ובתמונה של הבוט גם ה-driver של Playwright רץ עליו (PLAYWRIGHT_NODEJS_PATH) ולא על ה-Node שבתוך החבילה, שעדיין סומך על השורש שנפגע. tests/test_dockerfile_trust_floors.py בודק את הסדר ואת הבדיקה בכל שלב, ומריץ את בדיקת הגרסה מול dpkg. בשירותי ה-Python של Render (ה-WebApp ושרת ה-MCP) פקודת הבנייה מוגדרת בדשבורד ולא בריפו, ולכן שם שדרוג ה-pip נעשה בדשבורד. ה-Node שבתוך Playwright עוד רץ ב-CI של התיעוד (documentation.yml), שאינו חלק מהשירותים ב-Render.

2026-10-25

  • fix (WebApp): התיבה ”חיפוש לפי שם, תיאור או תגית“ בעמוד הקבצים מחפשת רק בשם, בתיאור ובתגיות — ולא בקוד. עד היום היא הריצה $text על search_text_idx, שכולל גם את הקוד, ולכן החזירה גם קבצים שהמילה מופיעה רק בקוד שלהם, בלי להראות איפה — והמיון (חדש ביותר) הציג אותם לפני הקובץ שהמילה בתגית שלו. $text גם מתאים רק מילה שלמה: view לא מצא את view_file.html. עכשיו כל מילה צריכה להופיע בשם, בתיאור או באחת התגיות, גם כחלק ממילה ובלי הבדל בין אותיות גדולות לקטנות, ו-#python מוצא את התגית python. התנאי נבדק על הגרסה האחרונה של הקובץ — עד היום נבדקו כל הגרסאות, וקובץ שתגית נשארה רק בגרסה ישנה שלו נמצא ומוצג בגרסה הישנה. אותו כלל בכל התצוגות של העמוד (_files_search_file_match), כולל נפתחו לאחרונה וקבצים גדולים, ואיתו ירדה מהעמוד הנפילה השקטה ל-$regex כשאינדקס הטקסט חסר, שבה תגית נמצאה רק בהתאמה מלאה ובאותיות קטנות. הסינון קורא את אותם מסמכים שפתיחת העמוד בלי חיפוש קוראת (נמדד ב-explain). תו NUL בשאילתה (q=%00) מחופש כמו כל תו אחר — $regex של מונגו דוחה ביטוי שיש בו NUL, ועד היום ”קבצים גדולים“ נפל עליו ב-500. חיפוש בתוכן נשאר בתיבה הראשונה, החיפוש הגלובלי, שמראה גם איפה המילה בקוד. לא לבלבל עם.

  • feat (WebApp): ”🏷️ עדכן תגיות“ בתפריט ⋮ של עמוד הקובץ — שינוי תגיות בלי עריכת קובץ ובלי גרסה חדשה. הפריט יושב מיד אחרי ”ערוך תיאור“ ופותח מודאל באותו סגנון, עם שורת טקסט שהתגיות מופרדות בה בפסיקים — כמו בעריכה המהירה בדשבורד ובעמוד העריכה. המודאל נפתח עם התגיות הנוכחיות, ושמירה בלי שינוי אינה נשלחת. השמירה עוברת ב-POST /api/file/<id>/quick-update עם tags בלבד, ולכן updated_at אינו זז. מה שמוצג אחרי השמירה הוא מה שהשרת שמר, ולא מה שהוקלד: התשובה נושאת עכשיו tags, בקריאה חוזרת מהמסד (_read_back_file_tags), כי השרת מנרמל — Python נשמר כ-python. ההמרה לאותיות קטנות נשארה גם לתגיות repo:, בהחלטה מפורשת, למרות שעמוד הקבצים מקבץ ומסנן לפי התגית הזו ברגישות לרישיות; שמירה בלי שינוי אינה כותבת מחדש, ולכן תגית כזו משתנה רק כשמשנים את התגיות. הפריט אינו מוצג בגרסה ישנה, בקובץ שבסל ובקובץ גדול: quick-update כותב רק ל-code_snippets, וקובץ גדול יושב ב-large_files — ומאותה סיבה ”ערוך תיאור“ בקובץ גדול עונה היום ”הקובץ לא נמצא“, באג שלא תוקן כאן. נבדק ב-Chromium מול שרת חי, בכל שבע הערכות: המודאל זהה למודאל התיאור.

  • fix (WebApp): Escape בתוך מודאל בעמוד הקובץ סוגר אותו ולא עוזב את העמוד. מאזין המקלדת של העמוד מחזיר אחורה ב-Escape, והוא רץ לפני המאזין של המודאל — כך שסגירת מודאל התיאור ב-Escape גם עזבה את העמוד, וכך גם תפריט ⋮, מודאל ההיסטוריה, מודאל הסל והתמונה המוגדלת (נמדד ב-Chromium על הקוד הקודם). עכשיו Escape חוזר אחורה רק כשאין שכבה פתוחה (_escapeIsTakenByOpenLayer); מודאל ההיסטוריה ומודאל הסל, שאין להם Escape משלהם, נשארים פתוחים.

  • fix (WebApp): אחרי שינוי תגיות, עמוד הקובץ מציג את התגיות החדשות ולא את מה שהדפדפן זכר. שינוי תגיות — מהדשבורד, מתיוג מרובה או מהמודאל החדש — בכוונה אינו מזיז את updated_at, וה-ETag של העמוד לא כלל את התגיות. לכן הכניסה הבאה לעמוד קיבלה 304, הדפדפן הציג את התגיות הישנות, ומודאל התגיות היה נפתח איתן ודורס בשמירה את החדשות. התגיות נכנסו ל-_compute_file_etag; בלי שינוי העמוד עדיין מקבל 304.

  • change (WebApp): חיתוך אחד לשורת תגיות, ותגית שהוקלדה עם # נשמרת בלי ה-# בכל מקום. עמוד העריכה, עריכת קובץ גדול וההעלאה חתכו שורת תגיות לפי פסיק, # ושורה חדשה, בעוד ש-quick-update חתך לפי פסיק בלבד, והעריכה המהירה בדשבורד חתכה בעצמה ב-JS — ולכן #python נשמר שם כמו שהוא, ועמוד הקובץ הציג ##python. החיתוך יושב עכשיו ב-file_tags.split_tags_text, וכל המסלולים קוראים לו; הדשבורד שולח את הטקסט כמו שהוקלד. ב-quick-update: tags שאינו טקסט או רשימת מחרוזות נדחה ב-400 (עד היום מילון הפיל את הראוט ב-500, ומספר ברשימה הומר בשקט למחרוזת), גוף שאינו אובייקט JSON נדחה ב-400, וכפילויות נזרקות לפני שסופרים עד QUICK_UPDATE_MAX_TAGS — עד היום חזרות על אותה תגית ”תפסו“ מקום. עריכה, העלאה ותיוג מרובה ממשיכים לשמור את הרישיות כפי שהוקלדה; התיוג המרובה (bulk-actions.js) עדיין חותך לפי פסיק בלבד.

  • fix (WebApp): בלוקי קוד ב-Live Preview של עמוד העריכה ועמוד ההעלאה מוצגים כבלוק, עם הדגשת תחביר וכפתור העתקה בראשם. עד היום הקוד נראה שם כמו טקסט רגיל בגופן מונו, בלי רקע ובלי צבעים, וכפתור ההעתקה יצא ריבוע ריק מתחת לקוד. שני העמודים לא טענו את utils/safe-highlight.js, ש-live-preview.js מדגיש רק דרכו, ולא את האייקונים של Bootstrap שבכפתור, ול-split-view.css לא היה עיצוב לבלוק ולכפתור. התלויות של התצוגה החיה עברו לשני partials משותפים, _live_preview_styles.html ו-_live_preview_scripts.html, במקום רשימה שכל עמוד מחזיק לעצמו, ו-tests/sticky-notes-target.test.js בודק שכל עמוד שטוען את live-preview.js מספק אותן. לבלוק יש עכשיו רקע, מסגרת, פינות וריווח מטוקנים שנגזרים מצבעי התצוגה, שורה ארוכה נגללת בתוך הבלוק ולא מרחיבה את כל התצוגה, והכפתור יושב מימין בפס בראש הבלוק — גם בבלוק עברי, כמו בתצוגת המסמך. צבעי התחביר הם של הבאנדל, כמו בדפדפן הריפו, וערכה מיובאת מקבלת את צבעי התחביר שלה. נבדק בדפדפן מול השרת האמיתי, בשני העמודים ובערכות בהירות וכהות: הקוד מודגש, ולחיצה על הכפתור מעתיקה ללוח את הקוד. ראו מערכת ערכות הנושא והטוקנים החדשה, בסעיף ”Markdown Viewer ו‑Split View“.

  • feat (WebApp, MCP): החיפוש בפתקים לא מחזיר עוד פתקים מהארכיון, אלא אם ביקשו. בעמוד החיפוש יש תיבת סימון ”כלול ארכיון“, שמחזירה אותם, ותוצאה מהארכיון מסומנת ”ארכיון“; הבחירה נשמרת בכתובת העמוד, כמו הצבע. ב-MCP, codekeeper_search_notes מקבל include_archived, והתשובה אומרת אם הארכיון נבדק (searched_archive). ההסתרה יושבת ב-note_search_filter המשותף, ולכן שני החיפושים מחזירים אותו דבר. בגללה נוסף אינדקס, user_archived_updated_idx: בלעדיו מונגו שמרה במטמון את התוכנית של מילה נדירה, ומילה נפוצה שחופשה אחריה קראה את כל הפתקים הפעילים במקום לעצור בתקרה (נמדד בפרופיילר). חיפוש בפתקים, חיפוש בפתקים: למה רג’קס ולא $text, איך מחפשים קובץ ופתק — codekeeper_search_code ו-codekeeper_search_notes.

  • perf (WebApp): המיון של חיפוש הפתקים מחזיק רק את מה שהתשובה צריכה, ולא את גוף הפתקים. ה-$project שלפני המיון מונה עכשיו את השדות שנשארים במקום להחריג את content: ההחרגה, שבאה אחרי $addFields, לא הורידה את הגוף מהמיון. נמדד ב-explain: 1,792,484 בייטים במיון לפני, ו-57,260 אחרי, על אותה תוצאה. חיפוש בפתקים: למה רג’קס ולא $text.

  • fix (בוט + MCP): רשימות הקבצים לא ממיינות עוד את הקוד של כל הקבצים, ולכן לא יחזירו ”אין קבצים“ כשהקוד גדל. חמש רשימות ב-database/repository.py — הקבצים, תצוגת ריפו, חיפוש הקבצים, שמות הקבצים והמועדפים — מיינו את הגרסה האחרונה של כל קובץ עם הקוד שלה, לפני ההיטלה. אצל המשתמש הראשי המיון החזיק כ-20MB, כ-60% מהתקרה של האשכול; מעליה מונגו מחזירה שגיאה, והרשימה חוזרת ריקה בלי שום סימן — כולל הגיבוי ל-Drive. עכשיו ההיטלה לפני המיון, וכשהתשובה צריכה את הקוד (הגיבוי, המועדפים) הוא נשלף אחרי העימוד, רק לעמוד. התשובות עצמן לא השתנו: הושוו לפני ואחרי על אותם נתונים. 🚀 The Performance Bible: CodeKeeper Optimization Guide.

  • change (WebApp): השמות בכרטיסי עמוד הארכיון בכתב יד, תמיד. עד היום כתב היד הופיע בכרטיס רק כשההגדרה הכללית של כתב היד בלוחות דלוקה, כי המתג של כל לוח לא מגיע לארכיון. הפתק שנפתח מהכרטיס ממשיך להיות מוצג לפי ההגדרה. ארכיון.

  • feat (WebApp): ארכיון לפתקים — 🗃️ בתפריט ⋮ מעביר פתק לארכיון, ובעמוד הארכיון הפתקים מוצגים ככרטיסים. פתק שסיימתם איתו יורד מהלוח או מהקובץ ונשמר בארכיון, וזה המקום החדש שלו — בלי דרך חזרה למקום הקודם, ולכן השם שהיה לו בלוח משתחרר. לפתק בלי שם נפתח קודם חלון שם, עם הצעה מהכותרת או מהשורה הראשונה. תזכורת פעילה נשארת פעילה, ושרשורי תגובות פתוחים מסומנים ”נפתר“. הכניסה — כפתור ”🗃️ ארכיון“ בראש עמוד הלוחות: כרטיסים בצבע הפתק, מהחדש לישן, ולחיצה על כרטיס פותחת את אותו פתק במרכז המסך, לעריכה, הזזה ושינוי גודל (הגודל נשמר, המקום לא). הקישור הקבוע /note/<id>, התראות ותוצאות חיפוש פותחים פתק שבארכיון בעמוד הארכיון. בארכיון עד MAX_ARCHIVED_NOTES_PER_USER פתקים, בנוסף לתקרה של 1000, שכבר אינה סופרת פתקי ארכיון — בכל כותב, בוובאפ, ב-MCP ובשחזור מגיבוי. פתק ארכיון שורד גיבוי ושחזור (עד היום פתק בלי לוח ובלי קובץ נזרק בשחזור בשקט). בשרת: יעד רביעי (archived_at), כתיבה מותנית אחת, ואינדקס user_archived_idx שעונה על הספירות בלי לקרוא מסמך (נמדד ב-explain). ארכיון, ארכיון: היעד הרביעי, ארכיון: המנהל במצב ארכיון, העמוד וחלון השם.

  • fix (WebApp): מחיקת פתק שנכשלה בשרת כבר לא מורידה אותו מהמסך. עד היום × הוריד את הפתק גם כשהבקשה נכשלה, כלומר פתק שנשאר במסד נראה כאילו נמחק עד הרענון הבא. עכשיו הפתק יורד רק כשהשרת אישר (או ענה שהפתק כבר אינו קיים), ובכשל מוצגת הודעה. בכל המשטחים: לוח, תצוגת Markdown, דפדפן הריפו והארכיון.

  • docs (Observability): סעיף פתקים דביקים בקטלוג האירועים. עד היום אף אירוע של הפתקים לא הופיע בקטלוג. פתקים דביקים.

2026-10-24

  • feat (WebApp): תפריט ⋮ בסוף שורת הפעולות של הפתק, ו-🔔 עבר אליו. הכפתור ⋮ פותח עמודה קטנה של כפתורי אייקון — הפעולות שמשתמשים בהן פחות, ולכן אינן צריכות מקום קבוע בשורה. היום יש בה כפתור אחד, 🔔, קביעת תזכורת. התפריט נפתח כלפי מטה אל תוך הפתק, וכלפי מעלה רק כשאין מתחתיו מקום; ליד קצה המסך הוא זז פנימה. ⋮ יושב בסוף השורה בכוונה, ולכן בפתק צר הוא הראשון שנחתך — במקום ×, שהיה עד היום הראשון שנחתך. ההתנהגות ב-תפריט ⋮, והנימוק ב-תפריט ⋮: הפעולות הנדירות, ומה קובע לאן הוא נפתח.

  • docs (פתקים): העמוד למפתחים של הפתקים הדביקים פוצל לשער ולעמוד לכל שכבה — השרת והמסד, מנוע המארקדאון, והממשק בדפדפן. עד היום כל העקרונות ישבו ב-עקרונות להוספת פיצ’ר לסטיקי-נוטס, בעמוד של כ-230KB. החלוקה היא לפי השכבה ההנדסית ולא לפי פיצ’ר, כי הכללים שחוזרים בכמה פיצ’רים שייכים לשכבה: עקרונות להוספת פיצ’ר לסטיקי-נוטס — השרת, המסד והחוזים בין השירותים מחזיק את מה שחי בפייתון ובמונגו ואת החוזה בין השרת ללקוחות שלו; עקרונות להוספת פיצ’ר לסטיקי-נוטס — מנוע הרינדור והמארקדאון של הפתק את המנוע שבונה את תצוגת הפתק מהטקסט; ו-עקרונות להוספת פיצ’ר לסטיקי-נוטס — הממשק בדפדפן: גאומטריה, אינטראקציה וניגודיות את הפתק כווידג’ט בדפדפן. הגופנים, החיפוש והשרשורים חוצים שכבות, ולכן הם מפוצלים לפי השכבה, ובכל צד יש קישור לצד השני. סעיף הצבע נשאר שלם בעמוד השרת, כולל הבורר והמדידות שכל צבע חדש צריך לעמוד בהן, כי מי שמוסיף צבע לפלטה צריך את שניהם יחד; הצבעים של רכיבים על הנייר נשארו ליד הרכיב שלהם, בעמוד המארקדאון ובעמוד הממשק, והסעיף על הבורר מקשר אליהם. השער שומר על הנתיב ועל הכותרת, ומחזיק את הפתיח ואת התיעוד למשתמש הוא חלק מהפיצ’ר. הטקסט עבר מילה במילה, חוץ מהרשימה הזו: ‏(1) כותרת, :summary: ושורת פתיחה לכל עמוד חדש, :summary: חדש לשער, ופסקה בשער שמפנה לעמודים; ‏(2) הפניות שהיו נשברות — ”הסעיף הקודם“, ”למעלה“, ושם של סעיף או של כלל שעבר לעמוד אחר — הן עכשיו :ref:; ‏(3) קישור לצד השני בכל סעיף של נושא שחוצה שכבות — שורה בראש הסעיף, או קישור בתוך המשפט שכבר מפנה לשם — וכותרת חדשה בעמוד השרת, שרשורי תגובות: השרת, מעל הסעיף על השרת של השרשורים; ‏(4) הסעיף ”מה לבדוק, ובמה“ התפצל: המודל הטהור והאינדקס הייחודי בסוף עמוד השרת, והחיווט של הלקוח והגאומטריה של פתקי ריפו בסוף עמוד הממשק; ‏(5) תוויות חדשות וקישורי מעבר בשער — ראו ”העוגנים“ בהמשך. נבדק ב-24.10.2026 בהשוואה של כל השורות: כל שורה במקור נמצאת באחד מהקבצים, מילה במילה או עם שינוי מהרשימה הזו, וכל שורה בהם מגיעה מהמקור או מהרשימה. העוגנים: התוויות לא השתנו, ולכן כל :ref: ממשיך להגיע לסעיף שלו, בעמוד החדש — מה שהשתנה הוא העמוד שבכתובת. כתובת ישנה מהצורה dev/sticky_notes_extending.html#<תווית> נפתחת בראש השער, ולכן יש בו סעיפים שעברו לעמודים אחרים, עם קישור לכל תווית שעברה: sticky-notes-content-as-sent לעמוד השרת, sticky-notes-inline-code לעמוד המארקדאון, ו-sticky-notes-new-note-size, sticky-notes-copy-id ו-sticky-notes-threads-ui לעמוד הממשק. כותרת בעברית בלי תווית מקבלת מ-Sphinx מספר רץ (id1, id2…), ולכן קישור ישן מהצורה dev/sticky_notes_extending.html#idN אינו מגיע עוד לסעיף שלו. נוספו תוויות לסעיפים שהפניות מעמוד אחר מגיעות אליהם, ולסעיף שנשאר בשער. ההפניות לנימוק מ-פתקים דביקים (Sticky Notes), מ-מבנה נתונים מפורט (Detailed Database Schema), מ-ניקוי קוד מודבק (Pasted-code cleanup) ומ-WebApp API Reference מצביעות עכשיו על העמוד שבו הוא נמצא, וכך גם הערות בקוד ובטסטים שמפנות לסעיף שעבר — רק הנתיב השתנה.

2026-10-23

  • ci (docs): התקנת הדפדפן לייצוא הסעיפים לא מורידה עוד פונטים ממאגר החבילות של אובונטו. --with-deps הריץ apt-get על פונטים (סינית, יפנית, תאית ועוד) ועל עדכוני גרסה לספריות שכבר מותקנות במכונה של GitHub, והמאגר היה לפעמים איטי מאוד: בשבע ריצות של documentation.yml שנבדקו ב-23.10.2026 הצעד לקח בארבע פחות מחצי דקה, באחת כמעט שלוש דקות, ובשתיים נקטע כשנגמר לו הזמן (timeout-minutes). בריצה שנקטעת האתר נפרס בלי _export/sections.json, וב-main נשלחת גם התראה לטלגרם. הייצוא לא צריך את הפונטים, כי הוא ממיר את ה-HTML למארקדאון ולא מצייר טקסט. ספרייה שתחסר יום אחד במכונה תכשיל את הייצוא: Playwright בודק אותן כשהוא מפעיל את הדפדפן, ונכשל עם שגיאה ברורה שמגיעה לאותה אזהרה ולאותה התראה. הנימוק והמקורות בהערה שמעל השורה ב-.github/workflows/documentation.yml.

  • feat (WebApp): גלריית צילומי מסך ציבורית ב-/gallery, לקישור מפוסטים, מה-README ומהיועץ בבוט. צילום אחד בכל פעם על כל רוחב המסך, עם כותרת, משפט הסבר, ”הקודם“ ו“הבא“ ומונה. בנייד מחליפים צילום בהחלקה — אצבע ימינה מביאה את הבא, כמו חץ שמאלה במקלדת — ומגדילים בשתי אצבעות, ובזמן הגדלה גרירה מזיזה את התצוגה ולא מחליפה צילום. לכל צילום כתובת משלו (/gallery#3), צילום מוצג רק אחרי שהוא נטען, והבא נטען מראש. העמוד לא דורש התחברות ופטור ממגבלת הקצב הגורפת, ותגיות ה-og: נותנות לקישור תמונה בוואטסאפ ובטלגרם. הצילומים והכיתובים ב-GALLERY_SLIDES (webapp/gallery.py), והתמונות מיוצרות ב-scripts/build_gallery_image.py. בדרך, הכלל שבונה את כתובת הבסיס המלאה של הוובאפ, שהיה כתוב פעמיים בקישורי השיתוף, עבר לפונקציה אחת, _webapp_base_url. ראו גלריית צילומי המסך (/gallery).

  • change (WebApp): כניסה לווב אפ כבר לא מעבירה לעמוד האחרון שביקרתם בו. עד היום base.html שמר בכל עמוד את הכתובת שלו, ובכניסה מבחוץ ל-/ או ל-/dashboard — מסימנייה, מקישור או מהאפליקציה המותקנת, שנפתחת ב-/ — העביר לעמוד ששמר. אותו מעבר רץ גם ברענון ובכפתור ”אחורה“, פעם אחת בכל טאב, ולכן הלחיצה הראשונה על ”אחורה“ החזירה קדימה לעמוד שממנו יצאתם (נמדד בכרומיום). הסקריפט (workStatePersistence) הוסר כולו, ואיתו השליחה של work_state ל-/api/ui_prefs ביציאה מעמוד, במעבר לטאב אחר ובלחיצה על קישור: השרת כבר לא שומר אותו, ו-/api/me כבר לא מחזיר אותו. גם מיקום הגלילה היה חלק מהמנגנון, אבל בעמודים שנמדדו (/settings ו-/dashboard) הוא נשמר תמיד כ-0: html, body ב-base.html מקבלים height: 100% עם overflow-x: hidden, ולכן נגלל ה-body ולא החלון שהסקריפט קרא ממנו. מקיצורי הדרך של האפליקציה המותקנת (manifest.json) ירד entry=shortcut, שהיה שם רק כדי לעקוף את המעבר. מה שכבר נשמר — ui_prefs.work_state במסד ו-work_state ב-localStorage — נשאר, ואף קוד לא קורא אותו.

2026-10-22

  • feat (Bot): מצב היועץ — שיחה עם מודל שפה שעונה אם CodeKeeper מתאים לאופן שבו הגולש עובד. נכנסים ב-/advisor או בקישור t.me/my_code_keeper_bot?start=advisor, ויוצאים בכפתור שבכל תשובה או ב-/cancel. עד היום היועץ רץ כבוט נפרד (codekeeper_advisor_bot) עם שירות משלו. כאן הוא מצב בתוך הבוט, כי טקסט חופשי בבוט הוא קוד לשמירה: הודעה שהיועץ לוקח לא מגיעה לשמירה, וכל פעולה אחרת מוציאה ממנו. זיכרון השיחה והמכסה היומית במונגו, עם TTL. מגבלת הקצב של הבוט עוצרת הצפה ולא עלות, ולכן נוספה מכסה יומית לכל גולש. ההגדרות במשתני ADVISOR_*, והפירוט ב-מצב היועץ (/advisor).

2026-10-19

  • feat (WebApp): בדשבורד יש צ’קליסט ”צעדים ראשונים“, והצעדים בו מסתמנים לבד לפי מה שהמשתמש עשה בפועל. משתמש חדש מוצא בדשבורד כרטיס עם הצעדים הראשונים: ערכת נושא, אוסף ראשון, פתק על לוח וחיבור סוכן AI. כל צעד נפתח בלחיצה, בנגיעה או במקלדת, ומציג הסבר וכפתור שמוביל ישר למקום. הסימון נגזר מהנתונים עצמם ולא מדגל לכל צעד, ולכן הוא לא משקר ואין מה לסנכרן בין מכשירים. כשכל הצעדים בוצעו נשמר ui_prefs.first_steps_done, והכרטיס נעלם; מאותו רגע הוא לא מריץ אף שאילתה, כי הדגל נקרא ממסמך המשתמש שכבר נשלף בבקשה — _request_user_doc שולף אותו פעם אחת לבקשה, ו-inject_globals קורא מאותה שליפה. ”הבנתי, להסתיר“ נשמר בשרת דרך /api/ui_prefs (first_steps_hidden), כלומר בכל המכשירים, ו“הצג שוב את הצעדים הראשונים“ בתחתית עמוד ההגדרות מחזיר את הכרטיס ומשאיר אותו עד שמסתירים אותו שוב, גם כשכל הצעדים בוצעו. השורה מתחת ל“הבנתי, להסתיר“ אומרת איפה הוא. ערכה שנבחרה ”רק במכשיר הזה“ נשמרת רק ב-cookie, ולכן ברגע הבחירה נרשם במסמך המשתמש שנבחרה ערכה (ui_prefs.device_theme_chosen), כדי שהצעד ייחשב בכל המכשירים. צעד שהבדיקה שלו נכשלה במסד מוצג ”לא ידוע כרגע“ ולא ”לא בוצע“, ואינו נועל. ”לוח העבודה“ מוביל ל-/boards/default, ראוט חדש שיוצר את לוח ברירת המחדל אם עוד אין ומפנה אליו. בפריסה של שלוש עמודות הכרטיס פורש על שתיים, כי בשורות שלו טקסט ארוך. את שולחן העבודה מזהים לפי השם בלבד, ולכן השם הוא עכשיו קבוע, WORKSPACE_COLLECTION_NAME במודול האוספים; העותקים שעוד מוקלדים מחוץ למודול — #3594. הפירוט ב-הצ’קליסט ”צעדים ראשונים“ בדשבורד.

  • feat (WebApp): בסעיף ”חיבור סוכן AI“ בהגדרות יש בלוק מתקפל ”מה אפשר לבקש מהסוכן“. הבלוק יושב מתחת ללשוניות, סגור כברירת מחדל, ובו דוגמאות לבקשה ראשונה — פתק בלוח, חיפוש קובץ, סיכום של מסמך מאוסף ושמירת סקריפט כקובץ — כדי שמי שחיבר עכשיו לא יישאר מול חלון צ’אט ריק.

  • fix (WebApp): ”הגדרות מתקדמות“ בבורר הערכות שבסרגל מגיע לכרטיס ערכת הנושא בהגדרות. הקישור הוביל ל-/settings#appearance, ובעמוד ההגדרות לא היה אלמנט עם העוגן הזה, ולכן העמוד נפתח בראשו. עכשיו לכרטיס ”ערכת נושא“ יש id="appearance", והוא גם היעד של ”לבחירת ערכה“ בצ’קליסט ”צעדים ראשונים“.

  • change (WebApp): בשורת הקטגוריות של עמוד הקבצים נכנס ”סטיקי נוטס“, ויצאו ”לפי ריפו“ ו“שאר קבצים“. ”מועדפים“ עבר למקום של ”לפי ריפו“, ובמקום של ”מועדפים“ נכנס כפתור חדש, ”סטיקי נוטס“, שמוביל לעמוד לוחות הפתקים (/boards) — עם אותו אייקון פתק כמו כפתור הלוחות בשורת הכלים שמתחת לחיפוש. רק הכפתורים הוסרו: הקטגוריות עצמן, /files?category=repo ו-/files?category=other, נשארות ועובדות בכתובת ישירה. ”שאר קבצים“ הוא ”כל הקבצים“ בלי קבצים עם תגית ריפו ובלי ZIP (category_file_match בענף other ב-webapp/app.py), ולכן ”כל הקבצים“ מציג כל קובץ שהוא הציג. האייקון מגיע ממאקרו אחד בתבנית, note_sheet_icon ב-webapp/templates/files.html, ששני הכפתורים משתמשים בו. tests/test_files_notes_buttons.py בודק את השורה כפי שהראוט מגיש אותה, ושאייקון החיפוש בפתקים — עותק של אותו דף עם חיתוך — לא נפרד מהציור של המאקרו.

  • fix (WebApp): החיפוש בתוך קובץ בדפדפן הקוד עובד בתצוגה המרונדרת — בקובץ Markdown ובעמוד rst. עד היום החיפוש ספר את המקור ולא את מה שמוצג, והבא/הקודם בחרו טקסט בעורך, שמוסתר בתצוגה הזו: המונה זז, ושום דבר על המסך לא הודגש ולא נגלל. בקובץ Markdown הספירה כללה גם מה שלא מוצג, כמו כתובת של קישור, ובעמוד rst היא נספרה בקובץ ה-rst — עם הסימון שלו, ובלי מה שהעמוד מציג מקובץ אחר, כמו קוד מ-literalinclude. עכשיו בתצוגה המרונדרת החיפוש עובר על מה שמוצג, דרך window.TextHighlight — אותה הדגשה של החיפוש במסמך ושל החיפוש בתוך פתק: כל ההתאמות מודגשות, הפעילה בולטת, והבא/הקודם גוללים אליה. נגללת רק התצוגה, ולא הדף: scrollIntoView גלל גם את body של דפדפן הריפו, והדף כולו זז למעלה. לכן פונקציית הגלילה של החיפוש בתוך פתק עברה למודול, scrollIntoViewWithin, והפתקים ודפדפן הריפו משתמשים בה שניהם. חיפוש פתוח רץ שוב במעבר בין התצוגות ובגרסה מההיסטוריה, וסגירה מנקה את ההדגשות. בתצוגת הקוד אין שינוי. ראו חיפוש בתוך הקובץ בתצוגה המרונדרת.

  • fix (WebApp): חיפוש מילה שמופיעה בנוסחה כבר לא סופר את מקור ה-TeX שלה. KaTeX שומר בתוך כל נוסחה את מקור ה-TeX (<annotation>), והדפדפן לא מציג אותו — ובכל זאת ההדגשה ספרה אותו, ומעבר אליו לא הראה כלום. DEFAULT_SKIP ב-utils/text-highlight.js מדלג עכשיו על כל ילד של <semantics> שאינו הראשון, לפי הכלל בגיליון ברירת המחדל. חל על החיפוש במסמך ועל החיפוש בתוך קובץ בדפדפן הקוד; הפתקים לא מרנדרים נוסחאות.

  • fix (WebApp): בדפדפן הקוד, רינדור איטי של גרסה קודמת מההיסטוריה כבר לא נכתב מעל הגרסה שנבחרה אחריה — גם בקובץ Markdown. עד היום נבדקה רק הטעינה של עמוד rst מאתר התיעוד, ולא הרינדור עצמו, וקובץ Markdown לא נבדק כלל. מונה אחד לכל רינדור של התצוגה (previewRenderSeq ב-repo-browser.js) מחליף את המונה של הטעינה, וכל כתיבה לתצוגה בודקת שהיא של הרינדור האחרון — ולכן גם החיפוש הפתוח רץ על הגרסה שמוצגת.

  • feat (Observability): התראה לבוט כשאינדקס התיעוד נכנס להמתנה לאישור. עד היום מעבר שעצר לאישור — למשל אחרי מיזוג שיצר יותר נתחים להטמעה מ-APPROVAL_THRESHOLD_CHUNKS — כתב רק את האירוע docs_index_awaiting_approval, שמגיע ללוג ולא לטלגרם. כך האינדקס נשאר על קומיט ישן כמעט 18 שעות, וכל מיזוג אחר כך חישב מחדש את הפער המצטבר ועצר שוב בשקט. עכשיו הכניסה להמתנה שולחת התראה בחומרת warn (ALERT_APPROVAL_NEEDED ב-services/docs_index_service.py): כמה נתחים להטמעה מול התקרה, הקומיט שנבדק מול הקומיט שבאינדקס, ושורת Quick Fix לעמוד האדמין. מעבר שעוצר שוב בזמן שהאינדקס כבר מחכה אינו שולח עוד אחת: ההחלטה נגזרת מהמסמך שהכתיבה של approval מחזירה, כמו שהוא היה לפניה. failed לא קיבל התראה חדשה: האירוע שלו נשלח ל-Sentry, ומשם לטלגרם כש-SENTRY_POLL_ENABLED דלוק. ו-paused_quota ממשיך מעצמו במעבר הבא. בדרך, שורת ה-Quick Fix הגיעה גם להתראות שאינן קריטיות, אבל רק להתראה שה-alert_type שלה מוביל ל-runbook משלו (quick_fix_line_for_bot_alert ב-services/observability_dashboard.py). עד היום היא הופיעה רק בהתראות קריטיות. נתיב יחסי בשורה הזו מגיע עכשיו לטלגרם כקישור מלא, לפי PUBLIC_URL — גם בהתראות הקריטיות, שבהן הוא הגיע עד היום כטקסט שאי אפשר ללחוץ עליו. ראו אינדקס התיעוד.

  • feat (WebApp): בדפדפן הקוד, עמוד rst של אתר התיעוד מוצג מרונדר, באותה תצוגה של קובץ Markdown. המארקדאון לא נבנה בוובאפ: מעבר האינדוקס של התיעוד מרכיב כל עמוד rst מהסעיפים שלו בקובץ הייצוא של האתר — כל הסעיפים, לפי הסדר, וכל כותרת ברמה שלה — ושומר אותו באוסף החדש docs_pages (page_markdown ב-services/docs_index_service.py). לכן ההמרה היא של Sphinx, כמו באתר. /repo/api/file מחזיר has_docs_page, והכפתור מוצג רק לקובץ שיש לו עמוד; עמודי docs/api/ אינם בייצוא, ונשארים קוד. העמוד מגיע מ-/repo/api/docs-page/<path>, והרינדור הוא אותו renderMarkdownPreview של קובץ Markdown. סעיפי החיפוש לא הספיקו לזה: אין בהם סדר, הם מדלגים על כותרת בלי גוף ועל ”ראו גם“, וביומן עדכונים הם עדכונים ולא ימים. ראו עמודי התיעוד (rst).

  • feat (WebApp): שורה מעל העמוד המרונדר כשהקובץ — או קוד שהעמוד מציג מקובץ אחר — השתנה אחרי הבנייה האחרונה של האתר. freshness בתשובה משווה את התוכן (ה-blob) בקומיט שהאינדקס נכון אליו מול הקומיט האחרון שהמראה סונכרנה אליו (last_synced_sha; ולא commit_sha של הקובץ, שהסנכרון מעדכן רק כשהקובץ עצמו משתנה): של הקובץ, ושל כל קובץ אחר שהעמוד נבנה ממנו — למשל docs/conversation-handlers.rst, שמציג קוד מ-handlers/save_flow.py ב-literalinclude. קומיט שלא נגע בהם אינו שינוי, וכשרק קובץ אחר השתנה השורה נוקבת בו. כשאי אפשר להשוות — מעבר באמצע, או קומיט שהמראה עוד לא משכה — השורה אומרת את זה. בגרסה מההיסטוריה ההשוואה היא לגרסה שנבחרה (services/docs_page_view.py).

  • feat (docs): קובץ הייצוא נושא את הכותרת של כל סעיף גם כמארקדאון ואת הקבצים שכל עמוד נבנה מהם, ו-SCHEMA_VERSION עלה. title_markdown היא הכותרת בהמרה של כפתור ההעתקה, כך שקוד והדגשה בכותרת נשארים בעמוד המורכב. התקרה שלה, MAX_TITLE_MARKDOWN_BYTES, נגזרה מהכותרת הארוכה באתר החי (19.10.2026), ושבירת שורה בה נדחית בשני צדי החוזה. dependencies הם הקבצים בריפו ש-Sphinx רשם כקלט של העמוד (env.dependencies): סקריפט הייצוא הוא גם הרחבה של Sphinx (docs/conf.py), שכותבת אותם בסוף הבנייה, והתקרות שלהם (MAX_DEPENDENCY_PATH_BYTES, MAX_PAGE_DEPENDENCIES) נגזרו מבנייה מקומית באותו יום. ראו Doc Authoring Guide (Sphinx/RTD). במעבר בין הגרסאות: הוובאפ קורא רק את הגרסה שלו. אם האתר נפרס לפני הוובאפ, המעבר של הפריסה נכשל ב-export_unsupported_schema ולא משנה כלום, ואחרי שהוובאפ עולה ”בדוק עכשיו“ בעמוד האדמין בונה את האינדקס. גם RECORDS_VERSION עלה, ולכן הבדיקה לא נעצרת על ”הקובץ לא השתנה“.

  • fix (docs): כפתור ”העתק תוכן הדף“ לא מוחק עוד כותרות בעמוד עם תוכן עניינים. .. contents:: עוטף את הטקסט של כל כותרת בקישור חזרה לתוכן העניינים (toc-backref), והכפתור מחק את הקישור יחד עם הטקסט. עכשיו הקישור יוצא והטקסט נשאר (UNWRAP_SELECTORS ב-docs/_static/copy-page.js). אותו ממיר כותב את קובץ הייצוא, ולכן גם בעמוד המורכב הכותרות במקומן. ראו Doc Authoring Guide (Sphinx/RTD).

  • fix (docs): בעמוד החיפוש הגלובלי ”תיעוד“ מודגש כמו שצריך. ו**תיעוד** הוצג באתר עם הכוכביות, כי ב-rst הדגשה מתחילה רק אחרי רווח או פיסוק. עכשיו ו\ **תיעוד**, כמו שמוסבר ב-רשומה ב-What’s New.

  • fix (WebApp): הכפתורים בעמוד השיתוף הציבורי עובדים — העתקה, הורדה, תצוגת Markdown ומצב קריאה. מאז #449 (ספטמבר 2025) /share/<share_id> מרנדר את התבנית של עמוד הקובץ של הבעלים, view_file.html, וכל כפתור בה נבנה ממזהה הקובץ — שבעמוד שיתוף הוא מזהה השיתוף. ”ערוך“, ”תצוגת Markdown“, ”הורד“ ו“השוואת גרסאות“ הובילו ל-/edit/<share_id>, /md/<share_id>, /download/<share_id> ו-/compare/<share_id>: אורח הופנה להתחברות, ומשתמש מחובר קיבל 404. לצידם הופיעו מועדפים, הוספה לאוסף, תיאור, היסטוריה, העברה לסל, שיתוף מחדש וסימניות, ו“העתק קוד“ לא העתיק דבר (נמדד בדפדפן: הלוח נשאר ריק), כי העמוד לא קיבל את הטקסט הגולמי. עד #3585 אף אחד לא הגיע לכפתורים האלה, כי הקובץ נקטע אחרי כמה עשרות שורות. עכשיו התבנית מקבלת is_public, ובעמוד הציבורי נשארות רק פעולות שיש להן נתיב ציבורי: ”העתק קוד“ מהטקסט הגולמי, ”הורד“, ובקובץ Markdown גם ”תצוגת Markdown“ ו“📖 מצב קריאה“. Escape כבר לא מוציא את המבקר מהעמוד, והכפתורים נשברים לשורה נוספת במקום להיחתך כשאין להם מקום. tests/test_public_share_page_actions.py נופל על כפתור חדש בסרגל שלא הוחלט אם הוא ציבורי. ראו המיני Web App (סקירה).

  • fix (WebApp): הורדה מעמוד השיתוף עובדת לכל שיתוף שיש בו תוכן. עד היום /share/<share_id>/download הוריד רק שיתוף ששדה ה-mode שלו download, ושני הכפתורים שיוצרים שיתוף בוובאפ (בעמוד הקובץ ובתצוגת ה-Markdown) שולחים רק permanent או temporary, כלומר אף שיתוף מהוובאפ לא היה כזה. גם שיתוף מהבוט, שאין בו mode בכלל, החזיר 404. ההגבלה נולדה ב-#2235, כששיתוף ”תצוגה מקדימה“ שמר רק את תחילת הקובץ, ומאז שכל שיתוף שומר את התוכן המלא אין לה סיבה. ההורדה מגישה עכשיו בדיוק את מה שהעמוד מציג, ושיתוף בלי תוכן מחזיר 404 ונספר ב-share_without_content. POST /api/share/<file_id> כבר לא שומר mode, כי שדה שאיש אינו קורא היה מתאר הרשאה שאינה קיימת; שיתופים ישנים עדיין נושאים אותו, והוא לא נקרא.

  • fix (WebApp): ”העתק קוד“ שומר את השורה הריקה הראשונה של קובץ שמתחיל בה. הכפתור, בעמוד הקובץ ובעמוד השיתוף, וגם התצוגה המתקדמת, קוראים את הקוד מ-<textarea id="rawCode"> ב-view_file.html. התוכן ישב צמוד לתגית הפתיחה, והדפדפן בולע שורה חדשה אחת שצמודה לה (HTML Living Standard, ה-”in body“ insertion mode) — כך שקובץ שמתחיל בשורה ריקה הועתק בלעדיה. נמדד ב-Chromium: "\n\nimport os" הועתק כ-"\nimport os". עכשיו יש שורה חדשה מכוונת אחרי תגית הפתיחה, והדפדפן בולע אותה במקום את השורה של הקובץ.

2026-10-18

  • fix (WebApp): שולח הפושים קם רק בתהליך השרת של הוובאפ — לא בבוט, לא בסקריפטים ולא בטסטים. start_sender_if_enabled נקרא בזמן הטעינה של webapp/app.py, ולכן כל תהליך שייבא ממנו סמל אחד הרים push-sender משלו. בבוט, שמייבא את webapp.app בג’וב חימום הקאש, הוא רץ בכל סבב ונכשל על מפתח VAPID חסר (push_send_missing_vapid_private בלוג של שירות הבוט) — בלי לבלוע תזכורות, כי הכשל קורה לפני שהוא תופס אחת. בתהליכי הטסטים הוא החזיק את _DB_INIT_LOCK בזמן חיפוש שרת מונגו, וכך נתקעו ב-CI של #3585 שמונה טסטים. עכשיו הוא מוגן באותו שומר כמו מתזמן הגיבויים, _is_webapp_runtime, שהופרד מ-FORCE_BACKUP_SCHEDULER: הדגל הזה מבטיח רק את מתזמן הגיבויים, ונשאר אצלו. והשומר עצמו מדויק יותר, לשניהם: הוא משווה את שם קובץ ההרצה ב-sys.argv[0] (gunicorn, או __main__.py של python -m gunicorn), ולא מחפש את המילה ”gunicorn“ או ”flask“ בכל הנתיב — כך שסקריפט שיושב בתיקייה בשם flask-migrations כבר אינו נחשב לשרת. גם שולח שלא קם כבר אינו שקט: start_sender_if_enabled בלע עד היום כשל בהרמת ה-thread וגם את סוף הלולאה, ועכשיו הראשון נרשם כ-Failed to start push sender, השני כ-push sender loop stopped, ועלייה מוצלחת כ-Push sender thread started. ראו עובדי Push.

  • fix (tests): freezegun כבר לא מקפיא את השעון של pymongo. freeze_time מקפיא את time.monotonic לכל התהליכונים, וחיפוש שרת שהתחיל בזמן ההקפאה חישב מועד אחרון שהשעון האמיתי לא מגיע אליו — כך הוחזקה הנעילה לתמיד ב-CI של #3585. tests/conftest.py מוסיף את pymongo לרשימת ההתעלמות של freezegun. ראו Testing Guide.

  • fix (WebApp): קישור שיתוף מציג את כל הקובץ ולא רק את תחילתו, ושיתוף מהבוט כבר אינו עמוד ריק. מאז #2235 (דצמבר 2025) POST /api/share/<file_id> שמר בשיתוף רק את 2000 התווים הראשונים של הקובץ, ו-/share/<share_id> קרא את המסמך בלי code. כל כפתורי השיתוף בוובאפ — הזמני, הקבוע ו“שתף בטלגרם“, מעל המסמך ובתחתיתו — הובילו לקובץ שנקטע אחרי כמה עשרות שורות, וכך גם /share/welcome, מצב הקריאה ותצוגת הקוד בעמוד השיתוף. ”שמור לקבצים שלי“ בעמוד השיתוף נכשל ב“השיתוף אינו כולל תוכן מלא“, ושיתוף ”📱 קישור פנימי“ מהבוט, ששומר את התוכן המלא בלי תצוגה מקדימה, הוצג ריק. עכשיו השיתוף שומר את התוכן המלא של הגרסה ששותפה והעמוד מציג את כולה; שיתוף בלי תוכן מחזיר 404 ונספר באירוע share_without_content, במקום עמוד ריק — וזה גם מה שקורה לשיתוף שנוצר בוובאפ לפני התיקון, שנשמר בלי התוכן המלא. ראו המיני Web App (סקירה).

  • feat (WebApp): מודאל השיתוף אומר לכמה זמן הקישור הזמני תקף. הכפתור מציג למשל ”קישור זמני (7 ימים)“ במקום ”קישור זמני“ בלבד, והשורה שמעליו אומרת אחרי כמה זמן הוא פג. המשך נגזר מ-PUBLIC_SHARE_TTL_DAYS — אותו ערך שקובע את expires_at של השיתוף — דרך public_share_ttl_label ב-inject_globals, בשני המודאלים: בעמוד הקובץ ובתצוגת המארקדאון. יום ויומיים מוצגים בעברית תקנית.

  • fix (tests): דמת המונגו המשותפת מכבדת היטלת החרגה, כמו מונגו. tests/_fake_mongo.py מימש עד היום רק הכללה, ולכן {"code": 0} החזיר את code, וקוד שקורא שדה שהוא עצמו החריג עבר מול הדמה ונשבר במסד — זה מה שהסתיר את שיתופי הבוט הריקים. עכשיו גם _id: 0 לצד הכללה מסיר את _id, ושילוב של הכללה והחרגה נדחה ב-OperationFailure 31254, כמו במונגו (נמדד מול mongod 7.0.14, וה-$project המקביל מול אשכול הייצור).

  • feat (CI): על כל PR חדש מתפרסמת פואמה קצרה בעברית, כתגובה אחת על ה-PR. ה-workflow החדש .github/workflows/pr-poem.yml רץ כשנפתח PR וכשטיוטה מסומנת כמוכנה לסקירה, ושולח למודל את הכותרת, את התיאור ואת שמות הקבצים שהשתנו, בלי ה-diff. מהתיאור יורדים קודם הבלוקים שהבוטים מוסיפים לו (cubic ו-Sourcery). ההנחיה לסוכן והדוגמאות יושבות ב-.github/pr-poem/, ונשלחות כמו שהן. הן והסקריפט נלקחים מענף ברירת המחדל ולא מה-PR, כי הם רצים עם המפתח. כל PR מקבל פואמה אחת לכל היותר, לפי סימון נסתר בתגובה, והפואמה של CodeRabbit לא נחשבת. התגובה מתפרסמת בשם GitHub App, כש-POEM_APP_ID ו-POEM_APP_PRIVATE_KEY מוגדרים, ובלעדיהם בשם github-actions עם אזהרה. שורה בלי אף אות עברית, כמו החתימה CodeKeeper forever 💫, מוצגת משמאל לימין, כך שהאימוג’י נשאר בסופה. מה צריך להגדיר (ה-secrets ANTHROPIC_API_KEY, POEM_APP_ID ו-POEM_APP_PRIVATE_KEY), איך מחליפים מודל ואיך מריצים ידנית על PR קיים: פואמה על PR.

  • feat (WebApp): בהגדרות יש סעיף קבוע ”חיבור סוכן AI“ — איך מחברים את Claude.ai, את Gemini ואת Claude Code לקבצים. עד היום ההוראות לחיבור סוכן לשרת ה-MCP היו רק בבוט, בפקודה /connect_claude, ובאתר לא היה להן מקום — גם לא למשתמש ותיק שמחבר מכשיר או לקוח חדש. הסעיף (העוגן /settings#ai-connect) מציג לשונית לכל לקוח: Claude.ai, בלי טוקן, דרך Add custom connector והתחברות עם הטלגרם; Gemini, בגרסת הרשת בלבד, דרך ”אפליקציות מקושרות“; ו-Claude Code / Desktop, עם טוקן אישי מ-/connect_claude (או /connect_claude write לטוקן עם הרשאת כתיבה) וקישור לבוט. הכתובת שמדביקים מוצגת עם כפתור העתקה, ונבנית מ-MCP_SERVER_URL של הוובאפ ואחריו MCP_ENDPOINT_PATH — קבוע חדש ב-mcp_server/public_url.py, ו-test_every_route_answers_401_without_a_token_except_a_closed_list מוודא שהשירות אכן מגיש אותו. כתובת שלא הוגדרה, או שנדחתה בבדיקה של הפקודות בתיאורי הכלים (why_not_usable, למשל שם משתמש וסיסמה בכתובת), לא מוצגת, והסעיף נשאר בלי שורת הכתובת; רק הנדחית נרשמת כ-WARNING, עם הסיבה ובלי הערך. העוגן יציב בכוונה: כרטיס הטיפים שמתוכנן לעמוד הבית יקשר אליו.

  • feat (WebApp): בתחתית עמוד ההגדרות יש קישור קבוע ”עזרה ודיווח על תקלות“. הוא מוביל לחשבון הטלגרם @moominAmir ומוצג לכל משתמש. עד היום הקישור הזה הופיע בהגדרות רק למשתמשי פרימיום, בכרטיס פרטי החשבון.

  • change (WebApp): משתמש חדש כבר לא מקבל מודאל פתיחה, סיור מודרך ואשף ערכות — תהליך ה-Onboarding הוסר. עד היום משתמש חדש קיבל בכל עמוד שנבנה על base.html מודאל פתיחה שחסם קליקים עד שנסגר, ובעמוד הקבצים גם סיור מודרך מבוסס Driver.js ואחריו אשף לבחירת ערכת נושא. עמוד הבית כבר מציג מה המוצר עושה, ומשתמש חדש מקבל את DEFAULT_UI_THEME, ולכן שלושת הרכיבים הוסרו לגמרי ולא הוסתרו מאחורי דגל. איתם יצאו Driver.js, שנטען מ-CDN בכל עמוד שנבנה על base.html, הראוט POST /api/welcome/ack, הטריגרים ?tour= ו-?theme_wizard=, ועמוד התיעוד webapp/onboarding. השדות has_seen_welcome_modal ו-ui_prefs.onboarding כבר לא נכתבים ולא נקראים; אצל משתמשים קיימים הם נשארים במסד בלי שימוש. טאב שנטען לפני העדכון ושולח onboarding ל-/api/ui_prefs מקבל תשובה תקינה, ושום דבר לא נשמר (tests/test_welcome_and_shared.py). הסנכרון של ערכת הנושא בין טאבים ישב בתוך קוד האשף; הוא עבר לבלוק משלו ב-base.html, ומכוסה עכשיו בטסט דפדפן (tests/test_theme_cross_tab_sync_browser.py). הקישור /share/welcome למדריך המשתמש לא השתנה.

  • fix (docs): תפריט הצד מסמן את הסעיף שקוראים בו, ונגלל אליו רק כשהוא יוצא מהתצוגה — במקום להתרחק עם הגלילה של העמוד. עד היום sticky_navigation של הערכה גלל את התפריט באותו מרחק שהעמוד זז, בלי קשר לסעיפים, ובעמוד ארוך כמו שרת ה-MCP — חיבור Claude ל-CodeKeeper התפריט הגיע לפריטים של עמודים אחרים לגמרי. זה לא התחיל עם המעבר של האתר לכיוון מימין לשמאל (העדכון על כך באותו יום): אותה התנהגות נמדדה גם בבנייה שלפניו. עכשיו ההגדרה כבויה, ו-docs/_static/nav-follow.js מסמן בפס דק את הפריט של הסעיף שקוראים בו ומזיז את התפריט רק כשהפריט יוצא מהתצוגה, כך שיהיה באמצע, כמו תוכן העניינים הצף בתצוגת Markdown בוובאפ. בסוף העמוד קו הקריאה יורד, כדי שגם הסעיפים האחרונים יסומנו. בלי זה, ברוב העמודים הסעיף האחרון לא היה מסומן אף פעם (נמדד על האתר כולו ב-18.10.2026, בגודל המסך של טאבלט). פרטים: התפריט עוקב אחרי הסעיף שקוראים בו.

  • change (WebApp): עמוד הבית בעיצוב חדש — כרטיסים שמראים מה אפשר לעשות ב-CodeKeeper, והכפתורים לדשבורד ולקבצים בראש העמוד. הכרטיסים: קוד וקבצים, Markdown, פתקים, AI וסוכנים, התאמה אישית וגיבוי, ובוט טלגרם. משתמש מחובר רואה בראש העמוד את הברכה עם השם שלו ואת הכפתורים ”לדשבורד שלי“ ו“לקבצים שלי“. מי שלא התחבר רואה שם ”התחל עכשיו!“ עם התחברות ופתיחת הבוט. הצבעים באים מערכת הנושא, והקישור למדיניות הפרטיות נשאר בתחתית. הסטטיסטיקות ירדו מהעמוד, וגם הקוד שחישב אותן בכל כניסה: ה-route של / כבר לא קורא ל-fetch_external_uptime, והעמוד לא מושך את /api/public_stats ואת /api/uptime. שני ה-API עצמם נשארו. הקרדיט למפתח עבר מהמסך לנתונים המובנים: author ב-JSON-LD. לאייקונים של הכרטיסים נוסף גודל בשם feature_card ל-LANG_ICON_SIZES (אייקוני שפות התכנות), וטבלת הגדלים בעמוד ההוא נבדקת מעכשיו מול הקוד.

  • docs: אתר התיעוד בנוי כולו מימין לשמאל — התפריט בצד ימין, הכותרות המעורבות בו בסדר הנכון, והכפתורים בעברית. עד היום רק אזור התוכן הוצג מימין לשמאל, בכלל direction: rtl על .rst-content, והתפריט, שורת המיקום וכפתורי הקודם/הבא נשארו במבנה של sphinx_rtd_theme, משמאל לימין. בתפריט, כותרת כמו ”ביצועים והרחבה (Performance & Scaling)“ הוצגה עם החלקים והסוגריים במקומות הלא נכונים. עכשיו dir על התגית html נגזר מהשפה שהבנייה רצה בה (_set_text_direction ב-docs/conf.py ועותק של layout.html של הערכה ב-docs/_templates/), ו-custom.css מתרגם את הצדדים הקבועים של הערכה למאפיינים לוגיים, כך שהכול מתהפך יחד: התפריט, שורת המיקום, הקודם/הבא כולל החצים, הזחות הרשימות, כותרות הטבלאות והפס של תיבות ההערה. בלוקי הקוד נשארים משמאל לימין, והפס של בלוקי autodoc נשאר בשמאל, בכוונה. ”Previous“, ”Next“, ”View page source“ ו-”Search docs“ מתורגמים ב-docs/locales/he/LC_MESSAGES/sphinx.po. unicode-bidi: plaintext הוסר: הוא לא חל על אף טקסט, כי התכונה לא עוברת בירושה, ומדידה של מיקום הטקסט בכל העמודים עם השורה ובלעדיה לא מצאה הבדל. נמדד ב-Playwright ברוחב 1000 וברוחב 700, כולל פתיחה וסגירה של התפריט, הדפסה, והפלט של ”העתק תוכן הדף“, שלא השתנה. tests/test_docs_rtl_layer.py שומר על ההחלטות, וההסבר המלא ב-כיוון האתר (מימין לשמאל).

  • fix (WebApp): הפתק שיצרתם או נגעתם בו אחרון יושב מעל שאר הפתקים. עד היום פתק עלה לקדמת הערימה רק כשנפתח בו שרשור או כשהגעתם אליו מקישור. לכן פתק חדש נפתח מתחת לכל פתק כזה, ולחיצה על פתק או גרירה שלו לא העלו אותו. עכשיו פתק חדש נפתח מעל כולם, וכל נגיעה בפתק — בתוכן, בכפתור, בבועת שרשור או בתחילת גרירה — מעלה אותו, בלי לשנות את מה שהנגיעה עושה. בלוח, בתצוגת Markdown ובדפדפן הריפו. הסדר הוא שינוי תצוגה בלבד, ועוד לא נשמר. וההעלאה כבר אינה מעלה את ה-z-index בכל נגיעה: הערך העליון תלוי במספר הפתקים שנגעו בהם ולא במספר הנגיעות (_raiseToFront). מונה שהיה עולה בכל נגיעה היה מביא פתק אל מעל כפתור ההוספה בתוך כמה עשרות נגיעות. ראו פתקים דביקים (Sticky Notes).

  • docs (MCP): עמוד שרת ה-MCP פוצל לשלושה — השער נשאר באותו נתיב, ולצידו עמוד על קבצים ופתקים במסד ועמוד על קריאה, פרסור וחיפוש בתוכן. עד היום כל התיעוד של השרת ישב בעמוד אחד, של 442KB. עכשיו שרת ה-MCP — חיבור Claude ל-CodeKeeper מחזיק את התשתית, ובה הכלים, מודל הריצה, הקבועים והתקרות, האימות, גבולות הבקשה, הפריימר, ההעלאה וההורדה, ההפעלה, דפדפן הריפו, מדידת השימוש ופתרון התקלות; שרת ה-MCP — קבצים ופתקים במסד: גרסאות, עקביות ומחזור חיים מחזיק את מה שקורה לקובץ ולפתק במסד, ובו התיאור וגילו, content_sha256, כמה עריכות בגרסה אחת, קריאת פתק, היסטוריית פתקים, שרשורי תגובות וההתראה כשסוכן שומר קובץ; ו-שרת ה-MCP — קריאה, פרסור וחיפוש בתוכן מחזיק את הקריאה והחיפוש, ובהם ענף שלא במראה, איזה קובץ כלי התיעוד קורא ואיך הוא מוצא כותרת, הפערים של מפת ה-Markdown, מפת הסימבולים, טווח שורות, ספירת מופעים, החיפוש, קריאה לפי סעיף בקובץ שמור, ספירת שורות בעץ הריפו והקריאה הקבוצתית. הטקסט עבר מילה במילה, חוץ מהרשימה הזו: ‏(1) ההערה על שני החיפושים, שישבה מתחת לטבלת הכלים, היא עכשיו סעיף משלה — איך מחפשים קובץ ופתק — codekeeper_search_code ו-codekeeper_search_notes; ‏(2) שתי פסקאות ההקדמה של ענף שלא במראה, מול קובץ שלא קיים — מה המראה מחזיקה ומתי היא נמשכת — עברו לסוף רענון אוטומטי (autosync), ובמקומן יש שורה שמפנה לשם; והסעיף עצמו עלה ברמה, כי בעמוד החדש הוא כבר אינו תת-סעיף של דפדפן הריפו; ‏(3) הפסקה על path_outside_root ו-repo_not_mirrored (#3432) עברה ממדיניות הסודות אל איזה קובץ docs_get_section קורא, ובאיזה ריפו; ‏(4) שמונה הפניות שהיו נשברות — ”למעלה“, ”ראו את ההערה מתחת לטבלה“ ודומיהן — והפניות בשם לכותרות שקיבלו תווית הן עכשיו :ref:, גם ברשומות קודמות בעמוד הזה; ‏(5) לכל עמוד חדש יש כותרת, :summary: ושורת פתיחה שמפנה לשער, ול-:summary: של השער יש ניסוח חדש; ‏(6) קישורי מעבר בשער: פסקה בראש העמוד וסעיף לפני ”ראו גם“ — ראו ”העוגנים“ בהמשך; ‏(7) בפסקה ”מי כתב“ ב-שרשורי תגובות על פתקים — codekeeper_comment_note תוקן התיאור של שם הלקוח — ראו את העדכון הבא. נבדק בהשוואה של כל השורות: כל שורה במקור נמצאת באחד משלושת הקבצים, וכל שורה בהם מגיעה מהמקור או מהרשימה הזו. העוגנים: התוויות לא השתנו, ולכן כל :ref: ממשיך להגיע לסעיף שלו, בעמוד החדש — מה שהשתנה הוא העמוד שבכתובת: mcp-server.html#mcp-read-batch, למשל, הוא עכשיו mcp-server-retrieval.html#mcp-read-batch. כתובת ישנה כזו נפתחת בראש השער, כי העוגן כבר אינו בו. לכן יש בראש השער פסקה שמפנה לשני העמודים החדשים ול-סעיפים שעברו לעמודים אחרים, ובסעיף הזה, לפני ”ראו גם“, יש קישור לכל תווית שעברה. עברו ל-שרת ה-MCP — קבצים ופתקים במסד: גרסאות, עקביות ומחזור חיים: mcp-update-description, mcp-description-saved, mcp-description-age, mcp-content-sha256, mcp-note-content-sha256, mcp-multi-edit, mcp-expected-content-sha256, mcp-get-note, mcp-note-threads ו-mcp-push-notifications. עברו ל-שרת ה-MCP — קריאה, פרסור וחיפוש בתוכן: mcp-repo-read-misses, mcp-docs-path-policy, mcp-md-known-divergences, mcp-docs-section, mcp-outline, mcp-line-range, mcp-search-total, mcp-search-file-pattern, mcp-file-query, mcp-file-sections, mcp-file-sections-dialect, mcp-tree-stats ו-mcp-read-batch. כותרת בעברית בלי תווית מקבלת מ-Sphinx מספר רץ (id1, id2…), והוא זז כשסעיף שלפניה יוצא (document.set_id ב-docutils 0.21.2, עם auto_id_prefix של Sphinx 8.2.3; נמדד בבנייה של main ושל הענף) — ולכן קישור ישן מהצורה mcp-server.html#idN עלול להגיע עכשיו לכותרת אחרת. בשער זזו כך עשר כותרות, ולכל אחת יש עכשיו תווית, שהיא העוגן היציב שלה (בסוגריים — המספר שהיה לה ב-main): עריכה מהדפדפן (id15), האחסון (id17), הפעלה — צעד אחר צעד (id19), שלב 1 — שירות חדש (id20), שלב 4 — דפדפן הריפו (אדמין, אופציונלי) (id21), חיבור לקוחות (id22), דפדפן הריפו — איך זה עובד (id23), אבטחה — עקרונות (id44), פתרון תקלות (id45) ו-ראו גם (id46). תווית נוספה גם ל-מודל הריצה של הכלים (id3 נשאר בשער כמו שהוא) ול-היסטוריית פתקים, כדי שההפניות אליהן בשם יהיו :ref:. תתי-הכותרות בלי תווית שעברו לעמודים החדשים קיבלו שם מספר רץ חדש. וטסט אחד חזר לטענה המקורית שלו: אחרי הפיצול אף קובץ RST כבר אינו חוצה את עמוד ברירת המחדל של מפת הסימבולים, ולכן הטסט ב-tests/test_mcp_outline.py חזר לטענה שנכתבה ב-#3373 — שמסלול העימוד אינו נגיש ב-RST. העימוד עצמו נשאר בדוק, על פייתון סינתטי ועל קובץ CSS אמיתי, והטסטים שבודקים טקסט בעמוד קוראים עכשיו את הקובץ שבו הטקסט נמצא.

  • docs (MCP): שם הלקוח שליד תגובה של סוכן הוא ההצהרה של הלקוח, ולא זיהוי מאומת. עד היום שרשורי תגובות על פתקים — codekeeper_comment_note אמר ש“סוכן אינו יכול להציג את עצמו כסוכן אחר“, וזה לא נכון. השם הוא clientInfo.name שהלקוח מצהיר עליו בעצמו ב-initialize, והטוקן שנושא אותו בין הבקשות, בכותרת Mcp-Session-Id, אינו חתום. לכן לקוח — או סוכן שמחזיק טוקן אישי ופותח חיבור משלו — יכול להצהיר על שם של סוכן אחר. מה שנכון הוא שהשם אינו פרמטר של הכלי, כך שהמודל אינו כותב אותו בקריאה לכלי. התיקון הוא בתיעוד, ב-docstring של mcp_server/client_identity.py ובהערות בקוד שחזרו על הטענה. ההתנהגות לא השתנתה, והשם משמש לתצוגה בלבד, לא להרשאה. נבדק מול mcp 1.28.1 ו-posthog 7.45.3: לקוח שהצהיר Gemini נרשם כ-Gemini, וטוקן שנבנה ביד, בלי מפתח, מפוענח כרגיל.

2026-10-17

  • feat (WebApp): עמוד מדיניות פרטיות ציבורי ב-/privacy, עם קישור מתחתית עמוד הבית ועמוד ההתחברות. העמוד באנגלית, ולא דורש התחברות. הכתובת שלו היא הקישור למדיניות הפרטיות בפרויקט ה-Google Cloud של חיבור ה-Drive, בבוט ובוובאפ. כל משפט בו נבדק מול הקוד, והעובדות שהוא נשען עליהן מוצמדות בטסטים: ה-scope, שאין הורדה מ-Drive, ושהוא לא טוען להצפנה כל עוד הטוקנים יכולים להישמר בלי הצפנה. ראו עמוד מדיניות הפרטיות (/privacy). וגם: ב-משתני סביבה - רפרנס השורה של TOKEN_ENC_KEY אמרה שהוא של הבוט בלבד, אבל גם הוובאפ מצפין בו את הטוקנים של Drive. השורה תוקנה.

  • fix (WebApp): נוסחאות ב-Markdown מזוהות בתוך הפענוח — מחיר כמו $5 ואופרטור של מונגו נשארים טקסט, נוסחה מוצגת משמאל לימין, ובלוק $$ על כמה שורות, כמו מטריצה, מרונדר. עד עכשיו renderMathInElement של KaTeX רץ על ה-HTML המוכן בתצוגת המסמך ובתצוגה החיה, וזה יצר ארבע תקלות: (1) כל זוג $ בטקסט רגיל הפך לנוסחה — ”עולה $5 ובפרימיום $10“, או $substrCP ו-$substrBytes באותה פסקה, כמו במסמך שהומר מ-sticky_notes_extending.rst. (2) Markdown השחית את הנוסחה לפני ש-KaTeX ראה אותה: \\ של מטריצה הפך ל-\, והמטריצה הוצגה בשורה אחת. (3) בלוק $$ על כמה שורות לא רונדר בכלל, ושורה של = בתוכו הפכה אותו לכותרת. (4) בעמוד עברי חלקי הנוסחה סודרו מימין לשמאל, ו-E = mc^2 הוצג כ-²mc = E. עכשיו תוסף markdown-it אחד, webapp/static/js/md-math-plugin.js, מזהה נוסחאות בזמן הפענוח לפי הכללים של pandoc, ומעביר את התוכן ל-KaTeX כמו שנכתב. הוא משותף לתצוגת המסמך, לתצוגה החיה, לדפדפן הריפו ולכרטיסי התיעוד. מעבר לכללים של pandoc יש כללים משלנו: $ שצמוד מבחוץ לאות לטינית או לספרה אינו גבול של נוסחה (המחיר: $n$th אינו נוסחה); $ שאחריו עוד $ אינו סוגר; אות עברית מחוץ לסוגריים מסולסלים מבטלת נוסחה בתוך שורה (עברית בנוסחה נכתבת ב-\text{...}); וגרש הפוך לפני ה-$ הסוגר מבטל את הנוסחה, כך שקוד לא נבלע בתוכה. כל נוסחה עטופה ב-dir="ltr". הבאנדל md_preview.bundle.js נבנה מחדש: הוא חושף את window.katex במקום renderMathInElement. בנייה של הקוד הקודם, בלי שינוי, יצרה בדיוק את הקובץ שהיה בריפו, ולכן ההבדל בבאנדל הוא השינוי הזה בלבד. נוסחה שמפילה את KaTeX בחריגה שאינה שגיאת תחביר (קינון עמוק מאוד) מוצגת כמקור, במקום להפיל את כל המסמך. נוסחה בכותרת של בלוק ::: ובתוכן העניינים כבר לא מרונדרת, כי אלה לא עוברים בפענוח. הפירוט ב-מדריך סגנונות וארכיטקטורת Markdown, והבדיקות ב-tests/md-math-plugin.test.js.

  • fix (WebApp): הגיבוי האישי שומר את הגרסה שרשימת הקבצים מציגה, כל הקבצים נכנסים אליו, וכשל בשליפה מכשיל את הגיבוי במקום להעלות גיבוי חסר. ‏(1) כשל שקט: כשהשאילתה של הייצוא נכשלה, הוחזרה רשימה ריקה, וגיבוי בלי קבצים הועלה ל-Drive כהצלחה. קובץ גדול שהשליפה שלו נכשלה (get_large_file מחזיר None) נכתב לגיבוי בלי תוכן. עכשיו כשל בשליפה או בכתיבה ל-ZIP עולה לקורא: ההורדה מחזירה שגיאה, והגיבוי המתוזמן נרשם כנכשל. וכשאין מסד אמיתי (מצב NoOp: המסד נוטרל, או שהחיבור נכשל בעלייה), שתי השליפות זורקות ConnectionFailure (DatabaseManager._require_real_database) — עד כאן ההורדה ו“גבה עכשיו“ לדיסק קיבלו שם ZIP בלי קבצים כהצלחה. ‏(2) תקרת זיכרון: הצינור הישן מיין בסופו את המסמכים המלאים, עם הקוד. מיון כזה חוסם בזיכרון, ובאשכול Flex התקרה היא 32MB בלי allowDiskUse. נמדד ב-explain על האשכול: 20.9MB אצל המשתמש הראשי, ומעל התקרה הגיבוי היה נכשל, ובגלל (1) — חוזר ריק. עכשיו השליפה בשני שלבים: צינור שבוחר רק מזהה לכל קובץ ($top), ואחריו find לפי מזהים במנות, והקבצים נכתבים ל-ZIP אחד-אחד. בנתונים סינתטיים עם 40MiB קוד, שיא הזיכרון ירד מ-68.2MiB ל-40.6MiB. ‏(3) תקרת כמות: $limit: 10000 חתך בשקט משתמש עם יותר קבצים, ו-files_count דיווח את המספר הקטוע. התקרה הוסרה. ‏(4) איזו גרסה: בשתי גרסאות פעילות עם אותו version (נמצא בפרודקשן: קובץ אחד, חמש גרסאות) הגיבוי לקח את הראשונה שנשמרה, והרשימה בוובאפ מציגה את האחרונה. עכשיו שניהם קוראים את אותו כלל, LATEST_VERSION_SORT_BY במודול השורש file_versions.py. בקבצים גדולים עם שני מסמכים פעילים באותו שם (מצב שרק הקוד מונע, בלי אינדקס) נכתב לגיבוי מסמך אחד, האחרון שהוכנס, ולא שניים לאותו נתיב. ‏(5) N+1: קובץ גדול כבר לא נשלף בשאילתה משלו. וגם: תוכן שאינו מחרוזת מכשיל את הייצוא, כמו _to_json באותו קובץ, במקום להיכתב לגיבוי כ-str(). ובקוד: ההגנה מ-MagicMock (has_explicit_collection_attr), ה-except TypeError סביב allowDiskUse והנפילה ל-get_user_files הוסרו מקוד הייצור.

  • fix (WebApp): גיבוי מתוזמן שנכשל מנוסה שוב אחרי המתנה שגדלה, ואחרי RETRY_MAX_ATTEMPTS ניסיונות עובר למועד הרגיל — לא כל חמש דקות בלי סוף. כל כשל של גיבוי Drive או דיסק בוובאפ קבע ניסיון חוזר בעוד SCAN_INTERVAL_SECONDS, בלי מונה ובלי סוף, ולכן כשל שאינו חולף הפך לגיבוי מלא כל חמש דקות. עכשיו ההמתנה מוכפלת בכל ניסיון (_retry_delay_seconds), המונה נשמר בהעדפות (consecutive_failures) ומתאפס בהצלחה — גם כשהמועד השתנה בזמן הגיבוי — בהשהיה, ובכל כתיבה של התזמון על ידי המשתמש: הפעלה, שינוי, כיבוי וניתוק (user_schedule_values). אחרי הניסיון האחרון הגיבוי עובר למועד הרגיל ונשלח webapp_backup_retries_exhausted. כשל בכתיבת המועד שאחרי הגיבוי אינו נספר ככשל של הגיבוי: הוא נרשם, והתפיסה נשארת עד שהיא פגה. וגם: המועד הבא נכתב בסוף הגיבוי רק אם הסורק עדיין מחזיק בו (_finish_claim) — תזמון שהמשתמש שינה בזמן שגיבוי רץ כבר לא נדרס. כשל בכתיבת המועד של גיבוי הדיסק נרשם בלוג, ולא נבלע ב-pass.

  • fix (WebApp, Drive): גיבוי Drive שגוגל דחה את החיבור שלו נעצר, ומסך ההגדרות מבקש להתחבר מחדש — במקום ZIP מלא כל חמש דקות. הגיבוי המתוזמן של הוובאפ בנה ZIP של כל הקבצים, ורק אז ניסה להעלות. כשהחיבור מת, ההעלאה נכשלה ב-RefreshError, והסורק ניסה שוב בסריקה הבאה, בלי סוף: מ-12.10 נבנה גיבוי מלא כל 5 דקות ו-20 שניות בערך, ושאילתת הייצוא נרשמה ב-slow_queries_log בכל פעם. במסך ההגדרות נשאר ”מחובר“ בירוק. עכשיו check_connection מחדש את הטוקן מול גוגל לפני שנבנה משהו (בדיקת חיבור לפני גיבוי (check_connection)). כשגוגל עונה invalid_grant, נכתב auth_required_at, /api/drive/status מחזיר needs_reconnect, והתזמון מושהה עד שמתחברים מחדש — ואז הוא חוזר לפעולה. ”גבה עכשיו“ אומר ”נדרש להתחבר מחדש“ במקום ”הגיבוי נכשל“, ושורת drive_call_failed נושאת את קוד השגיאה של גוגל (oauth_error), כדי להבדיל בין חיבור שמת לבין תקלת הגדרות.

2026-10-16

  • change (WebApp): האייקון של כפתור המזהה בפתק הוחלף בתו טקסט. # במקום 🆔: אימוג’י נצבע בצבעים של עצמו ובלט מדי לכפתור משני, ותו טקסט מקבל את צבע הכפתור, כמו ✎ שבאותה שורה. ההעתקה, המקום של הכפתור וההסבר שמוצג עליו לא השתנו (העתקת המזהה).

  • feat (WebApp): כפתור 🆔 בפתק מעתיק את מזהה הפתק — מה שסוכן צריך כדי לקרוא אותו ב-MCP. הכפתור יושב בשורת השם, ליד החיפוש, בכל פתק — על קובץ, על לוח ועל קובץ בריפו, וגם כשהפתק צמוד למסך — ומעתיק בדיוק את 24 התווים ש-codekeeper_get_note מקבל. המזהה נקרא ברגע הלחיצה, ולא כשהכפתור נבנה. על פתק שעוד אין לו מזהה מהשרת שום דבר לא מועתק, והחיווי אומר ”הפתק עוד לא נשמר“. הוא בשורת השם ולא בשורת הפעולות כי שם הוא היה דוחף כפתורים אל מחוץ לכל פתק צר מ-308 פיקסלים — בפתק של 260 גם את המזעור, ולא רק את המחיקה (העתקת מזהה הפתק: בשורת השם, והמזהה נקרא ברגע הלחיצה).

  • change (WebApp): פתק חדש במסך רחב נפתח ב-494×380 במקום 260×200, באותו יחס; בטלפון הגודל לא השתנה. הגודל נבחר בעין, בגרירה של פתק אמיתי (503×373), והותאם ליחס של הגודל הקודם באותו שטח; כל שורת הכפתורים נכנסת בו. הגודל בא היום מקבועים ב-sticky-notes.js (NEW_NOTE_*), ולא ממספרים מוקלדים ב-createNote. פתקים קיימים לא משתנים, וגם פתק בלי גודל שמור נפתח בגודל שהיה לו (NOTE_FALLBACK_*, שנקרא עד היום NOTE_DEFAULT_*). פתק שסוכן יוצר דרך ה-MCP עדיין נוצר ב-260×200 (גודל של פתק חדש, והגיבוי של פתק בלי גודל).

  • fix (WebApp): שתי העתקות שנכשלו ברצף כבר לא משאירות את הודעת הכשל על כפתור ההעתקה לתמיד. _flashCopyResult לכד בכל לחיצה את ה-title של אותו רגע, כדי לשחזר אותו כשהחיווי יורד — ואחרי כשל זו הייתה הודעת הכשל עצמה. היום ה-title נלכד פעם אחת לכל חיווי, ולחיצה בזמן חיווי מבטלת את הטיימר הקודם. נמדד בכרומיום לפני התיקון ואחריו, על ⧉ עם קליפבורד חסום.

  • feat (MCP): מפת כותרות של הרמות העליונות בלבד — max_depth בשני הכלים שבונים אותה. בקובץ שכל פרק בו חוזר על אותן תת-כותרות — כמו RECURRING-PATTERNS.md ב-amir-bug-patterns, שבו ”איך זה נראה“, ”כלל לזיהוי“ ו“ראה גם“ יושבות תחת כל דפוס — המפה המלאה היא בעיקר חזרות, ומי שרוצה לבחור פרק נאלץ לעבור על כולה. עכשיו max_depth=2 מחזיר את השורש ואת הפרקים בלבד, והסוכן בוחר פרק וקורא אותו בשמו. הפרמטר חל על המפה בלבד — codekeeper_docs_get_section בלי section, codekeeper_get_file עם toc=true, והמפה שבתשובת section_not_found של שניהם — ולא על ההצעות, על המועמדים של ambiguous_section או על ההתאמה: כותרת שמבקשים בשמה נמצאת בכל עומק. העומק נספר לאורך ה-breadcrumb ולא לפי level, כדי ש-### שבא מיד אחרי # — ילד ישיר — לא ייעלם עם כל מה שתחתיו. ההגבלה לבדה משאירה את toc_truncated כבוי — הוא נדלק רק כשהמפה המוגבלת עצמה נחתכת — וכותרת בגבול העומק שהוסתרו תחתיה כותרות נושאת hidden_subsections עם מספרן; בתשובת המפה (mode: toc) section_count נשאר מספר הכותרות כולן. max_depth חוזר בכל תשובה שנושאת מפה כערך שנאכף: StrictInt, ומספר מחוץ לטווח נצמד (MAX_DEPTH_MIN ו-MAX_DEPTH_MAX ב-mcp_server/docs_handlers.py) ואינו נדחה. ב-codekeeper_get_file, max_depth בלי toc ובלי section נדחה ב-max_depth_without_toc, כמו max_chars_without_section. פריטי codekeeper_read_batch אינם מקבלים את הפרמטר. בלי הפרמטר שום תשובה אינה משתנה: אפס-דיף על כל עמודי התיעוד (scripts/docs_section_zero_diff.py, הקוד שלפני ואחרי על אותו קורפוס), וכל הטסטים הקיימים של המפה עוברים בלי שינוי. ראו איך docs_get_section מוצא כותרת ו-קריאה לפי סעיף בקובץ Markdown שמור (toc ו-section).

  • feat (MCP): הורדת קובץ שמור ישר לדיסק של הסוכן, בלי לעבור דרך המודל. סוכן שהיה צריך להריץ בקונטיינר סקריפט ששמור ב-CodeKeeper קרא אותו ב-codekeeper_get_file והעתיק את כל התוכן לכלי הכתיבה שלו — פעמיים אותם בתים, ומקום לטעות העתקה. עכשיו GET /api/agent/download מוריד את הבתים בקריאת curl אחת, עם ה-PAT שכבר בסביבה (טוקן read מספיק), ישר לקובץ: curl -fsS -H "Authorization: Bearer $CODEKEEPER_PAT" -o script.py '.../api/agent/download?file_id=<id>' && sha256sum script.py. הגוף הוא code.encode("utf-8") ותו לא — BOM, ‏CRLF וירידת שורה בסוף נשארים — ו-X-Content-SHA256 הוא file.content_sha256 של אותה גרסה, כלומר ה-hash ש-sha256sum מדפיס. -f חלק מהפקודה בכוונה: בלעדיו גוף ה-404 נכתב לקובץ היעד ו-curl יוצא ב-0. הזיהוי הוא של codekeeper_get_file ודרך אותה שליפה (file_id, או file_name ו-version — לפי שם רק מקודד); מזהה של משתמש אחר, מזהה שאינו קיים ומזהה פגום — 404 אחד; פרמטר לא מוכר, כפול או ריק, ו-version לצד file_id — 400 עם קוד משלו, ולא התעלמות. אותה מכסת קצב של הכלים, כל סירוב של הראוט עם Connection: close, וכל תשובה שהוא בונה עם Cache-Control: no-store. הפקודה בתיאור file_id ובתיאור codekeeper_list_versions, ובתיאור codekeeper_get_file הפניה אליה; ה-host מ-MCP_SERVER_URL נבדק עכשיו פעם אחת לפקודות ההעלאה וההורדה יחד (mcp_server/public_url.py), וכתובת שנדחתה משאירה WARNING אחד; ובשתי הפקודות הכתובת מצוטטת ל-shell (_shell_word, מעל shlex.quote), כך ש-$(...), backticks או " בנתיב שהוגדר נשארים חלק מהכתובת ואינם מריצים דבר אצל הסוכן — עד כאן פקודת ההעלאה הכניסה את הכתובת בלי ציטוט. קבצים מהמראות — בשינוי נפרד. ראו הורדת קובץ לדיסק בלי לעבור דרך המודל.

2026-10-14

  • feat (WebApp): שרשורי תגובות על פתקים בוובאפ — בועות מעל הפתק וחלונית שרשור, בלוח, בתצוגת Markdown ובדפדפן הריפו. מעל כל פתק יש בועה לכל שרשור: הגוון לפי המספר שלו, כמה תגובות יש בו או ✓ כשנפתר, ונקודה אדומה על שרשור פתוח שהתגובה האחרונה בו היא של סוכן. לחיצה על בועה פותחת חלונית עם התגובות — מי כתב, על מה הסוכן עבד ולפני כמה זמן — ובה עונים (”שליחה“), סוגרים (“✓ נפתר“, והטקסט שבתיבה נשמר כמשפט סיכום באותה פעולה), עונים בלי לפתוח מחדש שרשור שנפתר (”שליחה בלי פתיחה“), ופותחים מחדש. שרשור חדש נפתח ב-💬 שבשורת הפעולות, ונשמר רק עם התגובה הראשונה. בפתק צר הבועות העודפות מתקבצות ב-”+N“, ובראש המסך הבועות עוברות לתחתית והחלונית נפתחת כלפי מעלה. בשרת נוספו ראוטים תחת /api/sticky-notes/note/<note_id>/threads: user_id מה-session בלבד, הבעלות על הפתק נבדקת לפני כל פעולה (פתק של משתמש אחר — 404, ושום דבר לא נכתב), והתשובה נבנית ממה שהמסד החזיר. רשימות הפתקים מחזירות לכל פתק את תקצירי השרשורים שלו, בשאילתה אחת לכל הרשימה. שרשורי תגובות על פתקים, שרשורי תגובות: השרת והממשק בוובאפ.

  • feat (WebApp): התראת Push כשסוכן מגיב על פתק, ולחיצה עליה פותחת את השרשור. שולח הפוש בוובאפ מכיר עכשיו את האירוע note_comment שה-MCP רושם: הכותרת אומרת מי הגיב ועל איזה פתק, והגוף הוא תחילת התגובה — אחרי ניקוי סודות, וקיצור בתווים (_PUSH_COMMENT_PREVIEW_MAX_CHARS). ההיטלה של השולח נגזרת מהשדות שכל סוג אירוע מצהיר עליהם (_EVENT_KINDS ב-webapp/push_api.py): רשימה שנכתבה ביד הייתה מביאה לבונה החדש אירוע בלי המזהים שלו, והאירוע היה נסגר בשקט כ-incomplete_event. ה-Service Worker (2.2.0) מזהה התראת תגובה לפי type: הלחיצה פותחת /note/<id>?thread=<id>, והקישור הקבוע מעביר את thread הלאה אחרי בדיקת צורה. הלחיצה אינה שולחת אישור תזכורת — התראת תגובה נושאת note_id כדי לפתוח את הפתק, ובלי הבידול הלחיצה עליה הייתה סוגרת תזכורת פעילה של אותו פתק. מכשיר שעוד מריץ את ה-SW הקודם ממשיך לאשר עד שהדפדפן מעדכן אותו (עובדי Push).

  • change (WebApp): מחיקת פתק מוחקת גם את השרשורים שלו — ורק אחרי שהפתק עצמו נמחק. delete_note קורא ל-note_threads.delete_note_threads רק אחרי ש-deleted_count == 1, כך שמחיקה שנכשלה (פתק של משתמש אחר, מזהה שכבר נמחק) אינה נוגעת בשרשורים של פתק שנשאר. כשל מסד (PyMongoError) במחיקת השרשורים נרשם בלוג ואינו מכשיל את הבקשה — הפתק כבר נמחק, ושרשור יתום אינו מוצג בשום מקום.

  • change (WebApp): זמן יחסי ממקור אחד — ”לפני שעה“ ולא ”לפני 1 שעות“, וברשימת הקבצים האחרונים גם שבועות, חודשים ושנים. utils/relative-time.js מחליף את שני העותקים שהיו בצד הלקוח: formatDate ב-base.html (רשימת הקבצים האחרונים) ו-formatRelativeDate ב-repo-history.js (היסטוריית הקומיטים בדפדפן הריפו). שניהם אמרו ”לפני 1 שעות“, ו-formatDate גם נעצר בימים (”לפני 400 ימים“). עכשיו: ”עכשיו“, ”לפני 20 דק׳“, ”לפני שעה“, ”אתמול“, ”לפני יומיים“, ”לפני שבוע“, ”לפני חודש“ — אותו טקסט שמופיע בחלונית השרשורים. המילים כתובות במודול, ולא נלקחות מ-``Intl.RelativeTimeFormat``: הניסוח שם הוא נתוני השפה של הדפדפן, והם משתנים בין גרסאות — ב-CLDR 48 (נוד 24) שעה אחת היא ”לפני שע׳ (1)“ ויום אחד ”לפני יום אחד (1)“. repo-history.js נטען עכשיו עם ?v=, כמו שאר הסקריפטים בעמוד.

2026-10-13

  • feat (MCP): שרשורי תגובות על פתקים — סוכן מגיב על פתק, עונה לסוכן אחר ומסמן שרשור כנפתר, בלי לגעת בגוף הפתק. כלי הכתיבה החדש codekeeper_comment_note פותח שרשור על פתק, עונה בשרשור קיים (thread_id) או סוגר אותו (resolve, עם משפט סיכום אופציונלי). תשובה על שרשור שנפתר פותחת אותו מחדש באותה כתיבה, ו-reopen=false עונה ומשאיר אותו נפתר. working_on — המשימה שהסוכן עובד עליה ברגע הקריאה — חובה בכל קריאה לכלי, גם בסגירה בלי תגובה, וסוג הסוכן (CC, Claude, Gemini) נלקח מהחיבור ולא ממה שהסוכן שולח. ההרשאה היא השער של codekeeper_get_note, והוא נבדק לפני כל כתיבה: פתק של משתמש אחר, ופתק ריפו למי שאינו אדמין, עונים not_found. codekeeper_get_note מחזיר אחרי הפתק את השרשורים — פתוחים עם התגובות האחרונות, נפתרים כשורה מקופלת — ו-part="threads" או thread_id קוראים אותם במלואם, בתוך תקרת התשובה של השרת. open_threads נוסף לשורה הרזה של codekeeper_list_notes ו-codekeeper_list_board_notes, ובפריימר יש שורת מצב שנייה עם הפתקים שמחכה בהם תגובה לסוכן. הכתיבות האטומיות, התקרות והבדיקות של גוף התגובה ושל working_on יושבות במודול אחד, note_threads.py, שגם הוובאפ ישתמש בו; הממשק בוובאפ, שולח הפוש לסוג note_comment ומחיקת השרשורים יחד עם הפתק — בעדכון הבא. ראו שרשורי תגובות על פתקים — codekeeper_comment_note ו-שרשורי תגובות על פתקים.

  • change (MCP): תקרת בלוק ההוראות של השרת עלתה ל-4,096 תווים, לפי ה-changelog של Claude Code. CLIENT_INSTRUCTIONS_MAX_CHARS היה 2,048, לפי עמוד ה-MCP בתיעוד של Claude Code. גרסה 2.1.296 של Claude Code (9.10.2026) העלתה את התקרה של ה-instructions ושל תיאורי הכלים ל-4,096 — והעמוד ההוא עוד אומר 2,048. הקבוע עוקב עכשיו אחרי ה-changelog, וכך נכנסה לבלוק שורת השרשורים בלי לקצץ ניסוחים אחרים. לקוח ישן מ-2.1.296 עדיין חותך ב-2,048, ולכן החלק האחרון בבלוק הוא כלי הריפו של האדמין. tests/test_mcp_instructions.py גוזר מהקבוע את מספר הריפואים שבבדיקת החריגה, במקום מספר קבוע שהתאים רק לתקרה הישנה. ראו שרת ה-MCP — חיבור Claude ל-CodeKeeper.

  • fix (WebApp): קוד בתוך בלוק קוד עברי מוצג משמאל לימין — בתצוגת ה-Markdown, בתצוגה החיה ובדפדפן הריפו. עד היום בלוק קוד שהתוכן שלו עברי (בלי שם שפה, או markdown ו-text) היה מיושר לימין כולו, וכשבתוכו יש דוגמה עם גדרות משלה, הכיוון חל גם עליה: שורת הגדר ```python הוצגה הפוכה, עם הגרשיים אחרי שם השפה, והשורה המוזחת התחילה משמאל לשורה שמעליה. עכשיו קטע שמתחיל בגדר פנימית ונגמר בגדר הסוגרת שלה, כולל שתי שורות הגדר, מוצג משמאל לימין, מיושר לשמאל, עם ההזחה שלו וגלילה אופקית משלו. כל שאר השורות בבלוק נשארות מימין, ובלוק עברי בלי גדר פנימית לא משתנה בכלל. הכיוון נקבע לפי סוג התוכן ולא לפי האותיות: כלל לפי האות הראשונה בכל שורה הקפיץ שמאלה פריטי רשימה עבריים שמתחילים במזהה לועזי (נבדק ונפסל ב-Markdown-Docs, שממנו התיקון הועבר). הגדרות מזוהות לפי CommonMark 0.31.2 (fenceOpening ו-fenceEnd ב-webapp/static/js/utils/rtl-code.js): גדר נסגרת רק בשורה שכולה אותו תו, באורך שווה או ארוך יותר, ולכן דוגמה של ארבעה גרשיים לא נסגרת בשלושה שבתוכה. העטיפה (wrapInnerFences) רצה אחרי ההדגשה, כי ההדגשה בונה את הבלוק מחדש, והיא גוזרת את הקטע מתוך ה-HTML שכבר נצבע, בלי לצבוע מחדש. בדרך: כפתור ההעתקה של בלוק קוד ב-md_preview.html מעתיק textContent ולא innerText. innerText מוסיף ירידת שורה בגבול של כל אלמנט בלוק, ובבלוק כזה הוא היה מעתיק שורה ריקה עודפת לפני הקטע ואחריו. השומרים: tests/rtl-code-inner-fences.test.js משווה את זיהוי הגדרות ל-markdown-it עצמו על מסמכים אקראיים, כך שסטייה מהפרסר מפילה את ה-CI, ו-tests/test_rtl_inner_fences_browser.py מודד את הציור בכרומיום בשלושת המשטחים. הפתקים, שיש להם רנדרר משלהם, יקבלו את התיקון בנפרד.

2026-10-12

  • fix (WebApp): קוד בשורה בתוך מודגש, נטוי, קו חוצה, מרקר וקישור בפתק מוצג כקוד, ולא כגרשיים בתוך העיצוב. עד היום **מילים עם `קוד` בתוך הדגשה** הוצג בפתק כמודגש שבתוכו גרשיים, בזמן שתצוגת המסמך המלאה מציגה בתוכו קוד. המארקדאון בשורה נקרא ברג’קס אחד, MD_INLINE_RE, שבחר בכל נקודה את מה שמתחיל ראשון — וה-** מתחיל לפני הגרש. ב-markdown-it הסדר הפוך: קטע קוד נצרך כיחידה אחת עוד לפני שההדגשות מזווגות. עכשיו _parseInline ב-webapp/static/js/sticky-notes.js קורא קוד בשורה בכללים של lib/rules_inline/backticks.mjs (markdown-it 14.1.0): רצף גרשיים נסגר רק ברצף הבא באותו אורך, קטע קוד קודם לכל מפריד — גם ל-] של תווית קישור — ותוכן של עיצוב נבנה כטקסט וקוד. מאותו שורש תוקנו גם כוכבית או סימן שווה בתוך קוד שפירקו את העיצוב סביבם (**a `*` b**), קוד שממשיך מעבר לסוגר של העיצוב, וקוד בתווית של קישור — גם של קישור שאינו http ומוצג כמו שהוקלד. מה שמשתנה במקרי קצה: גרשיים שלא נסגרו באותו אורך הוצגו לפעמים כקוד (a ``b` c), ועכשיו הם טקסט, כמו במסמך; ופתק שזה המארקדאון היחיד בו נשאר תיבת עריכה. בשורה בלי גרש הפלט זהה לקוד הקודם, וגם ההחלטה אם התצוגה נפתחת — נבדק על כל המחרוזות הקצרות, והפירוט בעמוד המפתחים. מה לא השתנה: עיצוב בתוך עיצוב. ==**בדיקה**== עדיין מציג את הכוכביות בתוך המרקר, כי זה עניין של זיווג ההדגשות — השלב השני ב-markdown-it — והוא נושא נפרד. השומרים: tests/sticky-notes-target.test.js מריץ את markdown-it עצמו, עם תוסף המרקר ועם האפשרויות שנקראות מ-md_preview.html, ומשווה HTML מלא על אוסף קלטים ואת קטעי הקוד בכל השורות הקצרות, כך ששדרוג שמשנה את כלל הגרשיים מפיל את ה-CI. בדיקת זמן מוודאת שהסריקה לינארית בשורה באורך תקרת הפתק — על שורה של הרבה [ שלא נסגרים גם הרג’קס הקודם היה ריבועי. ראו קוד בשורה: יחידה אחת, שקודמת לכל מפריד ו-פתקים דביקים (Sticky Notes).

  • fix (WebApp): הייצוא ל-HTML מעוצב מציג כתיבות את כל סוגי התיבות שהוובאפ מציג, וגם בלוקים מתקפלים (details), ולא משחית יותר בלוקי קוד שמדגימים את התחביר. עד היום preprocess_markdown ב-services/styled_export_service.py הכיר רק את note, info, warning, important, danger, success ו-tip, ולכן question, example, quote, experimental, deprecated, todo, abstract ו-::: details יצאו בייצוא כטקסט גולמי עם :::. ביטוי רגולרי רץ על הטקסט הגולמי לפני ש-Python-Markdown קרא אותו, ומכאן עוד כמה תקלות: דוגמה של ::: note בתוך בלוק קוד הפכה ל-<div class="alert ..."> בתוך הקוד (נמצא בשני מסמכים בריפו), תיבה ריקה בלעה את כל מה שאחריה עד ה-::: הבא, קוד וטבלה בתוך תיבה יצאו שבורים, כותרת שנכתבה אחרי הסוג נמחקה בלי סימן, ו-::: NOTE, :::: ושורת סגירה עם רווח בסוף לא זוהו. עכשיו המכולות מטופלות במעבד בלוקים של Python-Markdown (_ContainerBlockProcessor), באותה צורה של התוסף המובנה admonition: הוא רץ אחרי ש-fenced_code הוציא את בלוקי הקוד, ותוכן התיבה עובר דרך אותו פרסר כמו שאר המסמך. כללי הפתיחה והסגירה הם של markdown-it-container 4.0.0 שבוובאפ, ולכן קינון נעשה כמו שם — גדר ארוכה יותר בחוץ (:::: סביב :::) — ועד MAX_CONTAINER_NESTING רמות, כמו maxNesting של markdown-it; ליד תקרת הרקורסיה המכולה נשארת טקסט, כמו הציטוט של Python-Markdown. לכל תיבה יש שורת כותרת, כמו בוובאפ — מה שנכתב אחרי הסוג, או התווית של הסוג מ-ADMONITION_TYPES — ו-::: details הופך ל-<details> ו-<summary>. הצבעים הולכים אחרי הקבוצות של הוובאפ: לקבוצה האפורה (quote, deprecated, abstract) נוסף alert-neutral, ו-question מקבל את הצבע של important. בדרך: details ו-summary נכנסו לרשימה הלבנה של bleach, ולכן <details> שנכתב כ-HTML גולמי במסמך מתקפל עכשיו גם בייצוא (עד היום התגיות נמחקו והתוכן נפרס), עם class ו-id בלבד. השומר: tests/test_styled_export_containers_parity.py משווה את הסוגים והתוויות של הייצוא ל-admonition-icons.js, לרישום ב-md_preview.html ולרישום ב-live-preview.js, כך שסוג שנוסף בוובאפ ולא בייצוא מפיל את ה-CI. מה נמדד ב-12.10.2026 (Python 3.13, Markdown 3.9): על 40 מקרי קצה, מול markdown-it 14.1.0 שבבאנדל, המבנה זהה ב-37 — השונים הם תיבה בפריט רשימה עם הזחה של שני רווחים (Python-Markdown דורש ארבעה, לכל תוכן ברשימה), HTML גולמי בתוך תיבה (הייצוא מנקה אותו כמו בכל מקום), ו-::: בתוך בלוק קוד שבתוך תיבה (כאן הייצוא נכון יותר). על 167 קובצי ה-md בריפו: 164 יצאו זהים, ושלושה השתנו — שני בלוקי הקוד שכבר לא נהרסים, ו-<details> גולמי אחד. 8,000 שורות ::: שלא נסגרו: 1.61 שניות במקום 3.29, ו-5,000 תיבות: 1.58 במקום 3.12. קישורי שיתוף שכבר נוצרו לא משתנים — ה-HTML שלהם נשמר ביצירה. תחבירי !!! ו-??? של תצוגת ה-Markdown עדיין לא נתמכים בייצוא.

  • fix (בוט + MCP): מסלולים שכותבים קוראים את הקובץ מהמסד ולא מהקאש — עריכת הערה בבוט כבר לא מחזירה קוד ישן שנערך בוובאפ. עריכת הערה קראה את הקובץ דרך get_latest_version, שעטופה ב-@cached, וכתבה ממנה לגרסה החדשה את הקוד, השפה והתגיות. עריכה בוובאפ שמכניסה גרסה חדשה אינה מבטלת את הקאש הזה, ולכן עריכה בוובאפ ואחריה עריכת הערה בבוט, בתוך חלון הקאש, יצרו גרסה חדשה עם הקוד הישן. אותה קריאה ישבה בעוד חמישה מקומות שכותבים: השכפול, שהעתיק את התוכן מהקאש או מ-files_cache (רשימת התצוגה של הבוט, שאין לה תוקף בכלל); ”השם תפוס“ ב-Repository.rename_file; המונה ”עודכנו / חדשים“ בייבוא ZIP מ-GitHub; רשימת הקבצים שנמחקים ב-purge של שחזור גיבוי (get_user_files, גם היא מקוּשה); ו-codekeeper_create_note, שקשר פתק לשם ולמזהה שבקאש. עכשיו כולם קוראים דרך דלת טרייה: FilesFacade.get_latest_version_fresh ו-FilesFacade.get_user_files_fresh (חדשות), Repository._fetch_latest_version ו-Repository._fetch_user_files, ו-_latest_fresh ב-MCP — שכבר לא נופל לגטר המקוּש כשלמנהל המסד אין דלת טרייה, אלא נכשל בקול. שכפול מהרשימה מזהה דרכה את הקובץ בלבד, וקובץ שכבר אינו במסד לא נבנה ממנה מחדש. tests/test_writers_do_not_read_through_cache.py סורק את קוד הייצור ונכשל על פונקציה שקוראת דרך גטר מעוטר ב-@cached — גם כשהשם מגיע כמחרוזת, כמו _call_files_api("get_latest_version", ...) — או משתמשת בתוכן של רשומה מ-files_cache, לפני כתיבה שהשומר מכיר (שם מתוך WRITE_CALLS). כתיבה אחרת, כמו toggle_favorite ב-bot_handlers.favorite_command, אינה נבדקת. tests/test_bot_writers_read_fresh_state.py מחמם את הקאש, כותב גרסה חדשה כמו שהוובאפ כותב, ובודק מה נכתב. ובסבב הריוויו: קריאה שנכשלה כבר אינה ”אין קובץ“. ל-Repository._fetch_latest_version ול-Repository._fetch_user_files נוסף raise_on_error. בברירת המחדל הן מחזירות None או [] גם כשהשאילתה נכשלה, כמו עד היום, וכך נשארים הגטרים המקוּשים ושאר הקוראים; FilesFacade מבקש raise_on_error=True בשתי הדלתות הטרייות, ולכן כשל של המסד עולה ממנו כחריגה. עריכת הערה ושכפול שקריאה שלהם נכשלה עונים בשגיאה ולא כותבים; Repository.rename_file מסרב לשנות שם כשבדיקת ”השם תפוס“ נכשלה; שחזור מלא מגיבוי (purge=True) לא מתחיל כשרשימת הקבצים למחיקה לא נקראה; וייבוא ZIP מ-GitHub נעצר עם ”❌ קריאה מהמסד נכשלה“ במקום לדווח ”✅ ייבוא הושלם“, ומבין החריגות בקובץ בודד רק כשל בקריאה מהדיסק עוד נספר בו כדילוג. מסך השחזור מגיבוי בבוט מציג ❌ כשלא שוחזר אף קובץ ויש שגיאות, במקום ”✅ שוחזרו 0“. _latest_fresh ב-MCP נשאר בברירת המחדל, ולכן שם קריאה שנכשלה עדיין נקראת כקובץ שאינו קיים — פרטים ב-docstring שלו.

  • change (WebApp): גודל הטקסט בפתקים עלה — ”רגיל“ הוא 18px, ”גדול“ 19px ו“גדול מאוד“ 20px, בלוחות ובעמוד ההגדרות. עד היום בלוח היו רגיל 14px, גדול 16px וגדול מאוד 18px, ובעמוד ההגדרות — שחל על דפדפן הריפו ועל קבצי Markdown — רגיל 14px, בינוני 15px וגדול 16px. עכשיו שני הבוררים מציעים אותן שלוש אפשרויות באותם גדלים: ”רגיל“ הוא הגודל שהיה ”גדול מאוד“ בלוח, ו“בינוני“ יצא. כל בחירה ששמורה מלפני השינוי חוזרת ל“רגיל“, ולכן לוח שהיה על ”גדול מאוד“ נראה בדיוק כמו קודם, והבורר שלו מציג ”רגיל“. אין כאן מיגרציה ואין מחיקה: ההגדלות קיבלו שמות חדשים (large, xlarge), והשמות הישנים — lg ו-xl בלוח, mid ו-lg בעמוד ההגדרות — אינם מוכרים יותר, כך שערך ישן עובר במסלול של ערך פגום. בלוח הוא אינו מוחל ואינו מוצב בבורר. בשרת _decode_note_font_size מחזירה עליו None: שדה ישן במסד נופל לברירת המחדל, cookie ישן במצב ”רק במכשיר הזה“ נופל לבחירה המשותפת, ושמירה של שם ישן — למשל מעמוד הגדרות שנשאר פתוח מלפני הפריסה — נענית 400. בדרך: ברירת המחדל של --sticky-note-font ישבה כ-fallback בתוך ה-var() של תיבת העריכה ושל התצוגה, כלומר אותו מספר פעמיים, ועכשיו היא מוצהרת פעם אחת, על :root ב-sticky-notes.css. STICKY_NOTE_FONT_MENUS נשאר עם רשימה לכל בורר, ושתיהן זהות היום. ראו עקרונות להוספת פיצ’ר לסטיקי-נוטס ו-פתקים דביקים (Sticky Notes).

  • tests: טסט הלינאריות של בלוקי ה-style בסורק ה-CSS משווה זמן לזמן, ולא לתקרה בשניות. test_many_style_blocks_with_an_unterminated_region_stay_linear ב-tests/test_mcp_outline.py נכשל ב-11.10 ב-CI על קוד תקין — 2.41 ו-2.57 שניות מול תקרה של 2.0 — ועבר בהרצה חוזרת על אותו קומיט. התקרה כוילה בלי coverage, והטסט רץ גם במסלול של unit-tests שמודד branch coverage (CI/CD Guide): שם הסריקה איטית פי ארבעה בערך, והזמן משתנה עם המחשב (ב-main נמדדו 0.75–1.82 שניות). עכשיו הטסט מריץ את הסריקה על רבע מהקלט ועל כולו, ובודק שהזמן גדל פחות מ-_STYLE_BLOCKS_GROWTH_LIMIT. מחשב איטי ו-coverage מאטים את שתי המדידות באותה מידה, ולכן היחס לא זז. זמן המעבד של החוט (time.thread_time) לא סופר המתנה למעבד או לחוט אחר, ושלושה סבבים לסירוגין, עם הזמן הקצר ביותר לכל גודל, מנטרלים האטה רגעית. נמדד ב-12.10.2026, על Python 3.11 ו-3.12: בקוד של היום הזמן גדל פי 3.4–4.9, גם בעומס, וכשהחיפוש מתעלם מ-stop פי 12.3–17.0. על הקוד הזה הטסט נכשל בשלושת המקרים, והוא היחיד שנכשל מבין הטסטים שנוגעים במפת הסימבולים. המחיר: הטסט ארוך יותר — אצלי כ-10 שניות לשלושת המקרים עם coverage במקום 2.5, וכ-2.6 בלי coverage במקום 0.7.

2026-10-11

  • feat (WebApp): ערכה מיובאת יכולה לקבוע לעצמה את צבע הטקסט בכפתורי primary. בערכה מיובאת או משותפת הטקסט של כפתור primary נצבע ב---primary: כפתור שהוא קישור דרך [data-theme="custom"] a שב-dark-mode.css (ובריחוף ב---primary-dark), ”ערוך“ ו“העתק קוד“ דרך .file-primary-action, ומצבי הפוקוס והלחיצה דרך primary-btn-states-custom-type. הרקע, לעומת זאת, הוא --btn-primary-bg, שנגזר ממפתח VS Code אחר. ב-Everforest Dark יצא #7fbbb3 על #a7c080, והטקסט נבלע בלשונית הנבחרת בעמוד הקבצים, ב“ערוך“ וב“העתק קוד“, ובכפתורים בעמוד ההגדרות. נמדד ב-11.10.2026 בכרומיום מול הוובאפ האמיתי, בערכה שיובאה דרך /api/themes/import: ניגודיות 1.09 במצב רגיל, 1.2 עד 1.82 בריחוף, ו-1.07 עד 1.09 בפוקוס. --btn-primary-text-override נכנס לרשימה הלבנה, בלי ערך ברירת מחדל בשום מקום, ונקרא בכל אחד מהכללים האלה עם fallback לערך שהוא צבע עד היום. לקישורים נוספו שני כללים עם הבוררים של כללי הקישורים ו-:where(.btn-primary), כדי שיחולו בדיוק במקום שבו כללי הקישורים צובעים — ולא עם [data-theme-type="custom"], כי סנכרון הערכה בין טאבים (initThemeCrossTabSync) משאיר אותו כשטאב אחר עובר לערכה מובנית, ונמדד שכלל כזה היה משנה בה, גם בערכה שלא הצהירה על הטוקן, את הטקסט של כפתורי primary שהם קישורים בעמוד הקבצים ובעמוד ההגדרות (מ-#1a365d ל-#3182ce ב-Ocean). אחרי: Everforest שמצהירה #232a2e מקבלת, בדגימת פיקסל, בכל כפתור שהווו חל עליו 7.28 במצב רגיל, לפחות 4.8 בריחוף, ולפחות 5.17 בפוקוס ובכפתור מושבת; #2d353b, ה-button.foreground של הערכה, נפל ל-4.17 בריחוף של קישור, בגלל ה-opacity: 0.9 של כלל הריחוף. ערכה מיובאת שאינה מצהירה, ערכה משותפת שאינה מצהירה, התצוגה המקדימה של Ocean ו-Dracula — זהות לקוד שלפני בכל כפתור ובכל מצב, ובכל קישור בשלושת העמודים. ראו הטקסט בכפתורי primary.

  • feat (WebApp): בחיפוש בתיעוד, כל עדכון ב-What’s New הוא תוצאה משלו, והקישור שלו קופץ אל העדכון בתוך היום. עד היום כל יום בעמוד הזה היה סעיף אחד באינדקס. עדכון שהתאים לחיפוש הופיע בתוך כרטיס של היום כולו, מוצג מלמעלה ומכווץ, ולכן לא ראו אותו בלי להרחיב את הכרטיס ולחפש בתוכו, ושני עדכונים מאותו יום יכלו לתפוס לכל היותר כרטיס אחד. בנוסף, היום נחתך לנתחים לפי גודל ולא לפי עדכון, ולכן נתח ערבב כמה עדכונים, או התחיל באמצע עדכון בלי הפתיח שלו. עכשיו כל בולט ביום הוא רשומה משלו באינדקס: הכותרת שלה היא הפתיח המודגש של העדכון, השביל הוא העמוד, התאריך והפתיח, והוא בראש כל נתח של העדכון. ”פתח באתר התיעוד“ קופץ לפתיח בתוך היום, בדפדפן שתומך בקפיצה לטקסט (text_fragment ב-services/docs_search_contract.py, שבונה את :~:text=), וכשהפתיח כבר אינו בעמוד הדפדפן מגיע לראש היום. עדכון בלי פתיח מודגש, או שהפתיח שלו חוזר בעמוד (תווית כמו ”מגבלה ידועה:“; גם ברישיות או בניקוד אחרים, כי כך הדפדפן מחפש), נכנס בשם של היום ובלי קפיצה. העמודים שעובדים כך מוצהרים ב-UPDATE_LOG_SOURCES (services/docs_index_service.py), והגבולות בין העדכונים נקבעים בפרסר של markdown-it-py, אותה ספרייה של services/md_parser.py. הכללים לכתיבת רשומה כזו: רשומה ב-What’s New. RECORDS_VERSION עלה ונשמר במסמך המצב, ולכן אחרי הפריסה ”בדוק עכשיו“ ורשת הביטחון בונים מחדש את התוכנית של האינדקס, גם כשקובץ הייצוא לא השתנה. המעבר הראשון מטמיע מחדש את העמוד הזה, וכשהוא עובר את APPROVAL_THRESHOLD_CHUNKS הוא מחכה לאישור בעמוד האדמין.

  • fix (WebApp): דפדפן הקוד מציג את הקובץ כמו שהוא בריפו — ``key = index_info.get(”key“)`` לא מוצג יותר ``key=***``, ושורה שבאה אחרי ``BOT_TOKEN=`` ריק לא נעלמת. ו“ערוך / העתק“ (``/upload/from-repo``) פתוח עכשיו לאדמין בלבד. הסיבה: _run_git_command ב-services/git_mirror_service.py העביר ב-_sanitize_output גם את ה-stdout של git, ולא רק את ה-stderr ואת הפקודה שנכתבת ללוג. אבל ה-stdout הוא הנתונים עצמם — תוכן הקובץ (git show), שמות הקבצים (ls-tree) והודעת הקומיט (log). הביטוי לפי שמות שב-_sanitize_output החליף ב-*** את מה שבא אחרי token, ‏``password``, ‏``secret`` או key ואחריהם = או :, תפס גם תת-מחרוזת (monkey = 5), וכשהערך היה ריק חצה את ירידת השורה ובלע את השורה הבאה. סודות אמיתיים הוא לא תפס: AWS_ACCESS_KEY_ID=AKIA... ו-MONGODB_URL=mongodb://user:pass@host עברו כמו שהם. והחלק שמסתיר סיסמה בכתובת שינה גם כתובות לדוגמה בתוך מסמכים. מה הושפע: תצוגת הקובץ בדפדפן הקוד, הטופס של ”ערוך / העתק“, כרטיס הקומיט האחרון בדשבורד, שמות קבצים ב-codekeeper_list_repo_tree, ו-size ו-lines שהאינדקס (repo_files) מחשב מהתוכן. תצוגת ההיסטוריה ו-codekeeper_get_repo_file קוראים ב-get_file_at_commit, שקורא את הבתים בלי _run_git_command, ולכן לא הושפעו — ואותו קובץ הוצג בשני המסלולים אחרת. נמדד ב-11.10.2026 בהרצה של _sanitize_output על כל קובץ טקסט ש-CodeIndexer.should_index מקבל, ב-HEAD fa4e8ab של CodeBot: 481 מתוך 1,944 קבצים השתנו, וב-68 מהם נבלעו שורות. עכשיו ה-stdout חוזר כמו שהוא, והניקוי נשאר על ה-stderr ועל הפקודה שבלוג — המקום שבשבילו הוא נכתב, כי שם git מדפיס את ה-URL כשפקודת רשת נכשלת. ”כמו שהוא“ כולל את סופי השורות: _run_git_command רץ עד היום ב-text=True, ובמצב הזה subprocess מחליף CRLF ו-CR בודד ב-LF (Popen._translate_newlines, CPython 3.11 ו-3.12), ולכן קובץ Windows הגיע לדפדפן הקוד בלעדיהם, ו-size שלו באינדקס יצא קטן מדי. היום הפלט נקרא כבתים ומפוענח ב-UTF-8. הפקודה היחידה שה-stdout שלה יכול לשאת טוקן היא remote get-url origin (מראה מלפני #3480), והקורא היחיד שלה, ensure_clean_remote, מחזיר את ה-URL רק אחרי strip_userinfo. ”ערוך / העתק“ היה מוגן ב-login_required בלבד: נמדד מול האפליקציה האמיתית ומראה בדיקה שמשתמש מחובר שאינו אדמין מקבל בו את תוכן הקובץ, בזמן ש-/repo/api/file מחזיר לו 403. עכשיו הוא ב-admin_required, כמו כל עמוד אדמין. אחרי הפריסה: size ו-lines שכבר שמורים באינדקס מתעדכנים כשהקובץ משתנה, והרצה חוזרת של initial_import לריפו מחשבת אותם מחדש מיד — ראו התוכן כמו שהוא בריפו, ומי רואה אותו. אינדקס החיפוש בתיעוד לא הושפע: הוא נבנה מ-_export/sections.json של האתר, ולא מהמראה.

  • fix (WebApp): ”שמור“ בעמוד של ”ערוך / העתק“ שומר את הקובץ — עד היום הוא החזיר 405. העיפרון ”ערוך / העתק קטעים“ בדפדפן הקוד פותח את /upload/from-repo, שמרנדר את טופס ההעלאה (upload.html) עם הקובץ מהריפו. לטופס לא היה action, ולכן הדפדפן שלח אותו לכתובת של העמוד עצמו — /upload/from-repo, שמקבל GET בלבד (נמדד בכרומיום מול השרת האמיתי). עכשיו ה-action הוא url_for('upload_file_web'), כלומר /upload, בשני הראוטים שמרנדרים את הטופס. test_save_on_the_edit_from_repo_page_saves_the_file גוזר את היעד מה-HTML של העמוד, כמו דפדפן, ונפל לפני התיקון ב-405.

  • fix (בוט): עלייה בזמן שאין primary במסד לא נופלת יותר ב-``JobQueue.start``, וכשעלייה כן נכשלת עולה השגיאה האמיתית, ולא ``cannot pickle »SSLContext« object``. ב-9.10 (CODEKEEPER-3M) הבוט עלה בזמן שלא היה primary ב-Atlas. JobQueue.start הפעיל את ה-jobstore persistent של APScheduler, וזה יצר אינדקס על scheduler_jobs — כתיבה, שדורשת primary — והעלייה נכשלה ב-ServerSelectionTimeoutError. בסגירה שאחרי זה PTB העתיק (deepcopy) את bot_data בשביל PicklePersistence, נפל על לקוח ה-pymongo של אותו jobstore, וה-TypeError הזה החליף את השגיאה האמיתית בלוג וב-Sentry. ה-jobstore הוסר, כי אף job לא נכנס אליו: הבדיקה ב-handlers/drive/menu.py חיפשה scheduler.jobstores, שאין ב-APScheduler 3.11.3 (יש רק _jobstores), וגם אילו נבחר, job של PTB 22.5 אינו עובר pickle (weakref). ובכל זאת הוא כתב בעלייה, הלקוח שלו ישב ב-bot_data, ו-APScheduler שאל אותו בכל התעוררות מתוך ה-event loop — ב-9.10 שאילתה כזו נמשכה 49 שניות, וכל הבוט עמד. יצאו איתו _get_scheduler_pymongo_client, הבדיקה המתה וה-fallback ב-Drive יחד עם האירוע drive_schedule_job_persistent_fallback, ומשתנה הסביבה APSCHEDULER_COLLECTION. ה-jobs של ה-JobQueue חיים בזיכרון בלבד, ו-drive_reschedule בונה מחדש את ה-jobs של Drive מהתזמון השמור במסד בכל עלייה. ``PicklePersistence`` הוסר, כי הוא לא שמר דבר: השמירה התקופתית נפלה על אותו deepcopy כבר בסבב הראשון ומתה בלי לוג, והקובץ נכתב ל-/tmp, ש-Render מוחק בכל ריסטארט ובכל דיפלוי. מה שהוא כן עשה: בכל עלייה החליף את bot_data בתוכן השמור, הריק, ולכן ה-handlers ש-CodeKeeperBot שומר שם לפני run_polling נעלמו. מה משתנה בפועל: github_handler, ‏``backup_handler``, ‏``drive_handler`` ו-skill_handler נמצאים ב-bot_data כבר מתחילת העלייה. עד היום show_github_menu יצר מופע שני של GitHubMenuHandler בלחיצה הראשונה על כפתור GitHub, ו-drive_reschedule שחזר את ה-handler של Drive מ-application._drive_handler — ולכן האירוע drive_reschedule_handler_restored לא אמור להופיע יותר בעלייה רגילה. האינדקס של ``scheduler_jobs`` יצא מרשימת האינדקסים שבעלייה (database/manager.py), בכוונה: אין קוד שקורא מהאוסף מסמכים או כותב אליו. האוסף עצמו, וכל אינדקס שכבר נוצר עליו, נשארים. מסלול האדמין /admin/resolve-naming-conflicts עדיין יוצר עליו אינדקס כשמריצים אותו ידנית.

  • tests: ``tests/test_main_startup_with_real_ptb.py`` מריץ את העלייה האמיתית של הבוט, עם PTB ו-APScheduler אמיתיים, מול מסד שלא עונה. שאר הסוויטה רצה עם stubs של telegram (tests/conftest.py), ואין בהם את JobQueue.start ואת shutdown של PTB — בדיוק המקום של הבאג. הטסט מריץ בתת-תהליך את tests/helpers/main_startup_probe.py: ה-Application ש-CodeKeeperBot בונה, עם setup_bot_data, מול Bot API מקומי במקום טלגרם, ובסביבה מפורשת שאינה יורשת מפתחות מהסביבה של מי שמריץ. שני הטסטים נכשלו על הקוד שלפני התיקון, כל אחד על ה-assert שלו: העלייה לא הגיעה ל-job queue שמריץ ג’ובים (TypeError שהסתיר ServerSelectionTimeoutError מ-JobQueue.start), ו-502 על deleteWebhook עלה כ-TypeError במקום NetworkError.

  • docs: התקציר שכל עמוד ``.rst`` מצהיר עליו (``:summary:``) לא מוצג יותר באתר — הוא עבר לשורה הראשונה של הקובץ, לפני הכותרת. עד היום השדה ישב מתחת לכותרת, ושם Sphinx הציג אותו כחלק מהעמוד; משם הוא הגיע לכפתור ”העתק“, לקובץ הייצוא (_export/sections.json) ולכרטיסי החיפוש בתיעוד, כשורה שמתחילה ב-”summary:“ — בזמן שהוא נועד רק ל-AI-MAP.md. רשימת שדות שפותחת את הקובץ היא המנגנון ש-Sphinx מגדיר למידע על עמוד (”File-wide metadata“): הוא שומר אותה ואינו מציג אותה, בדיוק כמו את ה-front matter של עמודי .md. scripts/generate_ai_map.py קורא את השדה מהמקום החדש (_rst_summary_declaration), ו-AI-MAP.md לא השתנה. test_no_rst_page_has_a_summary_away_from_the_top_of_the_file נכשל על כל :summary: בעמודה 0 שאינו ההצהרה שבראש הקובץ — גם על שדה שבא אחרי תווית, כי שם הוא שובר את התווית בלי אזהרה. הכלל המלא ב-Doc Authoring Guide (Sphinx/RTD). בכלי התיעוד של MCP (codekeeper_docs_get_section) התקציר כבר לא חלק מהטקסט של הסעיף הראשון, כי הוא יושב לפני הכותרת; הוא נשאר ב-AI-MAP.md. באינדקס החיפוש בתיעוד סעיף שכל תוכנו היה התקציר נשאר ריק, ויוצא מהאינדקס במעבר שאחרי הפריסה.

2026-10-10

  • fix (WebApp + MCP): פתקים שומרים בדיוק את מה שהוקלד — ``&amp;``, ``&lt;div&gt;`` ו-``&quot;`` כבר לא הופכים ל-``& <div> ”``. טקסט כזה שהוקלד בפתק — בטקסט רגיל, בקוד בשורה ובבלוק קוד — הוצג תקין עד ריענון, ואחריו, גם במצב עריכה, הוצג & <div> ". הסיבה: מאז #1227 השרת הריץ html.unescape על כל גוף של פתק בשמירה (_sanitize_text בוובאפ, ו-_sanitize_note_text ב-MCP מאז #3189) וגם בקריאה (_coerce_content_from_doc, _as_note). לכן הטקסט המקורי לא הגיע למסד כבר בשמירה הראשונה, &copy= בתוך כתובת הפך ל-©=, ו-note_str_replace כתב בחזרה את כל הפתק מפוענח. עכשיו הגוף נשמר בדיוק כמו שנשלח ונקרא כמו שהוא שמור, בוובאפ וב-MCP — אותו כלל של קבצים — וה-escape נעשה רק בתצוגה, ב-textContent. הוסרו גם שאר השינויים שהניקוי עשה: המרה של CRLF ל-LF, מחיקה של תווי בקרה, ו-.strip() ב-MCP. גוף שכולו רווחים עדיין נדחה ב-empty_content, אבל הבדיקה רצה על עותק, ומה שנשמר הוא המקור. חלונית התזכורות בנתה את השורה ב-innerHTML עם בריחה של < ו-> בלבד, ולכן פענחה ישויות בעצמה; היא נבנית עכשיו בצמתים. בוובאפ content שאינו מחרוזת נדחה ב-400 invalid_content (עד היום str() שמר מילון כטקסט), ומחט חיפוש ארוכה מ-NOTE_SEARCH_MAX_NEEDLE נדחית ב-query_too_long במקום להיחתך. בשני החיפושים מחט עם NUL נענית invalid_query: מונגו דוחה $regex כזה, ועד היום הניקוי מחק את ה-NUL בשקט. שינוי חוזה ב-MCP: codekeeper_get_note כבר לא מחזיר stored_content. השדה נוסף ב-#3456 כדי לעקוף את הפענוח, ועכשיו note.content הוא אותו גוף; לצידו note.content_sha256. תשובות הכתיבה של פתקים נושאות note.content_sha256, ו-content_changed כשהקריאה כתבה גוף, באותו חוזה של הקבצים: בעדכון — מהמסמך ש-find_one_and_update החזיר, וביצירה — מקריאה חוזרת לפי ה-_id, וכשהיא נכשלת אין hash ו-content_changed הוא null (פתקים: note.content_sha256 ו-content_changed). מדידה בייצור לפני ההסרה (10.10.2026, שאילתות קריאה בלבד ב-Atlas): אף פתק אינו מכיל ישות ש-html.unescape מפענח — נבדקו &amp;, &lt;, &gt;, &quot; ו-&#x27;, ואחד-אחד כל פתק שיש בו & ואחריו אות, ספרה או # — וגם אף גרסה ב-sticky_note_versions אינה מכילה את הישויות שברשימה. כלומר הסרת הפענוח בקריאה אינה משנה את התצוגה של אף פתק קיים, ולא נדרשת מיגרציה. פתקים שכבר נפגעו אי אפשר לשחזר: הטקסט המקורי לא הגיע למסד, ובהיסטוריה ובגיבויים יושב אותו טקסט מפוענח. ראו התוכן: נשמר כמו שנשלח, וה-escape שייך לתצוגה ו-ניקוי קוד מודבק (Pasted-code cleanup).

  • fix (WebApp): כרטיסי החיפוש בתיעוד — קובץ המקור בראש הכרטיס, אייקון שמתחלף בהרחבה, וחזרה לכרטיס אחרי כיווץ. בראש כל כרטיס מופיע עכשיו הקובץ שהסעיף כתוב בו בריפו (source_path בתשובה, למשל docs/webapp/global-search.rst), מעל שביל הכותרות. עד היום הופיעה שם רק כותרת העמוד. כפתור ההרחבה החליף בלחיצה רק את הטקסט ואת aria-expanded, והאייקון נשאר של הרחבה גם כשהסעיף היה פתוח — והאייקון הוא כל מה שרואים, כי הטקסט של כפתור מוצג רק כשהאייקונים לא נטענו (.btn .btn-text ב-base.html). עכשיו שלושתם נגזרים יחד מהמצב של הסעיף (syncDocsExpandButton). ובכיווץ: הכפתור יושב בתחתית הסעיף הפתוח, ואחרי הכיווץ הסעיף התקצר מעליו והגלילה זזה רק בחלק מהקיצור, כך שהכרטיס כולו נשאר מעל המסך, ועל המסך היה תוכן אחר. עכשיו, כשראש הכרטיס מעל המסך, המסך חוזר לראש הכרטיס (scrollIntoView עם block: 'start', שגולל את body של העמוד — ראו Issue #3534), גם כשהכרטיס המכווץ גבוה מהמסך. כרטיס שראשו כבר על המסך לא זז. ראו תיעוד.

2026-10-07

  • feat (WebApp): חיפוש בתיעוד מתוך עמוד הקבצים, לאדמין — הסוג ”תיעוד“ בתיבת החיפוש. זה השלב השלישי של החיפוש בתיעוד: השאלה מוטמעת במודל שהאינדקס נבנה בו, POST /api/search/docs מחזיר את הסעיפים הקרובים, וכל סעיף מוצג בכרטיס מימין לשמאל, מרונדר כמו בתצוגת ה-Markdown של דפדפן הקוד, עם הערות ותרשימים. בכרטיס: ”פתח באתר התיעוד“, ”העתק כמארקדאון“, ו“הצג את כל הסעיף“ לסעיף ארוך, שמוצג בהתחלה רק בחלקו העליון. מעל הכרטיסים כתוב לאיזה קומיט האינדקס נכון, עם קישור לעמוד האדמין. כשהאינדקס לא זמין, ההודעה אומרת למה, ולא ”לא נמצאו תוצאות“. בדרך: הטוען של ספריות ה-Markdown (markdown-deps.js) והעיצוב שלה (markdown-preview.css) יצאו מדפדפן הקוד לקבצים משותפים. הטוען טוען עכשיו ישירות את הבאנדל המקומי, בכתובת עם מזהה גרסה, במקום לנסות קודם CDN, והדדליין שלו נגזר ממדידה. העיצוב עבר כמו שהוא, והגבולות וההדגשה נקראים בו עכשיו דרך טוקנים של הרכיב (--md-preview-border, --md-preview-accent), כי --border-color ו---accent-blue מוגדרים רק בדפדפן הקוד. בדפדפן הקוד נמדד לפני ואחרי בכל הערכות, בלי אף הבדל, ובערכה מיובאת הכרטיס זהה לו. ובתיבת החיפוש: תשובה של חיפוש ישן כבר לא דורסת חיפוש חדש שהתחיל אחריו. ראו תיעוד.

  • feat (WebApp): אינדקס של אתר התיעוד לחיפוש מתוך הוובאפ, עם עמוד אדמין, ‏``/admin/docs-index``. זה השלב השני של החיפוש בתיעוד: הוובאפ בונה מקובץ הייצוא של האתר שני אוספים — סעיף לכל כרטיס שיוצג (docs_sections) ונתח עם וקטור לכל קטע שמוטמע (docs_chunks) — ומעדכן אותם אחרי כל פריסה של האתר, רק במה שהשתנה. מה מפעיל: ה-webhook של GitHub באירוע deployment_status, שקורא את העותק של הקובץ לפי הקומיט של הפריסה; רשת ביטחון ב-webhook של push לענף הראשי של ריפו המקור, בלי תלות בסנכרון של המראה; והכפתור ”בדוק עכשיו“. השומרים: מילוי ראשון, החלפת מודל, ויותר מ-APPROVAL_THRESHOLD_CHUNKS נתחים להטמעה מחכים לאישור בעמוד, עם התוכנית וטביעת אצבע שלה; מחיקה רק כשהקובץ מכיר לפחות רשומה אחת מהמסד; קובץ שנבנה לפני זה שכבר הוחל לא מוחל; והקומיט שהאינדקס נכון אליו נכתב רק אחרי קריאה חוזרת שמוצאת הכול. בדרך: ה-webhook של GitHub מוחרג מהמגבלה הגורפת של קצב הבקשות — היא נספרת לפי IP, ו-GitHub שולח מכמה כתובות קבועות, כך שמשלוחים של push וסטטוסי פריסה נספרים יחד ועלולים להיחסם ב-429; לקוח הטמעות סינכרוני (SyncEmbeddingClient), שחולק עם הלקוח האסינכרוני את השער של הקצב ואת הסיווג של הסטטוסים — הסיווג עבר ל-services/embedding_service.py, עם ענף ”לא ידוע“ מפורש; וקובץ ייצוא עם surrogate בודד נדחה כקובץ פגום ולא כחריגה. צריך לעשות פעם אחת: לסמן את deployment_status ב-webhook של הריפו, וליצור ב-Atlas את האינדקס הווקטורי לפי ההגדרה שהעמוד מציג. ראו אינדקס התיעוד.

  • feat (תיעוד): בניית אתר התיעוד מייצאת את כל הסעיפים ל-``_export/sections.json``, עם הממיר של כפתור ”העתק תוכן הדף“. זה השלב הראשון של חיפוש בתיעוד מתוך הוובאפ. הקובץ נכתב מאותה בנייה שנפרסת, ולכן המזהה של כל סעיף בו הוא המזהה באתר, גם כשזה מספר רץ של Sphinx. copy-page.js חושף את ההמרה של הכפתור כ-window.DocCopyPage.toMarkdown, ו-scripts/docs_export_sections.py מריץ אותה בדפדפן על כל סעיף. כשל בייצוא לא מפיל את בניית האתר: האתר נפרס בלי הקובץ, נכתבת אזהרה, ובבנייה של main נשלחת התראה לטלגרם דרך פעולה משותפת חדשה, .github/actions/telegram-message. הפרטים ב-Doc Authoring Guide (Sphinx/RTD).

  • fix (WebApp): ‏``webapp/app.py`` נטען פעם אחת — עד היום כל עלייה של הוובאפ הריצה אותו פעמיים. גוניקורן טען app:app מתוך webapp/, כלומר את הקובץ בשם app, בזמן שכל הקוד מייבא from webapp.app import .... פייתון מזהה מודול לפי השם שלו ולא לפי הקובץ, ולכן הבקשה הראשונה לשם webapp.app טענה את כל הקובץ פעם שנייה — בשחזור של העלייה (gunicorn עם gevent, כמו בפרודקשן) היא הגיעה מתהליך שליחת התזכורות ב-webapp/push_api.py, עוד באמצע הטעינה הראשונה. כל מה שרץ בקובץ בזמן טעינה רץ פעמיים, וזה גלוי בלוג של הפרודקשן: התראת ”webapp service starting up“, רישום ה-jobs, בדיקת מודל ה-embedding, ושרשור האינדקסים של תגיות ההתראות; ולכל עותק get_db משלו, עם MongoClient משלו. כך גם python app.py, בשם __main__. עכשיו scripts/start_webapp.sh מפעיל את webapp.app:app מתוך webapp/, עם --pythonpath לשורש הריפו. תיקיית העבודה לא השתנתה בכוונה: BotConfig קורא .env יחסית אליה, וה-.env שבשורש נמצא בגיט — מהשורש הוא היה ממלא בשקט כל משתנה שלא הוגדר בסביבה. בלוק בראש app.py עוצר טעינה בכל שם אחר (גם WEBAPP_WSGI_APP שמוגדר ל-app:app עוצר עכשיו את העלייה בשגיאה), ובהרצה ישירה טוען את הקובץ פעם אחת בשמו ומריץ ממנו את run_dev_server. שרת הפיתוח מאזין עכשיו ל-127.0.0.1, ופתיחה לרשת דורשת WEBAPP_DEV_HOST: עם DEBUG=true הוא מגיש גם את הדיבאגר של Werkzeug. tests/test_webapp_import_paths.py בודק את הטעינה בגוניקורן, בשם הקצר ובהרצה ישירה, ואת הסקריפט עצמו.

2026-10-06

  • fix (WebApp): ”העתק“ בתצוגה המקדימה של כרטיס מעתיק את כל הקובץ, בגרסה ששמורה ברגע הלחיצה. עד היום הכפתור העתיק את הטקסט שמוצג בכרטיס — רק תחילת הקובץ, ואחרי שעבר בצובע התחביר, כלומר בלי ההזחה של השורה הראשונה, עם LF במקום CRLF ובלי השורות הריקות שבסוף (נמדד עם Pygments 2.19.2). עכשיו ההעתקה מבקשת את התוכן מ-api_file_content (/api/file/<file_id>/content) ברגע הלחיצה, וכותבת ללוח את הקובץ כמו שהוא שמור. הגרסה העדכנית, ולא זו שבכרטיס: כל שמירה של קובץ יוצרת מסמך חדש עם _id חדש, והכרטיס מחזיק את המזהה של הגרסה שהייתה האחרונה כשהעמוד נטען — ולכן קובץ שנשמרה לו גרסה חדשה מאז (מהבוט, מטאב אחר, מסוכן דרך ה-MCP) הוצג בתצוגה המקדימה בגרסה הישנה, בלי שום סימן. file_preview וההעתקה משתמשים עכשיו במזהה רק כדי לדעת על איזה קובץ מדובר, ושולפים את הגרסה הפעילה האחרונה (_latest_file_doc_by_id). התצוגה כותבת איזו גרסה היא מציגה, ”פתח דף מלא“ פותח אותה, והכפתור אומר ”הועתקה גרסה N“. קובץ שעבר לסל המיחזור מדווח במקום להיות מוצג או מועתק, ומסד לא זמין מחזיר 503 ולא ”הקובץ לא נמצא“. הכתיבה ללוח נפתחת בתוך הלחיצה, עם ClipboardItem שהתוכן שלו נכנס כשהשרת עונה: ספארי ופיירפוקס דוחים כתיבה ללוח שמגיעה אחרי המתנה לרשת. בנוסף, card-preview.js ו-card-preview.css נטענים עכשיו עם ?v={{ static_version }} בעמוד הקבצים ובעמוד האוספים — בלעדיו הדפדפן היה ממשיך להריץ את העותק הישן עד שנה (SEND_FILE_MAX_AGE_DEFAULT). tests/test_card_preview_latest_version.py בודק את השרת ו-tests/card-preview-copy.test.js את ההעתקה מול לוח מדומה, ושניהם רצים ב-CI; tests/test_card_preview_copy_browser.py בודק את הזרימה כולה בכרומיום אמיתי מול מונגו אמיתי.

  • tests: ``tap_on`` ב-``tests/_browser_harness.py`` מחכה רק לאנימציה שרצה. אנימציה שהסתיימה עם forwards נשארת ב-document.getAnimations() במצב finished, וההמתנה ל“אלמנט שאינו זז“ לא הסתיימה אף פעם. כך קרה לכל כפתור בכרטיס בעמוד הקבצים, שנכנס עם slideUpFade (.stagger-feed > * ב-animations.css): נגיעה בו פקעה תמיד.

  • fix (tests): בדיקות האינדקסים ב-``tests/test_note_boards_mongo.py`` לא נופלות יותר כשהן רצות אחרי בדיקות התזכורות באותו תהליך. _ensure_indexes זוכר בגלובלים של webapp/sticky_notes_api.py אם האינדקסים נבנו, ואחרי בנייה שנכשלה גם מתי מותר לנסות שוב (_INDEX_RETRY_AFTER). בדיקות התזכורות ב-tests/test_sticky_note_reminders.py משאירות את חלון ההמתנה פתוח, והפיקסצ’ר indexed_db איפס את הדגלים שהכיר ולא את החלון — ולכן כששני הקבצים רצו באותו worker של pytest -n בתוך _INDEX_RETRY_SECONDS, הבנייה יצאה מוקדם ושמונה בדיקות נפלו על מסד בלי אינדקסים. עכשיו reset_index_state_for_tests, ליד הגלובלים, מחזירה את כל המצב לנקודת ההתחלה — כולל הדגל המשותף בקאש, שהיא מוחקת וקוראת בחזרה — ופיקסצ’ר אוטומטי ב-conftest.py שבשורש קורא לה לפני כל בדיקה ואחריה. רשימות האיפוס שבקבצי הטסט הוסרו, ו-tests/test_sticky_notes_index_state.py גוזר מקוד המקור את הגלובלים שהבנייה כותבת ונופל אם האיפוס שוכח אחד מהם. האיפוס הוא גם גבול: עבודה שהתחילה לפניו — חימום שתוזמן, בקשה שממתינה לנעילה, בנייה שנכשלת בזמן שהוא ממתין — אינה בונה ואינה כותבת אחריו (_INDEX_STATE_GENERATION), והמחיקה של הדגל המשותף מאומתת מול הלקוח שמאחורי CacheManager, שמחזיר None גם כש-Redis לא ענה. בקוד הייצור אין מי שמקדם את הדור, ושני שינויים קטנים כן יש שם: כשהבנייה נכשלת בחריגה, _INDEX_RETRY_AFTER נקבע לפני שהנעילה משתחררת; וכשאינדקס שם לא אומת, האירוע failed נשלח אחרי שחרור הנעילה ולא לפניו — כמו במסלול החריגה. התיקון קודם ל-#3292, שיריץ את בדיקות המונגו האלה ב-CI. ו-Sticky Notes Warmup – פתרון ביצועים משולב מבחין עכשיו בין _INDEX_RETRY_SECONDS, אורך ההמתנה, לבין _INDEX_RETRY_AFTER, המועד שנבדק בפועל.

  • fix (לוגים): אירוע info שקורה פעם אחת בחיי התהליך כבר לא נעלם בדגימה, ו-``LOG_INFO_SAMPLE_ALLOWLIST`` מוסיף על הרשימה המובנית במקום להחליף אותה. עם LOG_INFO_SAMPLE_RATE מתחת ל-1, _maybe_sample_info ב-observability.py הגריל כל הופעה של אירוע info בנפרד, גם של אירוע שנשלח פעם אחת בעלייה. בוובאפ, ב-6.10, השורה db_connected הופיעה בלוגים של Render ב-3 מתוך 7 עליות, בזמן ש-db_connection_fallback_noop (רמת error, שאינה נדגמת) לא הופיעה באף אחת — כלומר המסד התחבר בכולן, והשורה נזרקה בארבע. היעדר metrics_db_initialized באותו יום הוביל למסקנה, בלי ראיה, שכותב המדדים של הוובאפ לא עולה. עכשיו אירוע שאף שורה שלו לא נשמרה ב-INFO_SAMPLE_WINDOW_SECONDS האחרונות נשמר בלי הגרלה, ורק חזרות בתוך החלון נדגמות; 0 עדיין מכבה את כל ה-info שאינו ב-allowlist. בנוסף, LOG_INFO_SAMPLE_ALLOWLIST החליף עד היום את INFO_SAMPLE_BUILTIN_ALLOWLIST, והתיעוד הציג כברירת מחדל רשימה בלי access_logs, כך שמשתנה שהוגדר לפי התיעוד גרם לדגימה של שורות הגישה בלי כוונה. עכשיו המשתנה מוסיף על הרשימה. ו-nan כשיעור, שזרק כל אירוע info שאינו ב-allowlist, נחשב עכשיו 1.0 כמו כל ערך שאינו מספר. בתיעוד, סכמת לוגים מסביר מה אומר היעדר של שורה בלוג. docs/logging_schema.md אוחד לתוכו: ה-rst היה מוחרג מהבנייה, העמוד שפורסם היה ה-md, ו-AI-MAP.md הצביע על הקובץ המוחרג.

  • fix (מדדים): כתיבת המדדים למונגו לא נתקעת עוד בלולאת E11000 אחרי ניתוק. בערב 6.10 החלפת primary ב-Atlas קטעה כתיבה של מדדי בקשות ל-service_metrics אחרי שהשרת כבר כתב אותה (operation cancelled). _flush_once ב-monitoring/metrics_storage.py החזיר לתור את כל הבאצ« על כל חריגה — ו-pymongo כבר הוסיף _id לכל מסמך — ולכן כל ניסיון מאז נכשל על כפילות באותם _id, לנצח: בלי הפסקה בין ניסיונות (חותמת ה-flush התקדמה רק בהצלחה, כך שכל בקשה הפעילה ניסיון), הבאצ« התקוע בראש התור עיכב את כל המדדים שמאחוריו עד שהתור הגיע לתקרה שלו (METRICS_MAX_BUFFER), וכל שורת לוג הדפיסה את כל המסמכים — כולל נתיב הבקשה, שיכול לשאת טוקן של קישור שיתוף. עכשיו כל תוצאה מטופלת לפי הסוג שלה: כפילות על _id היא מסמך שכבר שמור; שגיאת כתיבה אחרת זורקת רק את המסמך שלה ונספרת לפי הקוד; תקלה שאחריה אי אפשר לדעת אם נכתב — ניתוק, אין primary, מגבלת זמן (_OUTCOME_UNKNOWN_ERRORS) — מחזירה את הבאצ« לתור עם ה-_id שלו, שהכותב קובע בעצמו לפני הניסיון הראשון, כך שהניסיון החוזר לא יכול לכתוב פעמיים; וכל חריגה אחרת — באג, הרשאה — זורקת את הבאצ« ברמת error ועם traceback, במקום לחזור לתור. אחרי כשל, הניסיון הבא מחכה METRICS_FLUSH_INTERVAL_SEC מהניסיון האחרון (_last_write_attempt_ts) ולא מההצלחה האחרונה. בלוג יש רק מספרים וקודים, והאירועים מתוארים ב-קטלוג אירועים קנוניים, בסעיף Metrics (DB). גם לולאת הרקע של הכותב כבר לא בולעת חריגות בשקט. ובדרך: התיאור של METRICS_DB_ENABLED ב-משתני סביבה - רפרנס וב-Config Inspector טען שהכתיבה ”מושבתת בפרודקשן ברמת הקוד“ — הקוד אינו משבית אותה, והלוגים של הוובאפ הראו אותה כותבת; התיאור תוקן. tests/test_metrics_storage_write_outcomes.py בודק כל תוצאה מול דמה שבנויה כמו התשובות של pymongo 4.15.3, ו-tests/test_metrics_storage_flush_mongo.py משחזר את התקלה מול מונגו אמיתי: התשובה אבדה אחרי שהשרת כתב, וכל מדד שמור פעם אחת. כל טסט חדש הורץ על הקוד שלפני התיקון ונפל שם, חוץ מטסט בקרה אחד שמוודא שהמרווח אחרי כתיבה מוצלחת לא השתנה.

  • fix (WebApp): תפריטי הסרגל העליון לחיצים שוב, וסרגל החיפוש נצמד רק בזמן חיפוש. אחרי #3535, בכל עמוד, חלונית קיצורי הדרך (🚀) ותפריט האפקטים (🪄) נפתחו ונראו תקינים, אבל נגיעה בכפתור לא עשתה כלום (נמצא בטאבלט, כרום לאנדרואיד). .navbar יושב בשכבה שמתחת ל-.main-content: ה-z-index שלו מת מאז שאינו ממוקם, וה-transform וה-backdrop-filter שלו כולאים בתוכו את החלוניות. עד #3535 החלוניות נחתכו בתוך הסרגל ולא יצאו מעל התוכן; המעבר ל-overflow-x: clip שחרר אותן, והנגיעה הלכה לתוכן שמעליהן. עכשיו הסרגל עולה מעל התוכן רק בזמן שאחד התפריטים שלו פתוח (.navbar:has(...)), ולא לתמיד — כי נמדד שהרמה קבועה מסתירה את 🔖 ואת כותרת פאנל הסימניות בראש עמוד קובץ, ומונחת מעל כל חלון שנפתח על כל המסך מתוך תוכן העמוד. בנוסף, חלונית האפקטים נפתחה אל מחוץ למסך (עכשיו היא מעוגנת לצד השמאלי של השרביט), ובפריסת ההמבורגר הרשימה הפתוחה חתכה אותה (עכשיו .nav-menu.active אינו חותך). סרגל החיפוש בתצוגת קובץ ובתצוגת Markdown נצמד מאז #3535 גם בלי חיפוש, והסתיר את ראש התוכן לאורך כל הגלילה; עכשיו הוא נצמד רק כשיש טקסט בתיבה, ו-✕ משחרר אותו. גם הרווח מעל כותרות Markdown חל רק אז. הסרגל העליון עצמו לא השתנה: בלי תפריט פתוח הוא נגלל עם העמוד, כמו מאז #559. הכללים ב-מערכת ערכות הנושא והטוקנים החדשה. tests/test_navbar_menus_browser.py ו-tests/test_view_file_scroll_browser.py בודקים בכרומיום אמיתי במגע, ו-tests/test_navbar_and_search_bars_css.py שומר על ההחלטות גם ב-CI.

  • change (MCP): ‏``file_pattern`` ב-``codekeeper_search_repo`` מתואר בסכמה, ותיאור הכלי מפנה אליו. הפרמטר עבר תמיד כמו שהוא ל-git grep כ-pathspec אחד, אבל לא היה לו תיאור — וסוכן שרצה להחריג את assets/vendor מהחיפוש דיווח ב-get_more_tools על כלי חסר, בלי לדעת שהיכולת כבר קיימת. עכשיו התיאור אומר שזה pathspec של גיט מהשורש, ששם של תיקייה מסנן לפיה, שהכוכבית חוצה תיקיות, ש-:(exclude)<נתיב> מחריג, שהתבנית רגישה לרישיות גם כשהשאילתה לא (:(icase) מבטל), ושהיא רק מצמצמת: סוד וקוד חיצוני לא חוזרים דרכה. הוא גם מזהיר מ-docs/**/*.html, שבלי :(glob) מחמיץ את הקבצים שיושבים ישירות ב-docs בלי שגיאה. ההתנהגות עצמה לא השתנתה. כל צורה שהתיאור נוקב בה מקובעת בטסט מול מראה אמיתית, עם התוצאה שנמדדה לה על git 2.43.0. ראו סינון לפי נתיב (file_pattern).

  • fix (WebApp): גלילה וחיפוש בתצוגת קובץ — סרגל החיפוש נשאר על המסך, ▼ בתצוגה המתקדמת מגיע לתוצאה, ומסך מלא נגלל עד הסוף. ארבע תקלות שנמצאו בטאבלט (כרום לאנדרואיד), משלושה שורשים שונים. הסרגל הצמוד לא נצמד במסך רגיל, וכך גם הסרגל של תצוגת ה-Markdown והפריטים הצמודים של בונה הערכות: overflow-x: hidden על .main-content, .container ב-base.html הפך את שני המיכלים לקופסאות גלילה שאינן גוללות, ו-position: sticky נצמד לקופסה הקרובה. עכשיו overflow-x: clip — ראו את הכלל ב-מערכת ערכות הנושא והטוקנים החדשה. בעקבות זה כותרת ב-Markdown נוחתת מתחת לסרגל ולא מאחוריו (scroll-margin-top לפי הגובה הנמדד, --md-toolbar-h), ובבונה הערכות ההצמדה מבוטלת כשהפריסה נערמת, כי שם הפריטים הצמודים כיסו זה את זה. ▼ בתצוגה המתקדמת לא גלל, כי CodeMirror מניח שכשהוא מגיע ל-body זה החלון, והעמוד נגלל בתוך body (Issue #3534). עכשיו EditorView.scrollHandler ב-view-codemirror-toggle.js מעביר את הגלילה ל-scrollIntoView של הדפדפן, וההתאמה נגללת למרכז המסך ולא אל מתחת לסרגל. במסך מלא בתצוגה המתקדמת שום דבר לא גלל, ובבסיסית השורה האחרונה נחתכה מתחת לקצה המסך: הכרטיס הוא עכשיו עמודה גמישה, וקופסת הקוד ממלאת בדיוק את מה שנשאר וגוללת בשתי התצוגות (#codeCard:fullscreen ב-view_file.html). tests/test_view_file_scroll_browser.py בודק כל תקלה בכרומיום אמיתי, במגע של טאבלט.

  • fix (WebApp + בוט): סל המיחזור מציג שורה אחת לכל קובץ, לא לכל גרסה. קובץ בן שש גרסאות תפס שש שורות עם אותו שם, אותו תאריך מחיקה ואותו תאריך תפוגה — ובבוט שש שורות כפתורים זהות לחלוטין, כי שם אין אפילו מספר גרסה להבחין ביניהן. לקבצים גדולים זה היה גרוע יותר: אין להם שדה גרסה, ושמירה מחדש מורידה את הרוויזיה הקודמת לסל, ולכן הסל התמלא בשורות בלתי ניתנות להבחנה של קבצים שלא נמחקו בכלל. השורה היום היא קובץ: היא נושאת את מספר הגרסאות שבסל, ושחזור ומחיקה סופית חלים על הקובץ כולו — שחזור של גרסה אחת היה מחזיר היסטוריה קטועה, התאום ההפוך של באג המחיקה שתוקן. שתי השאילתות (הבוט והוובאפ) אוחדו לצינור אחד ב-file_deletion; העותק שבבוט מיין בפייתון והחזיר סל ריק כשלמסמך אחד לא היה deleted_at. העימוד עבר למסד במקום לשליפת כל הסל לזיכרון, וכשל בשאילתה מוצג כשגיאה ולא כ“הסל ריק“ — בוובאפ מצב שגיאה, ובבוט ❌, כי Repository.list_deleted_files זורק מעכשיו במקום להחזיר ([], 0). קובץ גדול משוחזר כרוויזיה אחת: לכל שם יש מסמך פעיל אחד, ולכן חוזרת זו שנמחקה אחרונה, ושחזור נדחה כשכבר קיים קובץ גדול פעיל באותו שם (בוובאפ 409). ואחרי שחזור, הגרסה האחרונה היא זו שמסומנת לאינדוקס סמנטי מחדש — המזהים נאספים ממוינים בסדר של is_latest_active_snippet; בלי זה סומנה הגרסה הישנה, ה-worker סיים אותה באפס צ’אנקים, והקובץ המשוחזר לא חזר לחיפוש הסמנטי. ראו סל המיחזור: שורה לכל קובץ.

  • fix (WebApp): פתקים בדפדפן הריפו — פתק חדש נפתח איפה שגללת, וגלילת הקוד כבר לא נחסמת. שני הבאגים באו מאותו מקום: מנהל הפתקים שאל את הקונטיינר שאלות שבדפדפן הריפו התשובה עליהן נמצאת בגולל הפנימי של CodeMirror. createNote מדד כמה מהקונטיינר נגלל — שם תמיד אפס — ולכן פתק שנוצר בתחתית קובץ ארוך נשמר בראשו ונשאר מוסתר; היום המיקום נמדד מהפינה של מה שרואים ועובר באותה המרה כמו כל שמירה אחרת, בשני הצירים. _applySurfaceExtent כתב min-height על הקונטיינר כמו בלוח, העורך נמתח מעבר למה שמוצג, וסוף הקובץ נחתך — עם פתק surface עמוק, אחרי גרירה או הגדלה לכיוון התחתית, וגם אחרי מעבר ל-screen; היום הוא אינו כותב בדפדפן הריפו. ובאותו מקום: פתק שנגרר בזמן גלילה הצידה כבר אינו קופץ בגלילה הבאה (_surfaceReach). ראו עקרונות להוספת פיצ’ר לסטיקי-נוטס ו-פתקים דביקים (Sticky Notes).

2026-10-05

  • feat (WebApp): ערכה מיובאת יכולה לקבוע לעצמה את הרקע ואת הגבול של בלוקי הקוד בתצוגת ה-Markdown של דפדפן הריפו. ב-Cobalt Next יוצאים --code-bg (הבלוק), --bg-tertiary (המעטפת) ו---border-color (הגבול) באותו צבע, ולכן הבלוק לא נבדל מהטקסט שסביבו — נמדד בדגימת פיקסלים בעמוד האמיתי: רקע הבלוק, הגבול והמעטפת היו אותו פיקסל. --code-bg עצמו לא נדרס, כי הוא צובע גם רכיבי קוד אחרים. במקומו נכנסו לרשימה הלבנה --repo-md-code-block-bg-override ו---repo-md-code-block-border-override, בלי ערך ברירת מחדל בשום מקום, והם נקראים בכלל הקיים שצובע את הבלוק בערכות מיובאות ומשותפות, עם fallback שהוא בדיוק מה שנצבע שם עד היום. ערכה מיובאת שאינה מצהירה, ערכה משותפת שאינה מצהירה וכל הערכות המובנות נמדדו זהות למצב שלפני, גם ב-:hover. ראו בלוקי הקוד בתצוגת ה-Markdown של דפדפן הריפו.

  • fix (MCP): תקרת התיאור של קובץ נאכפת בכל כלי MCP שמקבל תיאור, ונכתבת בתיאורי הכלים (#3489, התיאור). FILE_DESCRIPTION_MAX_CHARS (500 תווים) נאכף עד היום רק ב-codekeeper_update_file_description, ו-codekeeper_save_file שמר תיאור בכל אורך — כלומר סוכן יכול היה לשמור תיאור של 2,000 תווים ואחר כך לא להצליח לעדכן אותו. עכשיו codekeeper_save_file שומר את הקובץ ולא את התיאור כשהוא ארוך מהתקרה, והתשובה (ok: true, כי הכתיבה קרתה) נושאת description_saved: false עם max_chars, actual_chars, הודעה, והפניה ל-codekeeper_update_file_description; תיאור שנשלח ונשמר — description_saved: true, לפי מה שנקרא חזרה, ו-null כשהקריאה החוזרת נכשלה. התקרה חלה רק על תיאור שנמסר: כלי העריכה מעתיקים תיאור קיים בכל אורך, ו-codekeeper_update_file_description מקבל בכל אורך את הטקסט שכבר שמור — ההשוואה נעשית בתוך הכתיבה עצמה, מול הגרסה האחרונה — ולכן קובץ עם תיאור ישן וארוך נשאר ניתן לעריכה ולסימון ”נבדק“. הבוט וטפסי הוובאפ שיוצרים גרסה (עריכה, העלאה) עוד אינם אוכפים — העדכון המהיר בוובאפ ממשיך לחתוך לתקרה, כמו קודם — ותגיות עוד בלי תקרה; שניהם בהמשך #3489. ראו תיאור ארוך בשמירה — description_saved.

  • change (MCP): ``description_too_long`` נושא ``max_chars`` ו-``actual_chars`` במקום ``max``. הסירוב נשא מספר בלי יחידה ובלי האורך שנשלח, וסוכן עם 413 תווים עבריים — 625 בתים — לא יכול היה לדעת ממנו אם הטקסט המקוצר שלו נכנס. עכשיו שני המספרים בתווים, באותם שמות של path_too_long ו-section_too_long, עם הודעה שאומרת ”תווים, לא בתים“. max יצא: לקוח שקרא אותו יקרא מעכשיו את max_chars. ראו עדכון תיאור בלי גרסה חדשה.

  • change (MCP): תיאור הפרמטר ``description`` ב-``codekeeper_save_file`` וב-``codekeeper_update_file_description`` נפתח בתקרה, ונבנה ממנה ברישום. עד היום הסכימה לא אמרה שיש תקרה בכלל, וסוכנים גילו אותה מקריאה שנכשלה. המשפט הראשון — ”עד N תווים (תווים, לא בתים)“ — נגזר מאותו קבוע שהאכיפה קוראת, ולכן אינו יכול להבטיח מספר אחר; תיאור codekeeper_update_file_description נוקב בשני שדות הסירוב. הקבוע עצמו עבר מ-database/repository.py ל-file_description.py שבשורש, מודול טהור שגם שכבת ה-MCP יכולה לייבא בלי חבילת המסד.

  • fix (WebApp): חיבור Google Drive מהוובאפ עובד שוב — קוד ה-state נשמר בשרת, וכל דחייה בחזרה מגוגל נרשמת. ה-state נשמר עד היום ב-session, שהוא cookie, וב-session קבוע Flask שולח את ה-cookie מחדש בכל תשובה. בלחיצה על ”חבר“ יצאה ברקע גם שמירת מצב העבודה (POST /api/ui_prefs מ-beforeunload ב-base.html), והתשובה שלה, עם ה-cookie שלפני הלחיצה, הגיעה אחרי ההפניה לגוגל (כך בלוגים של 4.10.2026). הדפדפן שמר את ה-cookie הישן, ה-state נמחק, והחזרה מגוגל נדחתה בלי שורה בלוג. עכשיו ה-state נשמר במסמך המשתמש (_OAUTH_STATE_FIELD ב-webapp/drive_auth.py): רק ה-hash שלו, לשימוש אחד, עם תוקף (_OAUTH_STATE_TTL), ונבדק מול המשתמש שב-session. כל דחייה נרשמת באירוע webapp_drive_callback_rejected עם reason, בלי state, ‏code או טוקנים, ושמירת טוקנים שנכשלה כבר לא מדווחת כחיבור מוצלח. ראו החיבור בוובאפ: קוד ה-state נשמר בשרת ו-Google Drive.

  • feat (Drive): לבוט ולוובאפ יש חיבור Drive נפרד — טוקנים, העדפות ומתזמן משלו. שני השירותים מתחברים עם OAuth client אחר, ו-refresh token עובד רק מול ה-client שהנפיק אותו, אבל עד היום הם קראו וכתבו את אותם שדות: מי שהתחבר אחרון דרס את החיבור של השני, והשני נכשל בשקט בגיבוי הבא, והמתזמן של הוובאפ הריץ גם תזמונים שהבוט כתב. עכשיו כל פונקציה שקוראת או כותבת את החיבור מקבלת owner כפרמטר חובה, והמיפוי לשדות נמצא במקום אחד, drive_owner.py. הבוט נשאר על השדות שהיו לו, והוובאפ — וגם הגיבוי האישי, שרץ רק בוובאפ — עובד על שדות חדשים. טסט מבני בודק שכל קריאה בריפו מעבירה owner. ראו חיבור נפרד לכל שירות (owner).

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

  • fix (Drive, בוט): ”✅ חיבור ל‑Drive הושלם“ רק כשהטוקנים באמת נשמרו. הבדיקה ברקע והכפתור ”🔄 בדוק חיבור“ לא בדקו את התוצאה של save_tokens, שמחזיר False בכשל מסד ולא זורק, והודיעו ”הושלם“ על חיבור שלא נשמר. בהדבקת קוד, תשובת שגיאה מגוגל (access_denied, expired_token) נשמרה כטוקנים ודווחה כהצלחה. עכשיו שלושת המסלולים עוברים ב-_save_auth_tokens, וכשל מוצג ככשל.

  • fix (WebApp, Drive): תזמון ו“גבה עכשיו“ נכתבים רק למשתמש מחובר, באותה כתיבה ולא בבדיקה שלפניה; וניתוק הוא כתיבה אחת. החיבור נבדק עד היום בקריאה נפרדת, וניתוק שנכנס בין הבדיקה לכתיבה השאיר תזמון בלי חיבור. עכשיו תנאי החיבור הוא חלק מהפילטר של העדכון (_connected_user_filter ב-webapp/drive_backup_api.py), ו“גבה עכשיו“ לא מסמן ”רץ“ ולא שולח לרקע כשלא נמצא משתמש מחובר. ניתוק מוחק את הטוקנים ומכבה את התזמון באותה כתיבה (delete_drive_tokens עם prefs), במקום שתי כתיבות שכשל ביניהן השאיר חצי ניתוק.

  • fix (Drive): העדפות נכתבות לפי מפתח, בלי לדרוס עדכון מקביל. save_drive_prefs קרא את כל ההעדפות, מיזג וכתב את כולן חזרה, ולכן כתיבה שקראה לפני עדכון אחר מחקה אותו — למשל תזמון שנקבע בזמן שגיבוי רץ. עכשיו כל מפתח נכתב בנתיב משלו (_drive_prefs_set_paths). מפתח עם נקודה, או שמתחיל ב-$ — גם בהעדפות ששוחזרו מגיבוי אישי — נדחה לפני הכתיבה, והשחזור מדווח שגיאה.

  • fix (Drive): שירות Drive שנבנה מטוקנים שהוחלפו לא מוחזר מהמטמון. _SERVICE_CACHE המשיך להחזיר אחרי חיבור מחדש את השירות שנבנה מהטוקנים הקודמים, עד שהרשומה פגה. עכשיו שירות מוחזר רק אם הוא עונה על הטוקנים שבמסד עכשיו (_credentials_fingerprint) — בדיקה בזמן הקריאה, ולא ביטול בזמן הכתיבה שקריאה מקבילה הייתה מחטיאה.

  • feat (observability, Drive): העלאה שנכשלה נרשמת עם הסיבה, וגיבוי של הוובאפ שלא הועלה נשלח כאירוע. upload_bytes ודומיו בולעים חריגות ומחזירים None, ולכן הסיבה לא הגיעה לשום לוג — גם לא ללוג שבקורא, שלא ראה חריגה. עכשיו כל העלאה שמחזירה None נרשמת בשורת drive_call_failed (_log_drive_call_failed), וכך גם תיקייה שלא נוצרה ושירות שלא נבנה: הפעולה, סוג החריגה, סטטוס ה-HTTP וקוד השגיאה של Drive, בלי הטקסט של החריגה — וגם בלי הודעת השגיאה של גוגל כשאין קוד. גיבוי של הוובאפ שלא הועלה נשלח כ-webapp_drive_backup_failed, ו-_fetch_google_email רושם תשובת שגיאה מגוגל עם הסטטוס שלה במקום לקרוא אותה כפרטי החשבון. אירועי ה-Drive של הבוט נוספו לקטלוג, והטסט שמשווה את הקטלוג לקוד סורק עכשיו גם את הבוט. ראו Google Drive.

  • fix (Drive, בוט): הבדיקה ברקע נעצרת כשגוגל סוגר את בקשת ההתחברות. כשהמשתמש סירב (access_denied) או שהבקשה פגה אצל גוגל, הבדיקה ברקע התעלמה מהתשובה והמשיכה לפנות לגוגל עד שתוקף הבקשה פג — ואז הודיעה ”פג תוקף“ על בקשה שהמשתמש סירב לה. לפי RFC 8628 §3.5, על כל קוד שגיאה של OAuth חוץ מ-authorization_pending ו-slow_down הלקוח מפסיק לבדוק. עכשיו הבדיקה נעצרת ומציגה את השגיאה (is_terminal_device_flow_error), ותשובת שגיאה בלי קוד של OAuth, כמו 503, לא עוצרת אותה. גם ”🔄 בדוק חיבור“ והדבקת הקוד סוגרים עכשיו את הבקשה על שגיאה כזו, והדבקת הקוד סוגרת אותה גם כשהטוקנים התקבלו (_close_auth_request). עד היום הם השאירו את הבדיקה ברקע מתוזמנת, והיא פנתה שוב לגוגל עם הקוד הסגור. ראו Drive Menu V2.

  • fix (Drive): טוקן שהתקבל מרענון כפוי נשמר. אחרי 401, _force_refresh_credentials רענן את הטוקן וחישב את התוקף מ-creds.expiry. ה-expiry של google-auth הוא UTC נאיבי, והחיסור ממנו של זמן מודע-אזור זרק TypeError שנבלע — כך שהטוקן החדש לא נשמר אף פעם, והשירות הבא נבנה שוב מהקודם. עכשיו שני מסלולי הרענון שומרים דרך _save_refreshed_credentials, שמתייג את התוקף ב-UTC, בודק את התוצאה של save_tokens ורושם שמירה שנכשלה בשורת drive_refresh_not_saved. והניסיון החוזר אחרי 401 מקבל את הטוקן המרוענן גם כשהשמירה נכשלה: השירות שלו נשמר במטמון עם הטביעה של הטוקנים שעדיין במסד. עד היום המטמון התרוקן, והניסיון החוזר טען מהמסד את הטוקן שגוגל דחה.

  • fix (WebApp): כשמונגו לא זמין, ”חבר ל-Drive“, התזמון ו“גבה עכשיו“ עונים בשגיאה המתוכננת. כשהמסד לא זמין בעלייה, DatabaseManager עובר למצב no-op, ושם התוצאה של update_one לא כללה את matched_count ואת upserted_id. הקוראים בודקים אותם כדי לדעת אם משהו נכתב, ונפלו ב-AttributeError — ב“חבר“ ובתזמון 500 לא מטופל, וב“גבה עכשיו“ שגיאה כללית. עכשיו תוצאות העדכון במצב הזה (_noop_update_result ב-database/manager.py) נושאות את כל התכונות של UpdateResult, וטסט משווה אותן לגרסה המותקנת.

  • perf (WebApp): אינדקס לסריקה של גיבויי ה-Drive. הסריקה רצה כל SCAN_INTERVAL_SECONDS על כל אוסף users בלי אינדקס. עכשיו users_webapp_drive_schedule על schedule_key ואחריו schedule_next_at; tests/test_webapp_drive_scan_index_mongo.py מוודא ב-explain מול מונגו אמיתי שהסריקה בוחרת בו.

  • chore (config): ``GOOGLE_TOKEN_REFRESH_MARGIN_SECS`` הוסר — אף קוד לא קרא אותו. הוא הוגדר ב-config.py, הוצג ב-Config Inspector ותועד, אבל רענון הטוקנים לא נשען עליו. ערך שעדיין מוגדר בסביבה לא מזיק (extra="ignore" ב-BotConfig). ו-DRIVE_MENU_V2 מסומן כדגל של הבוט, השירות היחיד שקורא אותו.

  • docs (Drive): זרימת הגיבוי ל-Drive נכתבה מחדש לפי הקוד. הסעיף ב-זרימת גיבוי ושחזור (Backup Flow) תיאר פונקציות שאינן קיימות, ואמר שבשגיאת Drive הגיבוי נשמר מקומית — וזה לא קורה. עכשיו הוא מתאר את הבוט ואת הוובאפ כפי שהם, ו-Integrations מתאר את שני החיבורים במקום דוגמה גנרית.

2026-10-04

  • ci: coverage נמדד רק במסלולי 3.11 של ``unit-tests``. הוא הוסיף לטסטים של 3.12 כ-30% מהזמן שלהם (הערכה: מדידה מקומית עם coverage ובלעדיו, על זמני הטסטים מדוחות unit-durations-* של ריצת ci.yml מ-4.10), ובאותה ריצה התוצאות של 3.11 ושל 3.12 היו זהות, טסט מול טסט. עכשיו רשומת include במטריצה מוסיפה coverage: true לגרסה אחת, והדגלים --cov וההעלאה ל-Codecov תלויים בה. הגרסה היא 3.11, זו שהפרודקשן רץ עליה (Dockerfile). שמות הסטטוסים לא השתנו. tests/test_required_checks_are_listed.py פורש עכשיו את include לפי הכלל של GitHub, ובודק שלכל מסלול יש גרסה שמודדת coverage ושהדגלים וההעלאה תלויים במפתח הזה, כי Codecov אינו בדיקת חובה, וכיסוי שנעלם לא היה מפיל דבר. ראו CI/CD Guide.

  • tests: השהיות של קוד הייצור מתאפסות פעם אחת לכל הטסטים, ב-``tests/conftest.py``. apply_rate_limit_delay ממתינה בין קריאות ל-GitHub, וטסטי הורדת ה-ZIP עברו בה באמת: כ-98 שניות של המתנה בכל מסלול Unit Tests, לפי דוחות unit-durations-* של ריצת ci.yml מ-4.10. שני קבצים אחרים כבר נטרלו אותה, כל אחד לעצמו, והקבצים האלה לא. עכשיו tests/conftest.py מאפס את GITHUB_API_BASE_DELAY ואת GITHUB_BACKOFF_DELAY, והנטרולים הידניים נמחקו. אליו עברו גם ערכי ה-retry וה-backoff שהיו ב-env של ci.yml (HTTP_RESILIENCE_*, REQUESTS_RETRIES, REQUESTS_RETRY_BACKOFF, AIOHTTP_TIMEOUT_TOTAL), כך שהם חלים עכשיו גם על deploy.yml ועל הרצה מקומית. ההמתנה גם הסתירה שני טסטים, וזה נמדד במוטציות: test_backup_id_is_unique_within_the_same_second לא הגיע אף פעם לשתי אריזות באותה שנייה, ועבר גם בלי הסיומת האקראית של המזהה. ו-test_apply_rate_limit_delay_respects_backoff עבר גם כשה-backoff לא הופעל, כי ההשהיה הבסיסית הייתה ארוכה ממנו. עכשיו הראשון בודק את מה שהוא מבטיח, השני קובע את ההשהיה הבסיסית בעצמו, וטסט חדש עובר דרך ההמתנה הבסיסית האמיתית, בערך קטן שהוא קובע. ומשטסט ה-backoff התחיל לבדוק באמת, הוא נכשל ב-CI לפי סדר הריצה: test_telegram_retry_after_and_message_not_modified הוציא את github_menu_handler מ-sys.modules וייבא אותו מחדש בלי להחזיר את המודול הקודם, וטסט ה-backoff, שרץ אחריו באותו תהליך, שינה את מצב ה-backoff במודול שהקוד שרץ לא קורא ממנו. עכשיו monkeypatch.delitem מחזיר את המודול בסוף הטסט, וטסט ה-backoff בונה את GitHubMenuHandler מאותו מודול שהוא משנה. ובאותו סבב, tests/conftest.py קובע את ערכי ההשהיה בהשמה ולא ב-setdefault, כדי שערך שהמעטפת מייצאת לא יחזיר את ההמתנה. ובריצה אחרת של ה-CI נכשלו לפי סדר הריצה טסטים של log_user_activity, מאותה משפחה: tests/test_user_stats_unit.py עשה importlib.reload ל-user_stats, וה-reload בנה מופע חדש של user_stats.user_stats בזמן ש-main.py ממשיך להחזיק את הקודם, ולכן טסט שהחליף את log_user במופע החדש לא הגיע לקוד של main. ה-reload היה מיותר, כי user_stats מייבא את ה-facade בכל קריאה, והוא הוסר. ראו Testing Guide.

  • ci: טסטי ה-Markdown הכבדים רצים במסלול נפרד, במקביל לשאר טסטי היחידה. בחודש שעבר זמן הטסטים ב-CI עלה מכשלוש דקות וחצי לכשבע וחצי (שלב ה-pytest בג’וב של 3.12, לפי דוחות unit-durations-* של ריצות ci.yml מ-9.9 ומ-4.10). הטסטים שהיו קיימים לא הואטו בסך הכול; את התוספת הביאו טסטים חדשים, ואת החלק הגדול שלה מעט טסטים כבדים. ביניהם טסטי פרסר ה-Markdown שעיקר העבודה שלהם הוא החישוב עצמו: השוואה לאורקל cmark-gfm, קלט ענק בתקרות של הפרסר, והטסטים של סקריפטי המדידה. הם מסומנים עכשיו md_heavy (הרישום ב-pytest.ini), והג’וב unit-tests ב-.github/workflows/ci.yml רץ בשני מסלולים לכל גרסת פייתון: Unit Tests מריץ את כל השאר, ו-Unit Tests md-heavy מריץ רק אותם, במקביל ובלי MongoDB ו-Redis שהוא אינו צריך. כל מסלול מדווח סטטוס חובה משלו. את שני הסטטוסים החדשים צריך לסמן כבדיקות חובה בהגדרות של GitHub, ועד שזה נעשה כשל בהם מופיע ב-PR אך אינו חוסם מיזוג. ושמות הסטטוסים, שכתובים ביד בכמה קבצים, נבדקים עכשיו מול המטריצה ב-tests/test_required_checks_are_listed.py — והוא נכשל גם כשעותק של הרשימה מופיע בקובץ שהוא לא מכיר. Testing Guide ו-Branch Protection & PR Rules מפנים עכשיו לרשימה שב-CI/CD Guide במקום להחזיק עותק משלהם.

  • fix (שירות ה-MCP): ריפו שהוסר בממשק נמחק גם מהדיסק של שירות ה-MCP. הסרת ריפו בוובאפ מחקה את המראה שבדיסק של הוובאפ ואת הרשומות ב-repo_metadata, אבל לדיסק של שירות ה-MCP אף אחד לא נגע: המראה שם נשארה, וכלי הקריאה המשיכו להגיש אותה כאילו כלום לא קרה (כך קרה ל-codekeeper-plugin). עכשיו בסוף כל מעבר של ה-autosync, כל מראה בדיסק של השירות שאין לה רשומה ב-repo_metadata נמחקת, דרך delete_mirror. שום דבר לא נמחק כשהשאילתה נכשלה, או כשאף שם ב-repo_metadata אינו שם של מראה שבדיסק (כולל קריאה ריקה). כשיש בדיסק מראות שנחסכו כך, נרשמת אזהרה. וגם לא נמחקים תיקייה שאינה מראה שהשירות יוצר (שם לא תקין, קישור סמלי) או ריפו שנמצא באמצע clone או fetch. מחיקה שנכשלה, או תיקיית מראות שאי אפשר לקרוא, נספרות ב-errors, והמראה נשארת עד המעבר הבא. הקריאה של repo_metadata נעשית מה-primary במפורש. בשורת הלוג repo autosync pass: נוסף המונה pruned. ובאותה מנייה של המראות, גם ניקוי ה-credentials בעלייה מדווח עכשיו על תיקיית מראות שאי אפשר לקרוא ככשל, ולא כ-checked=0 failed=0. ראו רענון אוטומטי (autosync).

  • fix (מראות): טוקן ה-GitHub לא נשמר יותר בקובץ ה-config של המראות, ולא עובר בשורת הפקודה (#3480); וזיהוי הענף הראשי בייבוא ריפו (#3479). עד עכשיו init_mirror שכפל מ-URL שהטוקן בתוכו, ו-git שמר אותו בטקסט גלוי ב-remote.origin.url — על הדיסקים של הוובאפ ושל שירות ה-MCP, ובצילומים היומיים של Render; הוא גם הופיע בשורת הפקודה של git-remote-http בכל clone ו-fetch. עכשיו ה-URL השמור נקי, והטוקן עובר ככותרת דרך משתני סביבה של git, ורק לריפו שדורש הזדהות — ריפו ציבורי לא מקבל טוקן. מראות קיימות מנוקות לפני כל fetch ובעליית כל שירות, עם שורת לוג אחת שסופרת מה נמצא ומה נוקה, ואומרת לכל מראה מאיפה הטוקן שלה (map/global). fetch על מראה שלא אומת שהיא נקייה לא רץ (mirror_url_not_clean). ובנפרד: initial_import ניסה לזהות את הענף הראשי בפקודות ש-_run_git_command דוחה, ולכן תמיד נפל ל-main — וריפו שהענף הראשי שלו master לא יובא. עכשיו הזיהוי הוא מ-HEAD של המראה, וכשאין ענף מאומת מוחזר default_branch_undetected במקום ניחוש. ראו אימות מול GitHub — הטוקן לא נשמר במראה.

  • לפריסה של התיקון הזה: הניקוי מוציא את הטוקן מהדיסק, אבל צילומי הדיסק של Render שנלקחו לפניו נשמרים לפחות שבעה ימים ועדיין מחזיקים אותו — החלפת הטוקן היא ההחלטה שסוגרת גם אותם. ו-rollback לקוד שלפני התיקון אינו מחזיר את הטוקן למראות שכבר נוקו, ולכן ה-fetch שלהן לריפו פרטי ייכשל באימות; מראה כזו מתקנים במחיקה ושכפול מחדש.

  • fix (MCP): ``codekeeper_note_str_replace`` מודד את התוצאה לפני שהוא בונה אותה (#3495). עד היום הכלי בנה את גוף הפתק החדש ורק אז השווה אותו ל-MAX_NOTE_CHARS, ולכן replace_all על מחרוזת קצרה עם new_string ארוך בנה בזיכרון מחרוזת באורך מספר המופעים כפול אורך ההחלפה לפני שנדחה: פתק של 2,000 "a" והחלפה של 10,000 תווים — 20 מיליון תווים, שיא הקצאה של 20,019,845 בתים על בקשה של 10,097 בתים (נמדד ב-test_a_note_replace_all_is_checked_before_its_result_is_built על הקוד שלפני התיקון). בתקרות של הייצור — פתק של MAX_NOTE_CHARS תווים, ו-new_string שנכנס בגוף בקשה של 2MiB (התקרה ש-request_bytes_for גוזר מ-MAX_CODE_SIZE של 300,000) — זה כ-40GB לפני הסירוב: בקשה אחת שמפילה את תהליך ה-MCP לכל המשתמשים, ותקרת הגוף והגבלת הקצב אינן עוזרות, כי הן חוסמות כל גורם לבדו ולא את המכפלה. עכשיו הכלי עובר באותה בדיקה מוקדמת של codekeeper_edit_file (_apply_edit ב-mcp_server/handlers.py), והתשובה על תוצאה ארוכה מדי שאינה רווחים בלבד היא אותה תשובה — content_too_long עם max — רק לפני ההקצאה: אותו מקרה נגמר בשיא של כ-23KB, וכך גם פתק מלא עד התקרה. max_size של _apply_edit הפך לחובה, בלי ברירת מחדל, כדי שכלי הבא שיחליף טקסט דרכו לא יוכל לשכוח אותו. שינוי בקצה: תוצאה של רווחים בלבד שארוכה מהתקרה מחזירה עכשיו content_too_long ולא empty_content — שני הסירובים אינם כותבים דבר. ראו כמה עריכות בגרסה אחת — codekeeper_multi_edit_file.

  • ci (MyPy): קריאה שחסר בה ארגומנט חובה עוצרת את ה-CI — ``call-arg`` נוסף לשער. המעבר הרחב של mypy ב-.github/workflows/ci.yml נכשל עד היום רק על attr-defined ו-return-value. call-arg — ארגומנט חובה שחסר, או ארגומנט שאינו קיים — הודפס ביומן ולא עצר דבר, ובפייתון זו שגיאה שמתגלה רק כשהקריאה רצה: אתר קריאה בלי טסט נופל בייצור. עכשיו הוא חוסם, וזה מה שהופך את max_size החובה של _apply_edit לבדיקה סטטית — נבדק ש-note_str_replace בלי max_size מפיל את השער, ושעם השער הקודם אותו קוד עבר. המופע היחיד שהיה בריפו (mypy 2.4.0) — מחלקה מקומית בשם _Ctx שהוגדרה פעמיים ב-setup_bot_data ב-main.py — קיבל שם משלו, _CtxPredictive.

2026-10-01

  • fix (MCP): העלאה שהשתבשה באחסון הזמני אינה נשמרת — ``upload_corrupted``; ותיאור ``upload_id`` ב-``codekeeper_append_file`` אומר מה ה-hash מוכיח בהוספה. content_changed משווה את הטקסט שנשלף מ-mcp_uploads למה שנכתב לקובץ, ולכן טקסט שהשתבש בין ההעלאה לשמירה היה נשמר בשקט, עם content_changed: false. עכשיו _load_upload — העוזר שכל כלי שמקבל upload_id שולף דרכו — משווה מיד אחרי השליפה, לפני כל בדיקה אחרת של הכלי, את ה-hash של הטקסט שנשלף ל-content_sha256 שנשמר עם ההעלאה כשהגיעה. שונים, או שמה שנשמר אינו hash: upload_corrupted, גם כשבדיקה אחרת — התקרה, file_exists — הייתה נכשלת. שום דבר לא נכתב, ההעלאה נמחקת (ואם האחסון לא ענה למחיקה, היא פוקעת ב-TTL; התשובה אינה תלויה בזה), ונרשמת שורת ERROR אחת בלי המזהה ובלי התוכן. שומר מבני בטסטים מוודא שאין דרך שליפה או צריכה אחרת, לא בכלי ולא ב-backend. ובנפרד: תיאור הפרמטר upload_id היה משותף לשני הכלים והבטיח גם בהוספה ש-file.content_sha256 יהיה שווה ל-hash של ההעלאה. בהוספה file.content_sha256 הוא של הקובץ כולו, ומה שמראה שהטקסט נכנס בשלמותו הוא content_changed: false — וסוכן שבודק לפי התיאור הישן היה מסיק שההוספה נכשלה, מעלה שוב, ומוסיף את הטקסט פעמיים. עכשיו לכל כלי המשפט שלו, וטסט בודק כל משפט מול מה שהכלי מחזיר. ראו העלאת תוכן בלי לעבור דרך המודל.

2026-09-30

  • fix (tests): טסט הטפטוף של ``PUT /api/agent/upload`` נפל רק בריצה של ``deploy.yml`` — Sentry אמיתי נדלק בתוך תהליך הבדיקות. tests/test_db_sentry_checks.py ו-tests/test_chatops_stage7.py כתבו את SENTRY_DSN ישירות ל-os.environ, והראשון ”ניקה“ אותו ב-monkeypatch.delenv — שזוכר את הערך שמצא ומחזיר אותו בסוף הבדיקה — כך שהכתובת נשארה לכל הריצה. כל בדיקה שטוענת מחדש את main הדליקה ממנה Sentry אמיתי (main.py קורא ל-init_sentry() ברמת המודול, #3512), ואינטגרציית ה-Starlette שלו קוראת את גוף הבקשה לפני ה-route ובלי דדליין (#3513) — ולכן הטסט שבודק את הדדליין של ה-route נתקע, והשגיאה הופיעה ב-authenticate_bearer, רחוק משתי הבדיקות שגרמו לה. עכשיו tests/_sentry_isolation.py, שנרשם מ-tests/conftest.py לכל הריצה, מסיר את SENTRY_DSN בתחילתה, ואחרי כל בדיקה מחזיר למצב נקי ומכשיל בשמה בדיקה שהשאירה SENTRY_DSN בסביבה או לקוח Sentry חי; שתי הבדיקות הדולפות עברו ל-monkeypatch.setenv. דליפה של משתני סביבה אחרים בין בדיקות — #3511. ראו Testing Guide.

  • feat (MCP): העלאת תוכן ארוך בלי לעבור דרך המודל — ``PUT /api/agent/upload`` ו-``upload_id``. סוכן שכבר מחזיק את התוכן כקובץ מקומי — דוח, ניתוח, handoff — קרא עד היום את כל הקובץ להקשר וכתב את כולו שוב בתוך קריאת הכלי: פעמיים אותם בתים, ובמסמך ארוך סיכון לקיטוע או לסחיפה בהעתקה. עכשיו הוא מעלה אותו ב-curl אחד עם ה-PAT שכבר בסביבה שלו, ומעביר ל-codekeeper_save_file / codekeeper_append_file רק את upload_id. הראוט דורש טוקן תקין ולא write — הכתיבה עצמה נשארת קריאת כלי — חולק את מכסת הקצב של הכלים, מחזיק עד חמש העלאות ממתינות למשתמש לעשר דקות, ומסרב בלי אינדקס TTL מאומת. ההעלאה חד-פעמית: הכלי מוחק אותה לפני שהוא שומר, ולכן שתי צריכות של אותו מזהה אינן יכולות לשמור שתיהן, והוספה שנשלחה שוב אינה מכפילה את הטקסט. היא אינה מעלה את תקרת התוכן. ה-hash המקומי, content_sha256 בתשובת ההעלאה ו-file.content_sha256 אחרי השמירה — אחד. הפקודה בתיאור נוקבת ב-host מ-MCP_SERVER_URL; ערך שהוגדר ונדחה מקבל <mcp-host> ושורת WARNING בעלייה, בלי הכתובת עצמה. ראו העלאת תוכן בלי לעבור דרך המודל.

  • refactor (MCP): מנוע אינדקסי האכיפה בשם שאינו ”של פתקים“, ובדיקת TTL אחת לכל מפרט. _NoteIndex ← _EnforcedIndex ו-_ensure_note_index ← _ensure_enforced_index, כי גם ההעלאות נשענות עליו; כל אינדקס נושא עכשיו גם את מה שקורה כל עוד הוא לא אומת, במקום הודעה אחת (”falling back to a code check“) שנרשמה גם על גרסאות הפתקים, שבהן הצילום פשוט נדחה. והבדיקה ש-/admin/verify-indexes מריץ על ה-TTL של סל המיחזור עברה ל-ttl_index.is_ttl_index, שמשרת עכשיו גם את ה-TTL של ההעלאות — בלי שינוי התנהגות בסל.

  • fix (hooks): הפריימר נטען גם כשסשן נפתח באמצע דיפלוי — retry ב-``.claude/hooks/codekeeper-primer.sh`` (v2). לשירות ה-MCP מחובר דיסק, ולכן בכל דיפלוי יש חלון של עד כדקה שבו Render מחזיר 502. עד היום ההוק ניסה פעם אחת, וסשן שנפתח בחלון הזה התחיל בלי הוראות. עכשיו הוא מנסה שוב על 502, 503 ו-504 ועל כשל רשת זמני — לפי קוד היציאה של curl, ולא לפי ה-000 שבא איתו — במרווח קבוע ובתקציב כולל, ולא על שום דבר אחר: 500 הוא באג ולא דיפלוי. ה-timeout של ההוק ב-.claude/settings.json עלה כך שהמקרה הגרוע, התקציב ועוד בקשה אחת, נגמר לפניו — הוק שנחתך נזרק בשתיקה — והחשבון נבדק בטסט מול settings.json. stdout נשאר נקי: בהצלחה הפריימר בלבד, ובכשל שורה אחת שאומרת מה חזר, בכמה ניסיונות ובכמה זמן, ומבדילה בין דיפלוי לבין בעיה בסביבה. הניסיונות עצמם נרשמים ללוג הפרטי. ראו פריימר לסוכן — GET /api/agent/primer.

  • fix (hooks): ``200`` שאינו ``text/plain`` לא נכנס להקשר, ו-``200`` ריק אינו שתיקה. עד היום כל 200 הודפס כמו שהוא — כולל HTML של עמוד שגיאה, של host שגוי או של שירות מושהה, שהיה נקרא על ידי המודל כהוראות. עכשיו ההוק בודק את סוג המדיה, בלי תלות ברישיות, ומדפיס שורת אבחון במקום הגוף; וגוף ריק, או שכולו רווחים, מקבל שורת אבחון במקום שתיקה. 403 מקבל את אותה הודעה על ה-PAT כמו 401.

  • fix (hooks): שורת האבחון לא מעתיקה את הכתובת להקשר, וחצי פריימר לא נכנס להקשר. שורת ה-404 הדפיסה את CODEKEEPER_PRIMER_URL כמו שהוא, ולכן סוד בשורת השאילתה או סיסמה ב-userinfo נכנסו להקשר של המודל (נמדד); עכשיו היא נוקבת בשם המשתנה בלבד. והגוף נקרא במלואו לזיכרון לפני שמשהו ממנו מודפס: cat שנכשל באמצע השאיר עד היום חצי פריימר בלי שורת אבחון. הקריאה לזיכרון משמיטה תווי NUL, ולכן גוף שיש בו NUL, שאינו טקסט ממילא, נדחה במפורש. נמצא בריוויו של ה-PR.

  • docs (MCP): כתובת הדוגמה של הפריימר היא של השירות הנוכחי, ``codekeepermcp.onrender.com``. הכתובת שהייתה בעמוד מחזירה 404 גם ב-/healthz (נבדק ב-2026-09-30).

2026-09-29

  • feat (MCP): ``codekeeper_multi_edit_file`` — כמה עריכות בקובץ אחד, בגרסה אחת. עדכון אחד שנוגע בכמה מקומות בקובץ נעשה עד היום בכמה קריאות ל-codekeeper_edit_file: גרסה, התראה והזדקנות של התיאור לכל אחת, וכשאחת נכשלה באמצע — קובץ מעודכן בחלקו. הכלי החדש מקבל רשימת זוגות (old_string, new_string, replace_all), מחיל אותם לפי הסדר, כל זוג על התוצאה של קודמו, ושומר גרסה אחת — הכל או כלום. זוג שנכשל מחזיר את הקוד של codekeeper_edit_file ואת ה-index שלו, וב-no_match וב-ambiguous_match גם occurrences ו-occurrences_in_stored_version, שמראים מתי זוג קודם שינה את הטקסט שהזוג הזה מחפש. זוג פגום נדחה ב-invalid_edit בלי להדהד את הערך, ורשימה מעל MAX_EDIT_PAIRS נדחית ב-too_many_edits ולא נחתכת — שניהם לפני שהקובץ נקרא מהמסד. במכסת הקצב הקריאה שוקלת 1. ראו כמה עריכות בגרסה אחת — codekeeper_multi_edit_file.

  • feat (MCP): ``expected_content_sha256`` בכלי העריכה — עריכה על מה שקראתם. codekeeper_edit_file, codekeeper_multi_edit_file ו-codekeeper_append_file מקבלים את ה-file.content_sha256 שהסוכן קרא, ומסרבים ב-conflict, בלי לכתוב, אם הקובץ השתנה מאז — עם file של הגרסה הנוכחית, בלי התוכן. hash ולא מספר גרסה, כי check_file_sync כותב תוכן במקום בלי להעלות גרסה. ערך שאינו hash נענה ב-invalid_expected_content_sha256 ולא ב-conflict, ובלי הפרמטר אין בדיקה, כמו קודם. הבדיקה מצמצמת את החלון מול כתיבה מהוובאפ או מהבוט, ואינה סוגרת אותו — ראו עריכה על מה שקראתם — expected_content_sha256.

  • fix (MCP): עריכה שהתוצאה שלה גדולה מ-``MAX_CODE_SIZE`` נדחית לפני שהתוצאה נבנית. עד היום codekeeper_edit_file בנה את הקובץ החדש ורק אז מדד אותו, ולכן replace_all עם new_string ארוך בנה בזיכרון מחרוזת גדולה פי כמה מהתקרה לפני שנדחה. בבאץ« של עריכות זה היה מתעצם: זוג שמחליף את "a" ב-"aa" עם replace_all כופל את הטקסט בכל פעם שהוא חוזר. עכשיו אורך התוצאה מחושב מראש (_apply_edit ב-mcp_server/handlers.py), והסירוב — אותו code_too_large עם max — מגיע לפני ההקצאה.

  • docs (MCP): בלוק ה-``instructions`` מזכיר את ``codekeeper_multi_edit_file``, ובשביל המקום ירדה משורת החיפוש הדוגמה ``handof``/``handoff`` — היא כתובה גם בתיאור של codekeeper_search_code, והבלוק חייב להישאר בתוך CLIENT_INSTRUCTIONS_MAX_CHARS.

  • feat (MCP): כל כלי קריאה מצהיר על תקרת התשובה שלו, ועומד בה (#3460). Claude Code שומר לקובץ תשובת כלי מעל 25,000 טוקנים, חוץ מכלי שהצהיר ב-tools/list על _meta["anthropic/maxResultSizeChars"] — ועד היום רק codekeeper_read_batch הצהיר, ולכן קובץ עברי של 52,158 תווים הגיע לסוכן כקובץ. עכשיו מצהירים codekeeper_get_file, codekeeper_get_repo_file, codekeeper_search_repo, codekeeper_list_repo_tree, codekeeper_list_notes, codekeeper_list_board_notes, codekeeper_docs_get_section ו-codekeeper_read_batch, כולם על OUTPUT_BYTE_BUDGET — בתים של הטקסט כפי שהוא נשלח, שהם חסם עליון על התווים שהלקוח סופר. ההצהרה היא חלק מהרישום של הכלי (answer_size.declared_size_meta), והמדידה כולה עברה למודול אחד בלי תלויות, mcp_server/answer_size.py. וכל כלי עומד בתקרה בעצמו — שינויי התנהגות, בכוונה: קריאה מלאה גדולה מהתקציב היא answer_too_large עם הפניה ל-lines/query/toc/outline (על main קריאה מלאה של 300,000 תווים עבריים יצאה 547,927 בתים); טווח lines גדול ממנו נגמר מוקדם על גבול שורה, עם range.truncation_reason: "byte_budget", וממשיכים מ-end + 1; רשימת פתקים מלאה גדולה ממנו היא answer_too_large שמפנה ל-include_content=false — ולא רשימה חתוכה, כי לכלי הרשימה אין עימוד; והאאוטליין והחיפוש בריפו נמדדים על התשובה כולה כפי שהיא נשלחת (על main עמוד נמדד 247,684 בתים ויצא 261,992, וחיפוש נמדד 248,234 ויצא 374,931). ורשת אחרונה ב-AdminAwareFastMCP.call_tool מסרבת לתשובה שעוברת את מה שהכלי הצהיר, בשני הענפים, ורושמת answer_size_net בלוג — תפיסה שלה היא באג בכלי. codekeeper_list_repo_notes אינו מצהיר, בכוונה: 20 פתקים של 20,000 תווים הם יותר מהתקציב, ואין לו מצב רזה. ראו תקרת התשובה — מה כלי מצהיר, ומי אוכף.

  • fix (MCP): ``query`` של ``codekeeper_get_file`` נכנס בתקציב כפי שהוא נשלח, ואומר למה נעצר (#3474). הרשומות נמדדו ב-JSON דחוס מול התקציב כולו, בלי המעטפת ובלי ההזחה, ותשובה שנמדדה בתוכו יצאה 259,168 בתים. עכשיו המעטפת שמורה במקרה הגרוע שלה, כל רשומה נמדדת כפי שהיא יושבת ברשימה, ו-truncation_reason — max_results או byte_budget — מצטרף ל-truncated. QUERY_OUTPUT_BYTE_BUDGET נמחק: הוא היה עותק של OUTPUT_BYTE_BUDGET רק בגלל ייבוא מעגלי, ושני החיפושים מייבאים אותו עכשיו מ-answer_size.

  • fix (MCP): עמוד של ``codekeeper_list_repo_tree`` שאינו נכנס בתקציב נדחה כולו — ``page_too_large`` — ולא נחתך באמצע (#3481). העימוד אריתמטי, ולכן עמוד שנחתך באמצע איבד את הנתיבים שבין נקודת החיתוך לסוף העמוד: העמוד הבא התחיל אחרי per_page המלא. עכשיו התשובה כולה נמדדת כפי שהיא נשלחת, ועמוד שאינו נכנס מקבל את אותה תשובה כמו באאוטליין. truncated נשאר בתשובה, תמיד false.

  • fix (MCP): סירוב על קובץ שמור מוותר על תיאור ענק — שלם, עם ``file.description_bytes`` במקומו. עד היום סירוב ויתר רק על התגיות, ותיאור של 200,000 תווים עבריים הביא את הסירוב עצמו ל-400,523 בתים — מעל התקציב, בדיוק כשהקורא הכי צריך תשובה קריאה. התיאור אינו נחתך באמצע, כי תיאור חתוך נקרא כתיאור שלם; description_bytes מופיע רק כשהתיאור ירד. השורש — כותבים שאינם אוכפים תקרה על התיאור ועל התגיות — נשאר ב-#3489.

  • fix (MCP): תיאור ענק אינו נועל קובץ שמור — הוא יורד גם מתשובה מוצלחת, עם הפניה לכלי שמתקן אותו. ריוויו Han על אותו PR מצא שתיאור של 200,000 תווים נעל את הקובץ בכל צורה של codekeeper_get_file: קריאה מלאה, lines, query ו-toc נדחו כולם ב-answer_too_large, וההפניות הובילו זו לזו (lines ← query ← lines). עכשיו, כשהתגיות או התיאור הם מה שעומד בין התשובה לתקציב, התשובה חוזרת בלעדיהם, עם file.tags_truncated/file.description_bytes; וכל תשובה שהתיאור ירד ממנה — מוצלחת או סירוב — מפנה ב-hint ל-codekeeper_update_file_description. תשובה שנכנסת כמו שהיא לא משתנה, וגם קריאת המשך של קובץ גדול עם תיאור קצר. באותו ריוויו: קריאה מלאה מסתעפת לפי lines שנשלח ולא לפי שדה range במסמך השמור (מסמך עם שדה כזה קרס ב-KeyError), ו-page_too_large של העץ נושא hint.

  • שינוי התנהגות (MCP): לקוח שאינו Claude Code מקבל סירוב עם הפניה במקום תשובה של מאות קילובייטים. ההצהרה ב-tools/list מיועדת ל-Claude Code, אבל התקציב נאכף על כל לקוח: קריאה מלאה של קובץ מעל OUTPUT_BYTE_BUDGET היא answer_too_large עם הפניה ל-lines/query/toc, גם ב-claude.ai. זה מכוון — תשובה כזו לא הייתה שמישה גם שם, והסירוב אומר מה לעשות — ונשען על כך שמטא-דאטה לבדה כבר אינה סיבה לסירוב (הסעיף הקודם).

  • feat (MCP): כל חיתוך או סירוב של תקציב התשובה נרשם בלוג — ``answer_size_fit``, ברמת INFO. שם הכלי, שמות הארגומנטים והמספרים, בלי אף ערך — ורק מה שהלקוח קיבל: חיתוך בתשובה שנזרקה (פריט באץ« שעבר ל-unread, תשובה שהרשת החליפה) אינו נרשם. כך אפשר לראות אם OUTPUT_BYTE_BUDGET צר מדי לתהליך נפוץ, במקום לשמוע על זה מסוכנים. המודול mcp_server/answer_fit.py מרכז את מה שעושים כשתשובה אינה נכנסת — ליבת הסירוב, השגרה האחת של קריאת קובץ, טווח השורות והחיתוך — שעד הריוויו נכתבו בכמה עותקים שכבר התפצלו. ראו תקרת התשובה — מה כלי מצהיר, ומי אוכף.

  • feat (MCP): בלוק ה-``instructions`` נכתב מחדש, נכנס בתקרה של הלקוח, ויש עליו שומר. הבלוק שהשרת מחזיר ב-initialize לא הזכיר 17 מתוך 32 הכלים — codekeeper_docs_get_section, codekeeper_read_batch, כלי הריפואים, פתקי הריפו, האוספים וההיסטוריה של הפתקים — ועם טעינת כלים מושהית כלי שאינו בבלוק כמעט לא מתגלה. עכשיו הבלוק מקובץ לפי משימות, נוקב בכל הכלים, ונכנס כולו ב-CLIENT_INSTRUCTIONS_MAX_CHARS: Claude Code מעביר לסוכן רק את 2,048 התווים הראשונים של הבלוק (code.claude.com/docs/en/mcp), וטיוטה ארוכה יותר נחתכה אצלו באמצע המשפט על not idempotent. רשימת הריפואים שכלי התיעוד מגיש, תקרת הבאץ« והמשפט על get_more_tools נגזרים מהשרת שנבנה — המשפט רק כשעטיפת PostHog על tools/list באמת הותקנה, כי instrument() בולע כשל ומחזיר ידית ריקה. tests/test_mcp_instructions.py משווה את השמות שבתוך התקרה ל-tools/list של אדמין בתצורת הייצור, ובלוק ארוך מהתקרה מדווח בעלייה ב-WARNING עם שמות הכלים שנפלו. גם המשפט הראשון של codekeeper_get_file, codekeeper_search_code, codekeeper_get_repo_file ו-codekeeper_list_repo_tree נוסח מחדש, כי זה החלק מהתיאור שלקוח עם טעינה מושהית מציג. ראו שרת ה-MCP — חיבור Claude ל-CodeKeeper.

  • fix (MCP): מחרוזת שנראית כמו JSON מגיעה לכלי כמחרוזת (#3471). לפני הוולידציה ה-SDK של mcp מריץ pre_parse_json: כל מחרוזת שנשלחת לפרמטר שאינו מוצהר str בדיוק עוברת json.loads, ומה שיוצא ממנה — None, רשימה או מילון — מחליף אותה (נמדד על mcp 1.28.1). בפרמטרים מסוג ”מחרוזת או null“ זה היה באג שקט: "null" נהיה ”לא נשלח“, ולכן codekeeper_get_file עם query="null" או section="null" החזיר את הקובץ המלא, codekeeper_docs_get_section עם section="null" החזיר את מפת הכותרות, קובץ ששמו null לא נמצא לפי שם, ופתק שהגוף שלו null נענה no_fields_to_update. "[1, 2]" ו-'{"a": 1}' נדחו בוולידציה כ“לא מחרוזת“, ולכן חיפוש מילולי שלהם בקובץ JSON שמור לא היה אפשרי. עכשיו AdminAwareFastMCP.add_tool מוציא מהפענוח כל פרמטר שה-annotation שלו כולל str — לבד, או לצד None, מספר או בוליאני — והמחרוזת מגיעה לכלי כמו שנשלחה; כך בכל הפרמטרים שברשימה של #3471, בכלי קריאה ובכלי כתיבה. פרמטר בלי str — lines, items של codekeeper_read_batch — ממשיך להיות מפוענח כמו קודם, כי Claude Desktop שולח רשימות כמחרוזות JSON. ולמפתחים — כלל חדש ברישום: פרמטר שבו str יושב לצד רשימה, מילון, tuple, set או מודל, פרמטר Any, או צורה שהכלל אינו מכיר (Literal, Enum וכדומה) — הרישום נכשל ב-TypeError שנוקב בכלי, בפרמטר ובסיבה, כמו כלי כתיבה אסינכרוני. אין כזה היום; מי שיוסיף מכריע אז, עם טסט. tests/test_mcp_pre_parse_json.py עובר על כל הכלים הרשומים ולא על רשימה, ורץ פעם אחת גם עם אינסטרומנטציית PostHog דלוקה, בסכימות של הייצור. השורות שתיעדו את ההתנהגות הישנה נמחקו מ-קריאה לפי סעיף בקובץ Markdown שמור (toc ו-section) ומטבלת פתרון תקלות. מאותה משפחה ולא מתוקן כאן: ארגומנט ששמו אינו בסכימה (למשל secton) עדיין נזרק בשקט — #3484.

  • docs (MCP): מ-claude.ai ומ-Claude Code, ``“null“`` עדיין מגיע כ“לא נשלח“ — והפעם בגלל הלקוח. נמדד אחרי ש-#3485 עלה לייצור (2026-09-29, claude-code 2.1.284 ו-Anthropic/ClaudeAI 1.0.0): בפרמטר שהסכימה שלו מתירה null, הלקוח ממיר את המילה null ל-null של JSON עוד לפני שהבקשה יוצאת. לכן מהלקוחות האלה query="null" ו-section="null" עדיין מחזירים את הקובץ המלא, וקובץ ששמו null אינו נמצא לפי file_name — והשרת אינו יכול להבחין. "[1, 2]" ו-'{"a": 1}' יוצאים כמחרוזות ועובדים, ובפרמטר שהסכימה שלו string בלבד גם null יוצא כמחרוזת. איך נמדד: ב-Claude Code — ה-input של קריאת הכלי כפי שנרשם בתמליל ({"query": null}); ובשני הלקוחות — ck_read_mode ב-PostHog, שנגזר מהארגומנטים כמו שהגיעו לשרת (מצב הקריאה (ck_read_mode)): query שהגיע כמחרוזת מתויג query, ו-query שהגיע null מתויג full. השורות על "null" שהוסרו ב-#3485 חזרו ל-קריאה לפי סעיף בקובץ Markdown שמור (toc ו-section) ולטבלת פתרון תקלות, עם הסיבה הנכונה ועם העקיפה.

  • fix (MCP): ``toc`` מקבל דגל כמחרוזת, כמו ``outline`` — ו-``ck_read_mode`` קורא דגל כמו שהכלי קורא אותו (#3472). toc של codekeeper_get_file היה strict: toc="true" נדחה בשגיאת ולידציה, בזמן ש-outline="true" עבד. ה-strict לא הגן על כלום — המחרוזת "true" מגיעה לכלי כמו שנשלחה (pre_parse_json של mcp 1.28.1 זורק פענוח שנותן בוליאני), וההמרה של pydantic נותנת בדיוק את מה שהלקוח התכוון אליו — הוא רק חסם לקוח ששולח דגלים כמחרוזות. עכשיו toc הוא bool רגיל: "true", "yes" ו-1 הם המפה, "false", "no" ו-0 הם הקובץ המלא, ו-"maybe", 2 ו-null עדיין נדחים. הנימוק כתוב ליד StrictInt ב-mcp_server/handlers.py ובמצבי הקצה של קריאה לפי סעיף בקובץ Markdown שמור (toc ו-section), כדי שדגל strict לא ייווצר שוב. ובאותה הזדמנות תוקן באג שקיים מלפני כן ב-outline: ck_read_mode תייג outline="false" כמפה, כי בדק אמת-שקר של פייתון, שבה מחרוזת לא ריקה היא אמת — בזמן שהכלי קרא את הקובץ המלא. עכשיו הקולבק מריץ על הדגל את אותה ולידציה (TypeAdapter(bool)), ו-null שנשלח לדגל — שהכלי דוחה — נספר כמו זוג מצבים שנדחה. ראו מצב הקריאה (ck_read_mode).

  • fix (MCP): סירוב של ``toc``/``section`` בקובץ שמור נכנס בתקציב — בוויתור על ``file.tags`` (#3472). עד היום כל סירוב נשא את המטא-דאטה של הקובץ כמו שהיא, ותגית ענקית — אין תקרה על מספר התגיות ועל האורך שלהן — שלחה סירוב של כ-270KB, מעל OUTPUT_BYTE_BUDGET, בלי שום סימן. עכשיו כל סירוב שנושא file עובר באותו מנגנון שחותך את המפה ואת ההצעות (_fit_lists, שלמד לרדת רמה אחת): file.tags מתקצרת מהסוף, עם file.tags_truncated: true. ב-section_not_found וב-ambiguous_section התגיות נחתכות ראשונות, לפני המפה, ההצעות והמועמדים. תשובה מוצלחת אינה חותכת מטא-דאטה. ו-max בסירובי התקציב הוא עכשיו OUTPUT_BYTE_BUDGET עצמו (256,000), ו-bytes כולל את המקום ל-found ול-status — עד היום max היה 255,964 במפה ו-255,960 בסעיף, מספר שלא הופיע בשום תיעוד. וב-section_too_large — בשלושת הכלים שעונים על סעיף — bytes נמדד עכשיו על הצורה שההחלטה מדדה, העמוד הקטן ביותר שנושא תוכן: קודם הוא נמדד על צורה קצרה ממנה בכמה בתים, ובסעיף שנמצא בדיוק בסף ההחלטה הסירוב אמר bytes קטן מ-max (נמדד: 255,957 מול 255,960). תיאור ארוך עדיין אינו נחתך (הוא מחרוזת), והשורש — כותבים שאינם אוכפים תקרה על תגיות ועל תיאור — ב-#3489.

  • change (MCP): ``section`` של רווחים בלבד שארוך מתקרת האורך הוא ``section_too_long`` גם ב-``codekeeper_get_file`` — שינוי התנהגות בקלט קיצוני (#3472). הכלל המשותף הוא ”קודם אורך, אחר כך תוכן“, וכך ענה כבר codekeeper_docs_get_section. ב-codekeeper_get_file אותו קלט — למשל 5,000 רווחים — קיבל empty_section, כלומר שני כלים שעונים באותה פונקציה נתנו שתי שגיאות לאותו קלט. רווחים קצרים — empty_section, כמו קודם.

  • docs (MCP): תיאור הפרמטר ``section`` של ``codekeeper_get_file`` מפנה לכלל ההתאמה במקום להעתיק אותו, ו-``toc`` ו-``section`` נפתחים בהוראה להעביר ``file_id`` (#3472). כלל ההתאמה של כותרת — שוויון מלא, מזהים כמו K11, בקטיקים, שמות שחוזרים, הצעות ותקרת האורך — היה משובץ בתיאור כמו שהוא, כ-3,000 תווים שנסעו בכל tools/list, אף ששני הכלים עונים באותה פונקציה ושני התיאורים באותה רשימת כלים. עכשיו יש הפניה לפרמטר section של codekeeper_docs_get_section, ורשימת הכלים (בלי כלי האדמין) ירדה מ-40,626 ל-38,348 בתים. ובתחילת שני התיאורים: קריאות המשך — סעיף, העמוד הבא, lines על line_range — צריכות להעביר file_id=file.id, כי לפי file_name כל קריאה קוראת את הגרסה האחרונה, וגרסה ששמר סשן אחר באמצע נותנת עמוד שנפתח באמצע מילה.

2026-09-28

  • fix (MCP): ענף שלא במראה עונה ``ref_not_mirrored`` ולא ``not_found`` — שינוי התנהגות, בכוונה. עד היום codekeeper_get_repo_file ו-codekeeper_docs_get_section החזירו not_found גם לקובץ שאינו קיים וגם לכל נתיב בענף שהמראה עוד לא משכה, בלי לומר איזה ענף או commit נבדקו — וסוכן הסיק ”ההפניה שבורה“ כשהמראה פשוט לא ראתה את הענף. עכשיו שלושה מצבים, שלוש תשובות: ענף או SHA שהמראה לא מכירה ← ref_not_mirrored, עם repo, ref ו-message (ו-path בכלים שמקבלים נתיב); ענף במראה וקובץ חסר ← not_found, שנושא עכשיו ref ו-resolved_commit; קובץ קיים ← בלי שינוי. ועוד שינויי התנהגות באותו כיוון: ref פגום מחזיר invalid_ref במקום not_found; codekeeper_list_repo_tree פותר את הענף לפני ls-tree, ו-repo_or_ref_not_found כבר אינו מוחזר — כל סיבה נקראת בשמה (repo_not_mirrored, invalid_ref, ref_not_mirrored, invalid_input או read_failed), והתשובה התקינה נושאת resolved_commit; codekeeper_search_repo מחזיר ref_not_mirrored כשהענף הראשי חסר במראה, ו-repo_not_mirrored כשאין מראה, במקום search_failed. ההבחנה נולדת ב-_validate_ref_with_git, לפי קוד היציאה של git rev-parse --verify --quiet: 1 הוא שם שאינו במראה, וכל קוד אחר הוא מראה שבורה (git_error, עם WARNING שכולל את ה-stderr) — ולא ”ענף חסר“. get_file_at_commit מעביר את הקוד כמות שהוא במקום לאחד הכול ל-invalid_commit, ולכן בדפדפן הריפו בוובאפ: ענף שלא במראה ב-/repo/api/history היה 400 invalid_ref והוא 404 ref_not_mirrored; ב-/repo/api/file-at-commit ענף שלא במראה היה 400 invalid_commit והוא 404, ref פגום הוא 400 invalid_ref, ו-timeout בבדיקה הוא 504 ולא 400. שום בקשה אינה מושכת את הענף (נמדד בספירת תהליכי git), ו-sync_in_progress גובר כמו תמיד. ראו ענף שלא במראה, מול קובץ שלא קיים.

  • feat (MCP): ``outline`` על קובץ שכלי הסעיפים מגיש מפנה אליו — ``read_with`` ו-``read_with_arguments``. codekeeper_get_repo_file עם outline=true על Markdown מחזיר no_outline / unsupported_language, בזמן ש-codekeeper_docs_get_section כבר מחזיר את עץ הכותרות של אותו קובץ — והסוכן לא ידע. עכשיו התשובה נושאת את שם הכלי ואת הארגומנטים המדויקים לקריאה אליו, כולל ה-ref שהתבקש, באותם שמות כמו item_too_large של codekeeper_read_batch. ההחלטה נגזרת מהשער של הכלי ההוא (section_read_arguments), ולא מרשימה שנייה: על docs/*.md ב-CodeBot, שהכלי אינו מגיש, אין הפניה. no_outline נשאר status. ובתיאור הפרמטר ref של שלושת הכלים שמקבלים אותו — משפט אחד על מתי המראה מתרעננת, ממקור אחד (MIRROR_REFRESH_NOTE). ראו מפת סימבולים (outline).

  • feat (MCP): טביעת אצבע לתוכן בכל תשובה שמתארת קובץ שמור. file.content_sha256 הוא SHA-256 על בתי ה-UTF-8 של התוכן, בדיוק כפי ש-codekeeper_get_file מחזיר אותו: ב-codekeeper_get_file — של הגרסה כולה, בכל מצבי הקריאה; ובשלושת כלי הכתיבה — של מה שנקרא חזרה מהאחסון, ולא של מה שנשלח. תשובת הכתיבה נושאת גם content_changed: true כשמה שנשמר שונה ממה שהכלי התכוון לשמור, עם content_diff (מיקום החלון, הבתים בכל צד ועד 32 code points) ושורת WARNING אחת בלי תוכן; ו-null כשהקריאה החוזרת נכשלה, עם file מינימלי בלי hash. הקריאה החוזרת היא לפי ה-_id שה-insert החזיר — save_code_snippet_returning_id ו-find_version_by_id חדשות ב-Repository, לפי _id ו-user_id, מה-primary ובלי קאש — ומחליפה את הקריאה לפי שם שהייתה שם. תוכן שמור שאינו מחרוזת נופל עכשיו בקול בכל מצב קריאה ובעריכה ובהוספה, במקום להיקרא כקובץ ריק. רשימות אינן נושאות hash; hash של גרסה אחת — version=N עם lines=[1, 1]. המשפט על תקציב הבתים של query תוקן כך שיתאר את מה שנמדד בפועל (#3474). ראו טביעת אצבע לתוכן — content_sha256 ו-content_changed.

  • feat: חיפוש בתוך פתק דביק. בכותרת של כל פתק, ליד העיפרון של השם, כפתור זכוכית מגדלת שפותח תיבת חיפוש מחוברת לפתק מלמעלה: כל ההתאמות מודגשות, מונה 3/7, ניווט ב-Enter/Shift+Enter וב-▲▼, וסגירה ב-Escape או ב-✕. החיפוש עובד על הפתק המעוצב (מארקדאון או משימות); בפתק טקסט רגיל ובפתק ממוזער הכפתור מושבת עם הסבר. בזמן חיפוש לחיצה רגילה על הפתק אינה נכנסת לעריכה, ולחיצה ממושכת כן. בלוק ::: details סגור נפתח כשההתאמה בתוכו, ונסגר שוב בסגירת החיפוש. כשאין מקום מעל הפתק התיבה נכנסת לתוכו ודוחפת את התוכן, ובערכת הניגודיות הגבוהה היא שחורה כמו שאר הערכה. שום דבר לא נשמר ולא נשלח לשרת. ראו חיפוש בתוך פתק; הנימוק והמדידות ב-עקרונות להוספת פיצ’ר לסטיקי-נוטס.

  • refactor: הדגשת החיפוש במודול אחד — ``utils/text-highlight.js``. החיפוש במסמך ועמוד חיפוש הפתקים החזיקו כל אחד מימוש משלו לאותה ליבה, והחיפוש בתוך פתק היה העותק השלישי. עכשיו שלושתם עוברים דרך window.TextHighlight, עם כללי ההתאמה של החיפוש בשרת — ליטרלי, בלי רישיות, בלי נרמול ניקוד. מודול שלא נטען מכבה את היכולת במפורש (שדה מושבת, או טקסט בלי הדגשה) ולא מדווח ”אין תוצאות“. בדיקת החיווט נגזרת מהקוד: כל תבנית שמשתמשת במודול, גם תבנית עתידית, חייבת לטעון אותו לפני השימוש, עם ?v= ובלי defer. החיפוש בקוד ב-view_file עדיין אינו עובר דרכו — הממצאים עליו ב-#3477.

  • fix: החיפוש במסמך כבר אינו נוגע בדיאגרמות. הדילוג על SVG השווה tagName ל-'SVG', אבל הדפדפן מחזיר 'svg' באותיות קטנות — כלומר הוא לא פעל אף פעם. נמדד עם mermaid אמיתי: חיפוש ”fill“ הציג 44 תוצאות, 43 מהן בתוך ה-CSS של הדיאגרמות, וצבע הצמתים הפך לשחור עד לניקוי; ומילה בתרשים רצף נעלמה מהדיאגרמה בזמן שנספרה. המחיר: תווית של צומת בתרשים זרימה (HTML בתוך foreignObject), שהייתה מודגשת, אינה מודגשת עוד.

  • feat (MCP): ``codekeeper_get_file`` קורא קובץ Markdown שמור לפי סעיף — ``toc=true`` למפת הכותרות, ו-``section=“…“`` לסעיף אחד. עד היום מסמך שמור ארוך — מסמך העברה, תוכנית, רשימת כללים — נקרא כולו, או בטווח שנוחש. עכשיו קוראים את המפה (כל כותרת עם הרמה, ה-breadcrumb, טווח השורות וגודל הסעיף בבתים), בוחרים כותרת, וקוראים רק אותה — עם תת-הסעיפים, השכנים, ועימוד ב-max_chars/offset. זה אינו עותק של codekeeper_docs_get_section, אלא הוא עצמו: מיפוי הסירובים של הפרסר חולץ ל-parse_with_refusals, ושני הכלים עוברים בה וב-answer_section — אותה התאמה (כולל section="K11"), אותו חיתוך ואותה צורת תשובה, ו-file במקום ההקשר של הריפו. אפס-דיף על כלי התיעוד (208 עמודי RST ו-99 קבצי amir-bug-patterns) מוכיח שהחילוץ רק הזיז קוד. ארבעת מצבי הקריאה אינם מצטברים, וכל זוג נדחה בקוד משלו (toc_and_section, section_and_query וכו«); max_chars/offset בלי section נדחים; ו-section ריק הוא empty_section עם הפניה ל-toc=true, לא מפה בשקט. רק Markdown, לפי הכלל של הוובאפ (not_markdown אחרת), ו**תקרת גודל לפני הפרסור, בבתים של UTF-8** — אותה תקרה שמאגר הקריאות מתקצב לפיה פרסור (too_large_for_sections). הדיאלקט לא יושר עם הוובאפ, בכוונה, ושלושת המקומות שבהם המפה חולקת עליו — כותרת בתוך קופסת :::, כותרת מיד אחרי שורת HTML, ו-front matter — מתועדים עם דוגמה שנבדקה מול שני הצדדים. toc נספר באנליטיקס כ-outline, ו-section הוא תווית חדשה. ראו קריאה לפי סעיף בקובץ Markdown שמור (toc ו-section).

  • fix (MCP): תקרת אורך ל-``section`` — ``section_too_long`` מעל 4,096 תווים, בשלושת הכלים שעונים על סעיף. section לא עבר שום תקרה, והעבודה עליו גדלה עם מה שהקורא שולח: ההתאמה, ההצעות, וההד המלא ב-requested. נמדד: שאילתה של מיליון תווים (גוף בקשה של 1MiB נושא אותה) עלתה 321ms מעבד מעל הפרסור והחזירה תשובה של כמגה-בייט — מעבר ל-OUTPUT_BYTE_BUDGET, ומעבר לחשבון שמגבלת הקצב נשענת עליו. התקרה (MAX_SECTION_CHARS) נבדקת בפונקציה שבונה את התשובה, ולכן codekeeper_docs_get_section, codekeeper_read_batch ו-codekeeper_get_file מקבלים אותה ממקום אחד; היא רחוקה מכל כותרת אמיתית שנמדדה, והמדידה יושבת ליד הקבוע. ראו איך docs_get_section מוצא כותרת.

  • fix (MCP): עמוד של סעיף חסום בבתים כפי שהוא נשלח, ולא רק בתווים. max_chars סופר תווים, והתקציב (OUTPUT_BYTE_BUDGET) הוא בתים — ולכן עמוד מלא של תווים רחבים עבר אותו: עמוד CJK של MAX_CHARS_MAX תווים יצא ב-299,373 בתים, אימוג’י ב-398,132, ותווי בקרה ב-595,650 (נתפס בריוויו על ה-PR). עכשיו עמוד שאינו נכנס נגמר מוקדם יותר, על גבול תו, עם truncation_reason: "byte_budget" ו-next_offset איפה שהוא באמת נגמר — ובעימוד לפי offset זה חיתוך בלי אובדן. המדידה היא על התשובה כולה, באותה פונקציה שמודדת את הבאץ« (wire_json, שעברה מ-read_batch ל-repo_handlers), ו-codekeeper_get_file שומר בה מקום ל-found/status. באותה הזדמנות: subsections חסומה בתקרה של המפה (subsections_truncated) — סעיף עם 7,000 תת-סעיפים יצא בכמיליון בתים — וסעיף שגם עמוד ריק שלו אינו נכנס מקבל section_too_large עם line_range, ולא עמוד ריק שהיה שולח קורא ללולאה. אפס-דיף על קורפוס התיעוד, כולל כל סעיף ב-MAX_CHARS_MAX: אף עמוד אמיתי לא השתנה. ראו איך docs_get_section מוצא כותרת.

  • fix (MCP): גם המפה, ``section_not_found`` ו-``ambiguous_section`` חסומים בתקציב הבתים. עד עכשיו התקציב חל רק על עמוד של סעיף, והרשימות של שלוש הצורות האחרות היו חסומות רק במספר פריטים — ותיאור הפרמטר section הבטיח ש“תשובה לעולם אינה עוברת“ את התקציב, מה שלא היה נכון לתשובת ”לא נמצא“. מפה נושאת בכל פריט את כל ה-breadcrumb שלו, ולכן בקינון עמוק היא גדלה פי כמה מהקובץ: קובץ של 93,906 בתים עם 400 כותרות עבריות החזיר מפה של 472,517 בתים. עכשיו כל רשימה נחתכת מהסוף עד שהתשובה נכנסת, והדגל שלה (toc_truncated, suggestions_truncated, candidates_truncated) נושא שתי סיבות — התקרה במספר פריטים, או התקציב. ב-section_not_found המפה נחתכת לפני ההצעות; המועמדים נשארים בסדר המסמך, ואיך מגיעים למי שנחתך — וגם לכותרת ששמה חוזר בקובץ, שאינה נענית בשמה — כתוב בעמוד. תשובה שגם כשכל הרשימות שלה ריקות אינה נכנסת היא answer_too_large. תשובות שנכנסות לא השתנו: אפס-דיף על עמודי התיעוד, על amir-bug-patterns ועל קובצי ה-Markdown של הריפו, בתשובות המלאות. ראו איך docs_get_section מוצא כותרת.

  • fix (parsers): שורות המסמך של ``md_parser`` הן שורות המקור — טקסט סעיף זהה בית-בית לקריאת ``lines=`` על אותו טווח, גם ב-CRLF ועם BOM. עד עכשיו השורות נבנו מהטקסט המנורמל, כך שבקובץ עם \r\n טקסט הסעיף איבד את ה-\r, ובקובץ עם BOM הוא איבד את ה-BOM — ו-line_range הצביע על טווח שקריאתו ב-lines מחזירה טקסט אחר. הנרמול נשאר במה שהפרסר רואה, ולכן המפה עצמה לא זזה. חל גם על עמודי Markdown ב-codekeeper_docs_get_section; rst_parser לא השתנה.

  • refactor: ”מה נחשב Markdown“ בכלל אחד — ``services/markdown_files.py``. הוובאפ החזיק את הכלל (שפה markdown/md או סיומת .md/.markdown) בפונקציה אחת ובעוד שני עותקים מוטבעים, ורשימת השפות שוכפלה גם ב-_resolve_preview_mode. עכשיו כולם קוראים מהמודול, וגם כלי הקבצים של ה-MCP — כך שקובץ שהוובאפ מציג כ-Markdown הוא בדיוק קובץ שהסוכן יכול לקרוא לפי סעיף.

  • docs (MCP): מה הדשבורד באמת סופר מ-``ck_read_mode``. שתי הערות טענו שתווית שגויה ”מנפחת“ את עמודות האאוטליין וקריאת התוכן — על קריאות query ועל לחיצת היד. נקרא מהגדרת נקודת הקצה ck_mcp_navigation_cost_v2 ב-PostHog: היא סופרת את העמודות רק על אירועי $mcp_tool_call של codekeeper_get_repo_file. ההערות תוקנו — התוויות נחוצות כדי שהאירוע עצמו יגיד את האמת, לא כי הן מזיזות את הדשבורד של היום.

2026-09-27

  • fix (scripts): שיא הפרסור נמדד מאיפוס של ``VmHWM``, על 40 סידורי זיכרון, ונשפט כחסם עליון — וכל מספר שנמדד בשיטה הישנה נמדד מחדש (#3391). מאז #3429 scripts/measure_md_parse_cost.py הפחית מהשיא את הגבוה מבין ה-RSS שלפני הפרסור לבין השיא שהתהליך כבר הגיע אליו, ולכן זיכרון שהתהליך תפס ושחרר לפני הפרסור — בעיקר החוצץ של קריאת הקובץ — הסתיר את מה שהפרסור הקצה מתחתיו: כחצי MB על קלט של 512KB וכ-10MB על outline של 10MB, תמיד לכיוון ”נכנס“. עכשיו הילד המודד כותב 5 ל-/proc/self/clear_refs רגע לפני הפרסור, מוכיח בכל ריצה שהשיא אכן אופס, ועוצר בקול כשאי אפשר — בלי נפילה שקטה לשיטה הישנה. שתי הטיות נוספות, לאותו כיוון, נסגרו איתו: השיא של אותו פרסור תלוי בסידור הזיכרון שלפניו (עד כ-0.9MB), ולכן כל מדידת זיכרון רצה על 40 זרעי PYTHONHASHSEED קבועים (LAYOUT_SEEDS); ומוני ה-RSS של הקרנל מפגרים אחרי השיא האמיתי, ולכן מה שנשפט הוא חסם עליון — המקסימום ועוד הפיגור שמוכח מקוד הקרנל (counter_lag_bound_bytes), כשהילד המודד מוצמד למעבד אחד. ההצמדה היא של המדידה בלבד, לא של השרת. מה יצא: הקלט הגרוע תחת התקרות — חסם עליון של 95.9% מהעלות שמאגר הקריאות מקצה לחוט, כלומר 69.02 בתים לכל בית של תקרת הקריאה מול הקבוע 72: מרווח של 4.1% בלבד. CLOUD.md משוכפל עד תקרת הקריאה, בלי התקרות, עולה 72.4 עד 72.8 — מעל 72, שנגזר ממנו ב-#3429 — ולכן הקבוע מחזיק בזכות התקרות של #3391 ולא מעבר להן; הוחלט להשאיר אותו ולכתוב את זה לידו. RST עוין — 44.3MiB בלי תקרה ו-20.2MiB איתה; outline של 10MB לאורך המסלול כולו — 80.8 עד 91.6MiB; קובץ של 12MB לפני #3433 — 22MiB. הפרטים, הפיזור ואיך החסם נבנה — ליד _PARSE_RSS_PER_INPUT_BYTE וב-מודל הריצה של הכלים; השיטה — סקריפטים שימושיים. המספרים שנכתבו בשיטה הישנה ברשומות של #3429 ושל #3433 למטה נשארים כפי שנכתבו אז.

  • fix (MCP): שתי תקרות בפרסר ה-Markdown — שורות לפני הפרסור, וטוקנים בכל טוקן שנוצר (#3391). עד עכשיו התקרה היחידה בתוך md_parser ספרה כותרות, וקובץ עוין בלי אף כותרת עבר אותה בלי סירוב: 500KB של שורות-תבליט עלו כ-142.5MiB לפרסור אחד, וקובץ של 128KB עם הרבה טבלאות רחבות הגיע ל-3GB ונפל ב-MemoryError — התקרה של upstream לתאים משלימים (#364) היא לכל טבלה, והמונה מתאפס בכל טבלה חדשה. עכשיו parse_document מסרב לקובץ ארוך מ-MAX_LINES לפני הפרסור — too_many_lines, עם max ו-total_lines — ועוצר ב-MAX_TOKENS ברגע שנוצר הטוקן החורג, גם באמצע טבלה ובאמצע רשימה — too_many_tokens, עם max ו-line. הבדיקה יושבת ב-append של רשימת הטוקנים עצמה, שכלל core מתקין לפני block, ולא בבנאי של StateCore, ששם רשימה ריקה מוחלפת בשקט (tokens or []); ומעקה אחרי הפרסור מוודא שהרשימה שחזרה היא זו שהותקנה, אחרת RuntimeError. שני המספרים נבחרו יחד, משני תנאים: הקלט העוין הגרוע שנמצא — ציטוט בעומק 19 בכל שורה, \r\n ותו אסטרלי בכל שורה, וטבלה שעוברת את התקרה בתוך הציטוט — נכנס בעלות שמאגר הקריאות מקצה לחוט — החסם העליון שלו 95.9% ממנה (המדידה ברשומה שמעל) — ואף קובץ אמיתי אינו נחסם: הארוך ביותר 6,151 שורות, והצפוף ביותר 38,153 טוקנים. מגבלת הקצב יורדת מ-60 ל-45 בדקה: הטענה שהיא שומרת עליה — זהות אחת אינה עוברת דקת מעבד בדקה — נבדקת עכשיו מול הקלט הגרוע תחת התקרות, WORST_CASE_CPU_SECONDS ב-md_parser, ו-tests/test_md_parse_worst_case_claims.py גוזר ממנו גם את החשבון של הדדליין של codekeeper_read_batch. המדידה הישנה שהחשבונות האלה נשענו עליה (2.3 שניות, #3431) הייתה מוקלדת בכמה מקומות והתיישנה; עכשיו יש לה בעלים אחד. MAX_SECTIONS אינה יכולה להיפגע יותר ב-Markdown עם ברירות המחדל — כל כותרת צריכה שורה, ו-MAX_LINES קטן ממנה — והיא נשארת בשביל RST. scripts/measure_md_parse_cost.py מודד עכשיו גם את הקלט העוין כמו שהכלי מקבל אותו, עם זמן מעבד, ויוצא בקוד 1 כשהזיכרון או המעבד עוברים את הקבועים; ו---doubling בודק שכל צורה עוינת ליניארית — הבדיקה שהייתה תופסת מראש את הריבועיות של #367. האורקל מול cmark-gfm משווה בלי התקרות, בכוונה, ובשורה של הטבלה שעוברת את תקרת התאים כתוב שהפער אינו נגיש דרך הכלי: הוא מתחיל רק אחרי 196,608 טוקנים. #3466 נשאר פתוח, אבל החומרה שלו יורדת: עלות כל פרסור חסומה עכשיו, מכל מקור. ראו too_many_lines ו-too_many_tokens ב-איזה קובץ docs_get_section קורא, ובאיזה ריפו.

  • fix: שמירה שומרת בדיוק את מה שנשלח — הנרמול יצא משכבת השמירה, ונשאר ניקוי מינימלי רק לקוד שמודבק בבוט. normalize_code רץ מאוקטובר 2025 (#637) בתוך Repository.save_code_snippet, save_file ו-save_large_file, ולכן שכתב בשקט כל קובץ מכל כניסה — גם מה-MCP, מהוובאפ ומהעלאת מסמך לבוט: הוא מחק LRM ו-RLM ממסמכים בעברית, מחק רצפי escape טקסטואליים מקוד מקור (#643) כך שקבוע קיבל ערך אחר ורגקס נשבר, מחק את כל ה-newlines בסוף הקובץ (#1662) ורווחים בסוף כל שורה, ופירק אמוג’י שמחוברים ב-ZWJ; ועריכה של מילה אחת ב-edit_file נרמלה את כל הקובץ. עכשיו ה-Repository, הוובאפ וה-MCP לא משנים תוכן, ו-tests/test_content_cleaning_stays_in_the_bot.py נופל אם פונקציית ניקוי נקראת מ-database/, webapp/ או mcp_server/. בבוט רץ ניקוי מינימלי אחד, clean_pasted_code, ממש לפני השמירה בכל זרימה — שמירה רגילה ואיסוף ארוך, /save, עריכת קובץ ועריכת קובץ גדול (/save ועריכת קובץ גדול נוקו עד היום רק בשכבת השמירה): סופי שורה של Windows, CR בודד ו-BOM, ובקוד שאינו Markdown גם רווחי Zs, ‏ZWSP ורווחים בסוף שורה — הרשימה המדויקת ב-docstring של clean_pasted_code. הודעת ההצלחה אומרת מה נוקה, ותווי embedding, override ו-isolate נשארים, עם אזהרה על השורות שלהם. גם עמוד הקוד בוובאפ (view_file.html, בתצוגת הבעלים ובשיתוף הציבורי /share/<id>) מציג עליהם אזהרה מעל הקוד, עם מספרי השורות שבעמוד. בוובאפ decode_form_newlines מבטל את ה-CRLF ששליחת טופס HTML מוסיפה (HTML Living Standard, סעיפים 4.10.22.6 ו-4.10.22.8) — פענוח ולא ניקוי — ב-/upload וב-/edit/<id> בלבד; קובץ שהועלה לא עובר את הפענוח הזה, ו-upload_file_web רק מפענח את הבתים שלו לטקסט. הוסרו: utils.normalize_code, CodeNormalizer, strip_hidden_escapes, הכלל שמחק ”…“ מכל חלק באיסוף ארוך, והדגל NORMALIZE_CODE_ON_SAVE (ערך שנשאר מוגדר בסביבה פשוט לא נקרא). למה אף טסט לא תפס: תחת pytest ה-Repository קורא את tests/config.py, שאין בו את הדגל, וה-AttributeError נבלע ב-except Exception: pass — כלומר בטסטים הנרמול בשכבת השמירה אף פעם לא רץ. הטסטים החדשים טוענים את config.py האמיתי. נתונים שכבר נשמרו לא משתנים. ראו ניקוי קוד מודבק (Pasted-code cleanup).

  • fix: סל המיחזור מתרוקן שוב — אינדקס ה-TTL חזר למסלול העלייה. כל מחיקה רכה כותבת deleted_expires_at, והעמוד /trash מציג אותו כ“נמחק סופית ב-“, אבל אף קוד אפליקציה אינו מוחק בתאריך הזה: את העבודה עושה אינדקס TTL בצד השרת. ב-1 בינואר 2026 (#2525) רשימת האינדקסים שבעלייה נכתבה מחדש כרשימה ”מינימלית“ של אינדקסי ביצועים, והאינדקס הזה לא נכנס אליה; האשכול שהוקם אחר כך קיבל רק את מה שהעלייה יוצרת, ולכן מעולם לא היה בו TTL — לא ב-code_snippets ולא ב-large_files — ופריטים שתאריכם עבר נשארו בסל. עכשיו DatabaseManager._create_recycle_bin_ttl_indexes יוצר אותו בכל עלייה, והמפרט יושב ב-file_deletion.py: חלון 0 (מחיקה בדיוק בתאריך המוצג), ומסנן חלקי על is_active: false — כך שגם מסלול שחזור ששוכח לנקות את התאריך לא יגרום למחיקת קובץ פעיל. כשל ביצירה יוצא כאירוע db_recycle_bin_ttl_index_missing ברמת error ולא נבלע. ביצירה הראשונה מונגו מוחק בבת אחת את כל מה שכבר עבר — זו החלטה ולא תאונה, והיא כתובה ליד היצירה. /recycle_backfill קורא לאותה פונקציה ומדווח את מצב האינדקס לכל קולקציה, במקום לבלוע את הכשל ב-except: pass; ובמצב שבו המסד לא עלה הוא מסרב, במקום לדווח ✅ על כלום. בעמוד /admin/verify-indexes נוסף הסעיף recycle_bin_ttl: האם האינדקס קיים ותואם למפרט, וכמה פריטים שתאריכם עבר עדיין בסל. ראו אינדקסים שהם התנהגות, לא אופטימיזציה.

  • chore (MCP/docs): הפארסר של ה-Markdown עולה ל-markdown-it-py 4.2.0 — והפערים הידועים מ-GitHub יושבים עכשיו בטבלה אחת. הנעיצה עלתה מ-3.0.0 ל-4.2.0, ואיתה mdit-py-plugins ל-0.6.1 ו-myst-parser ל-5.1.0 (הוא זה שחסם: 4.0.1 דרש markdown-it-py~=3.0). למה עכשיו: לפני ש-md_parser יפרסר גם תוכן שמשתמשים כותבים, שני תיקונים של upstream ב-4.0.0 סוגרים עלויות שהגרסה הקודמת נשאה — הגדרות קישור רצופות נסרקו בזמן ריבועי (#367), וטבלה עם כותרת רחבה הושלמה תא-תא בלי תקרה (#364). איך נבדק: סקריפט חדש, scripts/md_parser_upgrade_zero_diff.py, רץ על שתי הגרסאות — כל מפות ה-.md וה-RST בריפו הזה וב-amir-bug-patterns, תשובות הסירוב, צורות עוינות, וכל משפחות הצורות של האורקל מול cmark-gfm — והפלט זהה, חוץ משתי מחלקות שהוכרזו מראש בהרצה ונבדקו עד הסוף. הראשונה: רשימת תגיות הבלוק של CommonMark 0.31.2, שממנה source יצאה ובה search נמצאת. markdown-it-py עובד לפיה מאז 4.0.0 ו-cmark-gfm עוד לא, ולכן שורה שמתחילה באחת מהתגיות האלה יכולה להזיז כותרת — 28 מתוך 60 צורות שנמדדו חולקות היום על GitHub, ופער אחד נסגר (<search> שלמה אחרי פריט רשימה, שב-3.0.0 הייתה מופע של #434). השנייה, שנמצאה בסקירה: התקרה של #364 עצמה — טבלה שעוברת את מספר התאים המשלימים המותר נחתכת, והשורות שנשארו בחוץ יכולות להפוך לכותרת setext שאין ב-GitHub. הפערים מקובעים, לא מתוקנים: הם בטבלה _KNOWN_DIVERGENCES ב-tests/test_md_parser_oracle.py, לצד הפער הוותיק של תגית מסוג 7 הצמודה לשורת מכל (#434) ולצד שני פערים שהסקירה מצאה ושקדמו לשדרוג (3.0.0 מחזיר בדיוק את אותן מפות): כותרת setext שצמודה להגדרת קישור, ותו רווח ש-\s של פייתון מזהה ו-cmark-gfm לא — כמו NBSP — אחרי שם של תגית HTML. לכל שורה: הסיבה, צורה ומה כל צד מחזיר עליה, על מה ומתי נמדדה, ומשפחת צורות קבועה באורקל. לידן משפחה קבועה של כל תגית בלוק, בכל צורות הכתיבה וההקשרים, כדי ששינוי ברשימת התגיות של אחד הפארסרים יתגלה בשדרוג הבא בלי שמישהו יחשוד בו מראש. איפה מפת ה-Markdown חולקת על GitHub מעתיק מהטבלה, עם טסט שמשווה בכל שורה. והטענה שאף קובץ אמיתי אינו מושפע נבדקת: טסט ב-CI סורק את עמודי ה-.md תחת docs/ לשורות שמפעילות שורה בטבלה שיש לה טריגר, מחוץ לבלוקי קוד ומחוץ לבלוק HTML שנפתח בשורה קודמת (כמו <source> בתוך <video>) — לפי הפארסר, ועם קבצים שתולים שמוכיחים שהוא תופס ולא תופס בהתאם. scripts/compare_md_parser_to_cmark.py מריץ את אותה סריקה ואת השוואת המפות על כל קורפוס, ונופל על כל אחת מהן — אפס על docs/, על amir-bug-patterns ועל הריפו כולו. והקבצים השמורים נמדדו פעם אחת במסד, והתוצאה מתוארכת בתיעוד. בדרך תוקן גם הטוען של הסקריפט הזה, שלא רשם את מודול האורקל ב-sys.modules ולכן נפל על @dataclass — ועכשיו גם מסיר את הרישום כשהטעינה נכשלת. עלות הפרסור נמדדה מחדש ולא זזה (_PARSE_RSS_PER_INPUT_BYTE נשאר 72). ראו איפה מפת ה-Markdown חולקת על GitHub.

2026-09-23

  • feat (MCP): ``codekeeper_read_batch`` — כמה סעיפי תיעוד וקבצים מהמראות בקריאת כלי אחת (אדמין). סוכן ריוויו קורא לפני כל סבב את כל הדפוסים ב-amir-bug-patterns שהטריגר שלהם נדלק, ובסבב שבו הוא ביקש את הכלי אלה היו 16 קריאות. PostHog הראה שהן מגיעות לשרת אחת אחרי השנייה ולא יחד: ארבעת הפרצים של הסבב נמשכו כ-11.5 שניות, והשרת עבד מתוכן כחצי שנייה. הכלי מקבל רשימת פריטים — סעיף (הארגומנטים של codekeeper_docs_get_section) או קובץ (של codekeeper_get_repo_file) — וכל פריט עובר דרך ה-handler של הכלי שהוא משקף, ולכן התשובה שלו זהה בית-בית לזו של הכלי הבודד, כולל סירובים, וכישלון של פריט אינו כישלון של הקריאה. commit אחד לכל ריפו (RepoBackend.snapshot, GitMirrorService.resolve_commit), ו-resolved_commit בכל פריט; קריאה ופרסור אחד לכל קובץ, עם lines בתוך מפתח הקבוצה כדי שפריט סעיף לעולם לא יפרסר טקסט שנקרא תחת תקרת הטווח; תקציב בתים בצורה שה-SDK שולח, פריט שלם או כלום (item_too_large עם read_with), והמשך ב-unread עם unread_reason (byte_budget או timeout); דדליין של 10 שניות מהכניסה ל-call_tool, שנבדק בין פריטים. כל פריט נספר כקריאה אחת במכסה, הכל או כלום, לפני שדבר נקרא: RateLimiter קיבל weight (ברירת המחדל 1 משאירה את הבוט כמו שהיה), והתקרה, MAX_BATCH_ITEMS, נבדקת לפני השקילה ויורדת עם המכסה כשהיא נמוכה ממנה. _meta["anthropic/maxResultSizeChars"] מוצהר, כדי ש-Claude Code לא ישמור את התשובה לקובץ. בדרך docs_get_section התפרק לחלקים שהבאץ« משתמש בהם (resolve_docs_target, load_document, document_from_read, answer_section) — ו-scripts/docs_section_zero_diff.py הראה אפס דיף לפני ואחרי, על קורפוס ה-RST ועל קורפוס ה-Markdown, גם דרך RepoBackend אמיתי ועם תשובות הסירוב. המדידות שהתיעוד מצטט מגיעות מסקריפט חדש, scripts/measure_read_batch.py. כלי הקריאה הקיימים עדיין נשמרים לקובץ מעל סף הפלט של הלקוח — אישו #3460. ראו קריאה קבוצתית — codekeeper_read_batch.

  • fix (WebApp): רשימות הקבצים — שורה אחת לכל קובץ, ו“שאר קבצים“ לא נופל יותר על תקרת הזיכרון של המסד. שלושה תסמינים, שני שורשים. ‏(1) ”מועדפים“ ותצוגת ריפו ספציפי הציגו שורה לכל גרסה — 30 קבצים מועדפים הוצגו כ-65 שורות — כי הענף שלהם לא קיבץ לפי שם קובץ. עכשיו כל קטגוריה שנשלפת מ-code_snippets עוברת באותו בנאי, _latest_version_per_file_stages, והספירה ב“מציג X מתוך Y“ סופרת קבצים ולא גרסאות. במועדפים הכלל הוא של הקובץ: קובץ נכנס אם איזושהי גרסה פעילה שלו מסומנת, ומוצגת הגרסה האחרונה שלו. ‏(2) ”שאר קבצים“ החזיר 500 עם שגיאה 292 (QueryExceededMemoryLimitNoDiskUseAllowed): שלב $addFields שישב בין ה-$match להורדת השדות הכבדים גרם למונגו למיין מסמכים מלאים, כולל גוף הקובץ — 35.8MB מול תקרה של 32MB באשכול Flex, שמתעלם מ-allowDiskUse. עכשיו רק $match בא לפני ההורדה, והקיבוץ בוחר את הגרסה האחרונה ב-$top בלי מיון מקדים; על נתוני הפרודקשן הצינור רץ ב-26ms. אותו שורש הפיל גם את ”כל הקבצים“ בכל טעינה במשך 17 יום, אלא שמסלול find עוקף הסתיר את זה — והמסלול הוסר: כשל כזה יופיע מעכשיו כשגיאה, ולא כעמוד איטי שמציג בחירת גרסאות אחרת. ובאותו תיקון: הוספה והסרה ממועדפים בבחירה מרובה חלות על כל הגרסאות הפעילות של הקובץ, ו-updated סופר קבצים; עריכה בדפדפן, העלאה, שמירת מדריך משותף, Incident Story ושמירה מאוסף משותף מעבירות את הסימון לגרסה החדשה, דרך פונקציה אחת ב-file_favorite.py שכל שבעת מסלולי הכתיבה קוראים לה — והיא שואלת את המצב של הקובץ, כלומר את כל הגרסאות הפעילות ולא רק את האחרונה, כמו הרשימה; עריכה ששינתה שם שואלת גם את השם הקודם; Repository.save_file (עריכה בבוט, ייבוא מ-GitHub ומ-ZIP) קורא את הגרסה הקודמת מהמסד ולא דרך הקאש — עד היום סימון מועדף שהוסר יכול היה לחזור לחיים, favorited_at יכול היה להיכתב כמחרוזת, ותיאור או תגיות ששונו בוובאפ יכלו להתהפך בשמירה הבאה מהבוט; סימון והסרה בוובאפ, אחד-אחד ובבחירה מרובה, מבטלים את הקאש של המשתמש, כך שקובץ שהוסר לא חוזר ברענון מעמוד המועדפים ששמור בקאש (עלות הניקוי ופתרון השורש שלה — #3402); גרסת המינימום של MongoDB עלתה ל-5.2, בגלל $top — התקנה והגדרה (התיעוד אמר 4.4, אבל $setWindowFields ב-search_engine.py דרש 5.0 עוד לפני כן); תצוגת ריפו ספציפי ו“שאר קבצים“ מסננות לפי התגיות של הגרסה האחרונה של כל קובץ, כמו רשימת הריפואים — עד היום הן סיננו גרסאות, ולכן קובץ שעבר לריפו אחר, או קובץ ידני שיובא אחר כך מ-GitHub, הופיע גם בקטגוריה הישנה, בגרסה הישנה; עמוד הקובץ והכוכב שבו מציגים ומחליפים את המצב של הקובץ ולא של הגרסה שנפתחה — עד היום בקובץ שרק גרסה ישנה שלו מסומנת הכפתור אמר ”הוסף“ והלחיצה השאירה אותו במועדפים, ובעמוד של קובץ בינארי או גדול לתצוגה הכפתור אמר תמיד ”הוסף“; המצב נכנס גם ל-ETag של העמוד, כדי שהדפדפן לא יקבל 304 עם כוכב ישן; ”נפתחו לאחרונה“ רושם לוג כשהשליפה נכשלת, במקום להציג בשקט רשימה ריקה; והמיון האחרון ב-codekeeper_list_files רץ על מטא-דאטה בלבד — עד היום בעמוד האחרון הוא מיין גם את גוף הקבצים, עד 19MB מתוך אותה תקרה.

  • docs (MCP): ``codekeeper_docs_get_section`` אומר איך קוראים קובץ שלם. תיאור הכלי, שורת הטבלה ב“הכלים“ וה-README אומרים עכשיו את מה שהקוד כבר ידע: section עם הכותרת הראשונה בעץ מחזיר את תת-העץ שלה (תת-הסקשנים כלולים כברירת מחדל; כל הקובץ כשהוא כולו תחת כותרת עליונה אחת, כמו קובצי bugbot-rules), מדופדף כמו כל סעיף — כל עוד truncated הוא true ממשיכים מ-next_offset — ולאדמין יש גם codekeeper_get_repo_file. עד היום התיאור הזכיר את codekeeper_get_repo_file רק כדבר שעדיף לא להשתמש בו, וקורא שאינו אדמין לא ידע שיש לו דרך לקרוא קובץ bugbot-rules שלם בלי סיבוב של עץ כותרות. ה-README גם אומר שהכלי קורא Markdown ולא רק RST. ובאותו PR: הבלוק ”דפוסי באגים“ ב-CLAUDE.md מונה את codekeeper_get_repo_file לקריאת קובץ שלם מ-amir-bug-patterns, לצד codekeeper_docs_get_section ו-codekeeper_search_repo.

2026-09-22

  • feat (MCP): ``codekeeper_get_note`` — פתק בודד לפי מזהה, ו-``include_content`` ברשימות הפתקים. עד היום לא הייתה דרך לקרוא פתק אחד: codekeeper_search_notes מחזיר מזהה בלי תוכן, codekeeper_get_note_version מחזיר תוכן רק לגרסאות קודמות, וכלי הרשימה מחזירים את המשטח כולו — בלוח ”Ck MCP“ עם 18 פתקים זה 64,691 עד 66,416 תווים, מעל מגבלת הפלט של הלקוח, כדי להגיע לפתק של 4,997 תווים; סוכן בלי shell לא יכול היה לקרוא את הפתק בכלל, וכל עריכה ב-codekeeper_note_str_replace, שדורש את הגוף הנוכחי המדויק, חייבה משיכה של הלוח כולו. הכלי החדש מחזיר את הגוף הנוכחי בדיוק כפי שהוא מאוחסן — פתק ישן עם &quot; חוזר עם הישות, כמו ב-codekeeper_get_note_version, בעוד כלי הרשימה ממשיכים לפענח — את הכותרת והצבע, את version (המספר שבו codekeeper_get_note_version מחזיר את הגוף הזה — עכשיו, או אחרי הדריסה הבאה דרך השרת הזה; עריכה מהוובאפ אינה נכנסת להיסטוריה), ואיפה הפתק יושב בדיוק בארגומנטים שכלי הרשימה המתאים דורש, עם orphaned על פתק ריפו כמו ב-codekeeper_list_repo_notes. זו אותה קריאה-לפי-מזהה ש-codekeeper_note_str_replace כבר עושה, ולא מסלול שני, והיא סוגרת את הלולאה שלו: conflict ← codekeeper_get_note ← ניסיון חוזר; נבדק שהשער האופטימי משווה תוכן בלבד, ולכן הגוף הנוכחי הוא כל מה שהניסיון החוזר צריך. ההרשאה נבדקת לפי סוג הפתק לפני שתוכן חוזר: פתק של משתמש אחר, ופתק על קובץ בריפו למי שאינו אדמין, מחזירים not_found — לא סירוב שמגלה שהמזהה קיים — ולכל אחד מהם טסט שנופל כשהבדיקה מוסרת. codekeeper_list_notes ו-codekeeper_list_board_notes מקבלים include_content (ברירת מחדל true, בלי שינוי לקוראים קיימים); false מחזיר לכל פתק רק מזהה, כותרת, צבע (color ו-color_id), updated_at ו-content_bytes — בבתים של UTF-8, ביחידה נקובה, כי בפתק עברי זה פי שניים מספירת תווים. תיאורי codekeeper_search_notes ו-codekeeper_note_str_replace מפנים ל-codekeeper_get_note, ושני כלי הגרסאות מצביעים זה על זה כדי שלא ייווצר ספק מי מחזיר את ההווה; המשפט בתיעוד שאמר שאת הפתק קוראים ”בכלי הרשימה“ תוקן, וההחלטה שפגיעת חיפוש אינה נושאת תוכן נשארת. הכלי אינו נושא ck_read_mode בדשבורד, בכוונה — התווית היא לכלי קריאת קובץ בלבד, וכלי שאינו במפה אינו נספר כקריאה מלאה. ממצא בדרך: OUTPUT_BYTE_BUDGET אינו נאכף על רשימות פתקים כלל — לוח שלם עבר מתחתיו, ומה שחסם היה הלקוח; אכיפה שם היא שינוי נפרד, רשום ב-#3457 יחד עם שאר הפריטים שנדחו מה-PR. ומה שסקירת ה-PR תיקנה בו לפני המיזוג: הגוף והגרסה נקראים תחומים — הפתק נקרא, ההיסטוריה נקראת, והפתק נקרא שוב, והזוג חוזר רק אם שום כתיבה לא נגעה בו בין השתיים (אותה הוכחה משולשת של תוכן, updated_at ו-write_id שמסלול הכשל של update_note משתמש בה), אחרת קוראים שוב ולבסוף conflict; המסלול הרזה של include_content=false הוא צינור אגרגציה שבו $strLenBytes מודד את הגוף במסד ומוריד אותו לפני המיון, ולא find שמושך גופים כדי לזרוק אותם; גוף ריק, שההיסטוריה מדלגת עליו, נושא version: null ולא מספר שלעולם לא יחזיר אותו; ומזהה פתק שהוקלד באותיות גדולות מגיע לכל כלי בצורתו הקנונית — קודם הוא עבר את השער, מצא את הפתק, וחיפש היסטוריה שלעולם לא תימצא. ומה שסקירה שנייה, בלתי תלויה, תיקנה לפני המיזוג: ההבטחה על version נוקבת בתנאי שלה בכל מקום שבו היא כתובה — תיאורי שני הכלים, עמוד ה-MCP וה-README — (דריסה דרך השרת הזה; עריכה מהוובאפ אינה נכנסת להיסטוריה), והפסקה שתיארה את החישוב תואמת את הקוד; רשימת שדות השורה הרזה חיה פעם אחת (LEAN_NOTE_FIELDS) ותיאורי הכלים נגזרים ממנה; length ברשימת הגרסאות נוקב ביחידה שלו (תווים) מול content_bytes (בתים); המשפט על OUTPUT_BYTE_BUDGET מדויק — עץ, אאוטליין וחיפוש, ו-query בקבוע משלו; _next_note_version נמחק לטובת קריאה ישירה אצל הקורא היחיד; ושני טסטים חדשים — פתק שנמחק בין שתי הקריאות של codekeeper_get_note עונה not_found ועוצר, וצורת השאילתה של רשימת פתקי קובץ ($or עם $in) רצה במסלול הרזה מול מונגו אמיתי (אחרי מיזוג, ב-deploy.yml). ראו קריאת פתק בודד — codekeeper_get_note.

2026-09-21

  • fix (MCP): סגירת ממצאי סקירת שבעת ה-PRים #3434–#3441 — תקרת הגוף מפסיקה לקרוא גוף אנונימי לפני האימות, ועוד ארבע-עשרה הצעות. הרגרסיה (SEC-001): תקרת הגוף מ-#3431 קראה כל גוף עד 1MiB לפני שהשכבה הבאה ראתה את הבקשה — במצב OAuth גם גוף אנונימי שהאימות של ה-SDK דוחה מהכותרות בלבד, ובלי דדליין (ל-uvicorn אין timeout לגוף בקשה): נמדדו 5 קריאות receive() לפני ה-401 על גוף של חמישה נתחים, גם עם Content-Length. שלושה כללים, כל אחד עם טסט שנפל לפני שנכתב: Content-Length תקין (ספרות בלבד, בלי Transfer-Encoding) עובר בלי קריאה, כי השרת תוחם את הגוף לאורך המוצהר — 0 קריאות לפני ה-401; גוף בלי אורך מוצהר נקרא עד התקרה תחת דדליין של 30 שניות על הלולאה כולה, ואז 408 body_read_timeout שאומר כמה נקרא; ורק POST/PUT/PATCH נבדקות, ולכן GET /healthz עם Content-Length מזויף מחזיר 200 ולא 413 (WARN-002). שני הסירובים נושאים Connection: close, וטסט סדר-התקנה למצב OAuth עומד ליד זה של מצב PAT. התקרה נגזרת: DEFAULT_MAX_REQUEST_BYTES היה מוקלד לצד הערה שגוזרת אותו ביד; עכשיו request_bytes_for(MAX_CODE_SIZE) — פי שישה ועוד מעטפת, מעוגל ל-MiB — גם בעליית השירות מהתצורה בפועל, וטסט בונה את בקשת השמירה הגדולה ביותר (קובץ עברי בגודל המקסימלי) ומודד שהיא נכנסת (SUGG-022). המגביל: הסירוב הוא CallToolResult שלם ולא ערך שעובר ב-convert_result של הכלי, ולכן כלי עם טיפוס החזרה מוצהר או שם כלי לא מוכר מקבלים rate_limited ולא ValidationError או שגיאת SDK (SUGG-009); is None במקום or בבחירת המגביל, כדי ש-ToolRateLimiter(0) לא יוחלף בשקט ב-60 בדקה ברגע שיתווסף __len__ (SUGG-023); טסט מקבילי — 25 קריאות בו-זמנית, תקציב 2, בדיוק 2 עוברות (SUGG-024); RateLimiter אינו יוצר עוד רשומה לזהות ששאלו עליה בלבד, ופנקס האזהרות מנוקה (SUGG-011); ToolRateLimiter.enabled נמחק (YAGNI-001) ו-MCP_MAX_REQUEST_BYTES נשאר כהחלטה סגורה — לא kill switch אלא דרך להעלות את התקרה בלי דיפלוי (YAGNI-002). החיווט נבדק: טסט בתת-תהליך מייבא את mcp_server.app כמו uvicorn, בשני מצבי האימות ועם ריצת בקרה, ומוודא ששני משתני הסביבה ו-MAX_CODE_SIZE מגיעים לאפליקציה הבנויה (WARN-001). ומה שלא נספר: סירובי מכסה אינם נספרים ב-PostHog — ההכרעה קורית לפני התפר שהמדידה עוטפת, וגם סירוב מגוף כלי נרשם שם כהצלחה — התיעוד אומר זאת עכשיו במפורש, והעיצוב פתוח באישו #3442 (WARN-003). קטנות באותו PR: token_count ו-front_matter_end עוברים באותו שער כניסה כמו parse_document (BOM, \r בודד, טיפוס), ולכן generate_ai_map אינו יכול עוד לקבל גבול front matter שחולק על split("\n") (SUGG-019, SUGG-013); הצורה העוינת בסקריפט מדידת הפרסור רצה עם max_sections=None במפורש, כי עם התקרה היא מדדה עצירה (41.0 בתים לבית) ולא את הפרסר (90.1) (WARN-004); _CANDIDATES_MAX מיובא מ-doc_sections במקום להיות מוקלד (SUGG-002); תנאי מת ב-utils.normalize_code ומספר מוקלד בטסט של שורת הקיבולת הוסרו (SUGG-021, SUGG-020); והערות עם מספרים שהתיישנו אחרי המעבר לפרנקפורט אומרות זאת בתאריך (SUGG-005, SUGG-006, SUGG-010). עשר ההצעות שנדחו — באישו #3442. ראו גבולות הבקשה — גודל הגוף והקצב.

  • chore (MCP): יתרת ממצאי הסקירה על #3428 (#3432). שני סירובים חדשים שנוקבים בסיבתם: path_outside_root ב-codekeeper_docs_get_section (עד היום נתיב שיצא מהשורש חזר כ-missing_path, ו-missing_path נשאר לנתיב ריק בלבד) ו-repo_not_mirrored מ-RepoBackend.get_file (עד היום מארח בלי עותק של הריפו חזר כ-not_found, וסוכן ניסה שם אחר בזמן שהבעיה אצל המפעיל). טבלאות המדיניות של הכלי (DOCS_PATH_POLICY, _PARSERS) מיוצאות כ-MappingProxyType, כי הוולידציה בייבוא היא הבטחה רק אם הטבלה אינה משתנה אחריה; זנב עיצוב התשובה של docs_get_section נפרד ל-_answer_from_document (אפס-דיף מדוד על 208 קובצי ה-RST); שתי בדיקות הנרמול של הוולידטור ושורת הלוג על repo_not_configured קיבלו טסטים; טסט ההסכמה בין חיפוש לקריאה כבר אינו דורש שוויון מדויק (המדיניות מצהירה ש-is_denied נשאר שכבה אחרונה), ושני הטסטים תלויי-git מדלגים בלי git באותה צורה. החלטה מפורשת על לוגים לסירובים: סירוב הוא תשובה של הפרוטוקול ולא תקרית, ואף מסלול סירוב בשכבת המטפלים אינו רושם שורה — מתועד ב-שרת ה-MCP — חיבור Claude ל-CodeKeeper. שני ממצאים נדחו בנימוק: תצוגת התצורה אינה יכולה לייבא את docs_handlers (הכיוון services ← mcp_server חד-סטרי), ושני חצאי מדיניות הסודות נשארים בשתי שפות כי אין מנוע אחד לשניהם — מה שמחזיק אותם יחד הוא רשימת תבניות אחת ושני טסטים.

2026-09-20

  • fix: ``codekeeper_docs_get_section`` חוסם את רשימת המועמדים של ``ambiguous_section`` ב-50 (#3426). זה היה השדה היחיד בתשובה בלי תקרה: toc חסום ב-400 ו-suggestions ב-50, ורק המועמדים חזרו כולם — נמדד 13,030 מועמדים ו-1.4MB על שאילתה בת שלושה תווים בעמוד סינתטי. הענף נדלק מכותרות שנושאות מזהה, ומאז #3428 הקורפוס שנושא אותם מוגש. אותו מספר כמו ההצעות ומאותה סיבה (מלאי בסדר הופעה, לא דירוג), והדגל candidates_truncated מופיע רק כשנחתך — כמו suggestions_truncated — ולכן תצלום אפס-הדיף של הכלי על 208 קובצי ה-RST זהה לפני ואחרי. ובאותו PR: טסט שמקבע שגם במסלול ה-Markdown suggestions הוא רשימת מחרוזות ולא ה-NamedTuple (הצרכן השני מ-#3426 הוא אותו אתר קריאה, והוא כותב .titles).

  • fix (MCP): תקרת גודל לגוף בקשה והגבלת קצב לפי זהות, עם סירוב שנוקב בסיבתו (#3431). עד עכשיו המידלוור היחיד היה האימות, וכל משתמש מאומת יכול היה לשלוח בקשות בכל גודל ובכל תדירות. שני גבולות חדשים ב-mcp_server/limits.py: גוף בקשה מעל 1MiB (MCP_MAX_REQUEST_BYTES) נדחה ב-413 body_too_large במידלוור ASGI, לפני שהטרנספורט מפענח JSON — לפי Content-Length ואם היא חסרה או מכזבת, לפי מה שבאמת מגיע; וקריאות כלים מוגבלות ל-60 בדקה לזהות (MCP_RATE_LIMIT_PER_MINUTE) בנקודת השיגור של הכלים — המקום היחיד שרואה את הזהות גם במצב OAuth — ולפני שנתפס חוט, עם rate_limited ו-retry_after_seconds בתשובה. המגביל הוא rate_limiter.RateLimiter הקיים של הבוט, לא עותק. ‏``/healthz`` פטור מבנית משניהם (blanket-policy-silent-block §7), וזה מקובע בטסט. המספרים נגזרו מהמדידות ב-#3431: 0.24 שניות מעבד לעמוד RST עוין של 500KB, 0.47 למסמך ה-Markdown הצפוף, 2.3 לצורה העוינת, מול מכסה של 0.5 מעבד. ראו ”גבולות הבקשה“ ב-שרת ה-MCP — חיבור Claude ל-CodeKeeper.

  • fix (mirror): ‏``get_file_at_commit`` בודק את גודל הקובץ במאגר האובייקטים לפני ``git show``, ולכן קובץ מעל התקרה אינו נטען לזיכרון כלל (#3433, פריט 9). עד היום git show נטען כולו לזיכרון ורק אז max_size נבדק — כלומר התקרה הייתה בדיקה בדיעבד: קובץ של 12MB שנדחה עלה 20MiB שיא בחוט הקריאה לפני שהתשובה הייתה file_too_large. מעכשיו git cat-file -s <sha>:<path> מחזיר את גודל האובייקט בלי לקרוא אותו, שתי הפקודות פונות לאותו קומיט שנפתר פעם אחת (אין חלון לסנכרון להיכנס בו), וקובץ מעל התקרה נדחה לפני שנקרא בית אחד — אותה תשובה, אותו size, אפס זיכרון. כשל בבדיקת הגודל אינו נופל לקריאה בלי תקרה, ומה שמוחזר עדיין נבדק מול התקרה בנפרד, לכל סוג אובייקט. נמדד: 12MB מעל תקרה של 500KB ושל 10MiB — 20.2 ו-20.4MiB לפני, אפס אחרי; 7MB מתחת לתקרה — 14MiB לפני ואחרי, כי אותו כן קוראים. ראו מודל הריצה של הכלים.

  • chore (MCP): ארבעה פריטים קטנים מסקירת #3429 (#3433). שורת הקיבולת של מאגר הקריאות קוראת את ThreadPoolExecutor._max_workers הפרטי דרך _installed_width, וכשהמאפיין ייעלם היא אומרת ”unreadable“ לצד הרוחב שהתבקש עם WARNING, במקום שהשירות לא יעלה בגלל שורת לוג (SUGG-004); ‏``scripts/measure_md_parse_cost.py`` מודד צפיפות דרך md_parser.token_count הציבורית — על המופע שהכלי מריץ — במקום לקרוא ל-_build_parser הפרטית ולבנות פרסר לכל קובץ (SUGG-010); שני טסטים חדשים מקבעים שקובץ memory.max שקיים אבל ריק או לא-מספרי נופל ל-cgroup v1 (SUGG-014); ואסרשן שלא יכול היה ליפול הוחלף בטסט שמצמיד os.cpu_count ל-16 כדי שה-fallback ייבדק מול 20 ולא מול עצמו (SUGG-001).

  • fix (parsers): ‏``rst_parser.parse_document`` בודק את הקלט בכניסה, וברירת המחדל של ``max_sections`` מיושרת לזו של ``md_parser`` (#3421, #3420). עד היום rst_parser.parse_document(None) החזיר מסמך ריק בשקט — מפה ריקה שמתחזה למפה של קובץ בלי כותרות — ו-17 נפל ב-AttributeError גולמי, בעוד md_parser זרק TypeError שאומר מה התקבל. מעכשיו שני הפארסרים עוברים באותה בדיקה, doc_sections.require_str, ומרימים את אותה חריגה עם אותן מילים; אף קורא לא נשען על הצורה הישנה (המטפל, הסורק והסקריפטים מעבירים תמיד מחרוזת). ובאותו PR ההכרעה על ברירת המחדל: max_sections ב-rst_parser היה None (בלי תקרה) כי הפרמטר נוסף לפארסר שכבר רץ בייצור, ואילו ב-md_parser הוא MAX_SECTIONS — כלומר קורא ששכח להעביר תקרה קיבל הגנה מהפארסר האחד ולא מהשני. עכשיו שניהם על אותה ברירת מחדל, MAX_SECTIONS שעבר ל-services.doc_sections ומיוצא משני הפארסרים, ו-codekeeper_docs_get_section אינו מעביר תקרה לאף אחד מהם — וזה מחליף את מה שכתוב ברשומת הקריאה של Markdown שלמטה (”RST דרך התקרה שהכלי מעביר מאז #3429“): מאז השינוי הזה הכלי אינו מעביר תקרה, וברירת המחדל של הפרסר היא שעוצרת. נמדד, לא הונח: על כל 208 קובצי ה-RST ב-docs/ הקובץ העשיר ביותר נושא 50 סקשנים מול תקרה של 50,000 (אחד לאלף), ופלט הכלי על כולם — 5,931 רשומות — זהה בית-בית לפני ואחרי. סורק האאוטליין ממשיך להעביר את התקרה שלו במפורש, וטסט מקבע זאת. ראו ”שני סירובים שמגיעים מהפרסור עצמו“ ב-שרת ה-MCP — קריאה, פרסור וחיפוש בתוכן.

  • refactor: שלושה כללים שנכתבו פעמיים חזרו למקום אחד (#3419, #3427). ‏(1) כלל ה-\r הבודד — סיומת שורה שאינה חד-משמעית — ישב גם במנתב האאוטליין וגם בפארסר ה-Markdown, ושני העותקים היו צריכים להסכים לנצח; עכשיו הוא במודול עלה חדש, services/line_endings.py, ושני הצרכנים קוראים לו. ‏(2) scripts/generate_ai_map.py כתב ביד את גבול ה-front matter ונמדד שהוא חולק על התוסף ש-MyST מריץ בחמש מתוך שתים-עשרה צורות; עכשיו הוא קורא את הגבול מהפארסר של הכלי (md_parser.front_matter_end, דרך mdit_py_plugins.front_matter), ו-AI-MAP.md שנוצר זהה בית-בית לזה שבריפו — הטסט שקיבע את הפער בכוונה נערך יחד עם הסגירה. ‏(3) שתי רשימות זהות של 16 קודי תווים נסתרים — ב-utils.normalize_code וב-CodeNormalizer — לא הוסיפו דבר על בדיקת unicodedata.category == "Cf" שישבה מתחתן (כל 16 הערכים הם Cf); הרשימות נמחקו, שתי הפונקציות אוחדו ל-strip_hidden_escapes אחת בשכבת הדומיין, וענף ה-Variation Selectors (Mn, לא Cf) נשאר נפרד ונדלק רק לפי בקשה. לשני הנרמולים אפס-דיף מדוד על קורפוס של רצפי בריחה, בכל צירוף אפשרויות.

  • feat: ``codekeeper_docs_get_section`` קורא גם קובצי Markdown, ולכל ריפו מדיניות נתיבים משלו. עד היום הכלי ידע לקרוא .rst בלבד, ורק מתחת ל-docs/. הפארסר של Markdown נכתב ונמדד כבר קודם — ואף אחד לא קרא לו; זה השינוי שמחווט אותו. מעכשיו הסיומת בוחרת את הפארסר, ולכל ריפו מוצהר איפה התיעוד שלו יושב ובאיזה פורמט: CodeBot נשאר docs/ עם .rst ללא שינוי, ו-amir-bug-patterns מגיש .md משורש הריפו. וזו הרחבה מכוונת של גבול הקריאה — הכלי ציבורי, כלומר כל משתמש מאומת מפעיל אותו בלי אדמין, והריפו שנוסף ציבורי ב-GitHub. מה ש**לא** השתנה: מדיניות סינון הסודות חלה על המסלול הזה במלואה, ולכן path="secrets" מחזיר path_denied ולא not_found, וגם secrets.md ו-credentials.md חסומים; ותקרת 500KB של שירות המראה נשארת ההגנה על הפרסור, כי הכלי קורא את הקובץ כולו בלי lines. שני שערים ולא אחד: MCP_DOCS_REPO מתיר בזמן ריצה, טבלת המדיניות בקוד יודעת לקרוא, וריפו שנמצא במשתנה הסביבה ואין לו מדיניות נדחה ב-repo_not_configured במקום ליפול לברירת מחדל מתירנית. ובקשה לפורמט שהריפו אינו מגיש נדחית בשמה — suffix_not_allowed עם רשימת הסיומות שכן מוגשות, במקום להשלים סיומת בשקט מעל הקיימת ולחזור כ“לא נמצא“ על קובץ שקיים. שני סירובים חדשים מגיעים מהפרסור עצמו: inconsistent_line_endings על \r בודד (CRLF עובד במלואו), ו-too_many_sections על קובץ שחוצה את תקרת 50,000 הכותרות — Markdown דרך ברירת המחדל של הפרסר, ו-RST דרך התקרה שהכלי מעביר מאז #3429; סירוב שהפארסר מספק לו מספר שורה נושא גם line — תמיד ב-Markdown, ולא ב-too_many_sections של RST, כי rst_parser מרים אותה בלי מספר. includes הוא שדה של RST ולכן בעמוד .md הוא תמיד ריק. ומסלול ה-RST לא זז: אפס דיף מדוד על 5,920 רשומות מ-208 קובצי RST, לפני ואחרי. ראו איזה קובץ docs_get_section קורא, ובאיזה ריפו.

  • fix: מאגר הקריאות של ה-MCP נגזר ממכסת הזיכרון של הקונטיינר, ולא ממספר המעבדים של המארח (#3391). כלי הקריאה רצים ב-asyncio.to_thread, כלומר ב-executor ברירת המחדל של הלולאה, שגודלו min(32, os.cpu_count() + 4) — ו-os.cpu_count() בקונטיינר הוא מספר הליבות של המארח, כפי ש-CPython מתעד במפורש. שורת הקיבולת מהייצור אמרה את זה במספרים: read pool 12 threads (os.cpu_count=8, usable=8) על מכסה של 0.50 cpu. לקריאת מונגו זה לא מזיק; לפרסור בפייתון טהור אין מקביליות ב-CPU בגלל ה-GIL, ולכן 12 חוטים היו 12 עצי פרסור בזיכרון בו-זמנית — יותר ממה שנכנס ב-512MiB — ורגע לפני שהפרסור הופך לכלי ציבורי. מעכשיו attach_read_pool מתקין בעליית ה-lifespan של אפליקציית ה-ASGI מאגר משלו, בגודל (מגבלת הזיכרון − קו בסיס − שוליים) ÷ עלות פרסור אחד: המגבלה נקראת מ-cgroup בזמן ריצה (memory.max ב-v2, ‏``memory.limit_in_bytes`` ב-v1) ולא מקובעת בקוד, קו הבסיס והשוליים הם מדידות מהשירות בייצור עם תאריך, ועלות הפרסור נגזרת מ-MAX_FILE_SIZE_FOR_DISPLAY כי הכלי דוחה too_large לפני שהוא מפרסר. על תוכנית הייצור זה 10 חוטים במקום 12 — עלות הפרסור נמדדה מחדש על הפרסר הנעוץ (scripts/measure_md_parse_cost.py; הקבוע נמדד על services.md_parser כהכנה לכלי ה-Markdown של PR 5, בעוד הכלי הציבורי היום מפרסר RST ב-services.rst_parser, שעולה כ-6 בתים לבית גם על העמוד הצפוף ביותר — והסקריפט מודד את שניהם), והיא תלויה בצפיפות הטוקנים של המסמך ולא בגודלו: המסמך הצפוף ביותר בקורפוס הוא הקבוע, וצורה עוינת של שורות-תבליט בודדות עולה פי ארבעה ממנו — מה ששום רוחב מאגר אינו סופג, ומחכה לתקרת טוקנים בפרסר עצמו. ובעקבות הסקירה: codekeeper_docs_get_section מעביר לפרסר את תקרת הסקשנים של האאוטליין (50,000) ומחזיר too_many_sections במקום לפרסר את הקובץ כולו — צורה עוינת של RST (כותרת בת תו אחד בכל שורה) עלתה 44.0MiB לפרסור, יותר מ-35.2MiB שהמאגר מקצה לחוט, ועכשיו נעצרת ב-20.1MiB; אף עמוד אמיתי אינו מתקרב לתקרה. רצפה של 2 (קריאה תקועה אחת לא משביתה את השאר), תקרה של 12, הרוחב שהייצור כבר הריץ (מעבר לתוכנית גדולה לא מרחיב את המאגר בלי החלטה; הגרסה הראשונה נקבה ב-32, והסקירה של #3429 הורידה אותה כי המחלק מתאר את הפרסור ולא את קריאות הטווח של האדמין; חסימת הקריאה במקור — #3433), וכשאין מגבלה קריאה — הרצפה, לא cpu_count + 4, עם WARNING שאומר שזה קרה. ושורת הקיבולת מפסיקה לחשב בעצמה: היא נרשמת מתוך ה-lifespan, קוראת את _max_workers של המאגר שהותקן בפועל, ומדווחת גם את מגבלת הזיכרון לצד מכסת ה-CPU — כי רשומה שמתארת מצב ומתעדכנת בנפרד ממנו היא בדיוק מה שמשקר בשקט. ה-seam הוא עטיפת router.lifespan_context, אותו seam שניקוז ה-PostHog כבר משתמש בו, כי FastMCP.streamable_http_app() בונה את Starlette עם lifespan= משלה ו-on_startup אינו רץ. הטסט המרכזי נכנס ל-lifespan של האפליקציה האמיתית ומוכיח שקריאת to_thread נוחתת על חוט של המאגר החדש — לא שפונקציה נקראה; שורת הקיבולת נבדקת בתת-תהליך נקי דרך הפלט האמיתי ולא דרך caplog. ראו מודל הריצה של הכלים.

  • feat: ``codekeeper_docs_get_section`` מוצא סעיף גם לפי המזהה שלו, ולא רק לפי השם המלא. הסוכנים מפנים זה לזה לפי מזהה — ”קרא K11“, ”ראו U3“ — ועד היום section="K11" החזיר section_not_found עם רשימת הצעות ריקה, כי ההתאמה הייתה שוויון מלא ו-difflib עם cutoff=0.5 אינו מוצא קרבה בין שלושה תווים לכותרת עברית ארוכה. כלומר הזרימה המרכזית של הכלי לא עבדה. מעכשיו, ורק אחרי שהשוויון המלא לא מצא כלום, שאילתה שבנויה כמזהה (עד שלוש אותיות ואחריהן עד שלוש ספרות, עם נקודה אופציונלית) מותאמת לכותרת שנפתחת באותו מזהה. והמזהה נקרא כיחידה ולא כקידומת של מחרוזת, ולכן K1 מחזיר את K1 בלבד ולעולם לא את K10 עד K15 — הצורה השבורה של הבדיקה הזאת היא אותה מחלקה בדיוק שבה גבול נתיב נבדק כרצף תווים. שאילתה שאינה בנויה כמזהה אינה עוברת במסלול הזה כלל, ולכן section="איך" ממשיך להחזיר אפס התאמות גם בעמוד שיש בו חמש-עשרה כותרות שמתחילות במילה הזאת. מזהה שחוזר פעמיים הוא ambiguous_section עם מועמדים, כמו כל כותרת כפולה, ושאילתת מזהה שלא נמצאה מקבלת ב-suggestions קודם כול כותרת קרובה, אם יש כזו בעמוד, ורק כשאין אף כותרת קרובה את המזהים שכן קיימים — עד 50, ועם suggestions_truncated כשהיו עוד. והתקרה גבוהה בכוונה, כי רשימת מזהים אינה מדורגת: לשאלה ”אלה שכן קיימים“ אין תשובה ”החמש הטובות“, וחיתוך שלה מסתיר פריטים בלי קריטריון ובלי דרך לבקש את השאר. והדגל הזה אומר את אותו דבר בשני המסלולים: גם רשימת מזהים שנחתכה וגם רשימת כותרות קרובות שנחתכה מדליקות אותו. שדה בשם truncated שמשמעותו ”נחתך“ במסלול אחד ו“שקט“ בשני הוא בדיוק ההפתעה שאנחנו מנסים למנוע. ונקודה עוד יותר קלה לפספס: הנקודה שפותחת תת-מספור אינה גבול. בכותרת K11. טקסט הנקודה מסיימת את המזהה, ובכותרת K11.1 טקסט היא מפרידה בתוך מזהה ארוך יותר — ולכן K11 לעולם אינו מחזיר את K11.1, וכותרת בתת-מספור נגישה בשמה המלא בלבד. זו אותה מחלקה בדיוק כמו K1 שתופס את K10: גבול שנבדק כתו בודד, בלי לשאול מה בא אחריו. ההתנהגות על התיעוד כאן לא זזה, וזה נמדד ולא הונח: הפלט של הכלי על כל קובצי ה-RST — כל כותרת, בכל צורותיה — זהה בית-בית לפני ואחרי. וההנחה שהכול נשען עליה, שאף כותרת בעמודים כאן אינה נפתחת במזהה, אינה ספירה שנרשמה פעם אחת אלא טסט שרץ בכל CI: tests/test_docs_headings_carry_no_identifier.py סורק את כל העמודים ונופל על כותרת שנפתחת במזהה, עם דוגמת autodoc אמיתית שמוכיחה שהוא מסוגל ליפול. ומה שלא נבדק בקורפוס הזה נבדק בבקרה סינתטית, כי סוללה שכל תשובותיה ”לא נמצא“ אינה מבדילה בין ענף כבוי לבין פרובים עיוורים. שני הדברים שמפתיעים קורא — קיצור המזהה, וכותרת שנושאת בקטיקים ולכן דורשת אותם בשאילתה — עברו לתיאור הפרמטר section, שאינו נחתך אצל הלקוח כמו תיאור הכלי. ראו איך docs_get_section מוצא כותרת.

  • feat: גרסה קודמת היא עמוד שאפשר לפתוח, לא רק לשחזר. בבוט אפשר היה לפתוח כל גרסה ולראות אותה; בווב-אפ גרסה ישנה הייתה משהו שאפשר רק לשחזר, או לראות בדיף מול הנוכחית. מעכשיו כל שורה בהיסטוריית הגרסאות מקשרת אל הגרסה עצמה, והיא נפתחת ב**אותו עמוד קובץ** ובאותה תצוגת Markdown — אותה הדגשת תחביר, אותו מסלול הברחה ואותה בדיקת בעלות, כי לא נבנה מסלול תצוגה שני. בראש העמוד באנר שאומר באיזו גרסה מדובר ומתי נשמרה, עם מעבר לגרסה הנוכחית, השוואה אליה ושחזור; פעולות שמשנות מצב מוסתרות שם, כי כולן פועלות על המסמך שבכתובת. ברשימת ההיסטוריה אפשר גם לסמן שתי גרסאות ולפתוח דיף בין שתיהן — דף ההשוואה תמיד ידע לקבל ?left= ו-?right=, ומה שהיה חסר הוא הדרך להגיע לשם. בדרך תוקנו שלושה דברים שהיו שקטים: ?left=abc הציג דיף של גרסה אחרת בלי לומר דבר, כי type=int של Flask מחזיר את ברירת המחדל בשקט; שלושה מקומות חישבו בנפרד אילו שתי גרסאות מוצגות, כך שהרשימה הנפתחת והדיף יכלו לומר דברים שונים; ולשאילתה ”מהי הגרסה האחרונה של הקובץ“ לא היה אינדקס תומך, אף שהיא רצה גם בכל שמירה. compare.js ו-compare.css הוגשו בלי מזהה גרסה מול max-age של שנה, כלומר שינוי בהם לא היה מגיע למי שכבר ביקר בדף; זה תוקן, ויש טסט שמונע תגית חדשה כזו. ראו גרסאות: צפייה והשוואה.

2026-09-17

  • feat: ‏``description_age_versions`` — כמה גרסאות עברו מאז שהתיאור נקבע. תיאור של קובץ התיישן בשקט: codekeeper_edit_file ו-codekeeper_append_file מעבירים את התיאור הקיים לגרסה החדשה — ברירת מחדל נכונה — ולכן תיאור שנכתב בגרסה 1 נראה בגרסה 11 בדיוק כמו תיאור שנכתב אתמול, ולא הייתה שום דרך לדעת שכדאי לבדוק אותו בלי לקרוא את כל הקובץ. השדה מוחזר ב-codekeeper_list_files, ב-codekeeper_search_code וב-codekeeper_get_file, והוא רמז לבדוק ולא קביעה שהתיאור שגוי: עשר עריכות קטנות אינן הופכות תיאור לשגוי, ועריכה אחת גדולה כן יכולה. null אומר שהגיל לא ידוע ולעולם לא 0, ולקובץ בלי תיאור השדה נעדר לגמרי. שתי ההיטלות של הרשימה והחיפוש לא החזירו version כלל, ולכן הורחבו — בלעדיהן הגיל היה null בכל שורה, דווקא במסלול שהוא נועד לו. codekeeper_update_file_description מסמן מעכשיו את התיאור כנבדק ומאפס את הגיל גם כששולחים את אותו טקסט, ומחזיר unchanged: true כדי שיהיה גלוי ששום דבר לא השתנה מלבד החותמת. לקבצים שנשמרו לפני השדה יש מיגרציה חד-פעמית, scripts/migrate_description_set_at_version.py, שמשחזרת את החותמת מהיסטוריית הגרסאות ומשאירה null כששרשרת הגרסאות קטועה. ראו גיל התיאור — description_age_versions.

  • fix: ‏stderr של ``git grep`` מנוקז תוך כדי הקריאה, בשני המעברים (#3398). stderr=PIPE שאיש לא קורא ממנו הוא צינור בן 64KB; ריפו עם אובייקטים חסרים מדפיס שתי שורות error: לכל קובץ, וגיט נחסם ב-write עד תום התקציב — כשל צינור שדווח כ-timeout ובלי לוג על הסיבה. האישו נסגר בלי שהקוד השתנה; זה המימוש, במחלקה אחת שמשרתת גם את איסוף התוצאות וגם את הספירה. בדרך נתפס גם מה ש-stderr מגלה: בלוב חסר גורם ל-git grep לדלג ולצאת ב-0, וקוד היציאה לבדו היה מכריז על total מדויק שחסר בו קובץ — היום זה total_at_least. וכשל של המנוע אחרי שכבר אסף תוצאות חזר עד היום כתשובה תקינה עם truncated: false ובלי אף שדה ספירה; היום מה שנאסף מוגש עם search_failed, או sync_in_progress אם sync רץ.

  • feat: ‏``case_sensitive`` ב-``codekeeper_search_repo``. הפרמטר היה קיים לכל אורך המנוע, אבל שכבת ה-MCP לא העבירה אותו — ולכן git grep רץ תמיד עם -i ולא הייתה דרך להבדיל בין Config ל-config. הדגל הוא תוספתי (ברירת מחדל false, בדיוק ההתנהגות שהייתה), חל גם עם regex=true, ו**גם על הספירה**: מופע שהוא מוציא מהתוצאות אינו נספר ב-total. בדרך תוקן גם תיאור הכלי, שאמר ”matched literally — every character is itself“ בלי לומר שהרישיות נבלעת. ראו כמה מופעים יש באמת (total מול total_at_least).

  • fix: ‏``total`` ב-``codekeeper_search_repo`` הפסיק לשקר. השדה היה שווה ל-count תמיד — max_results=3 החזיר total: 3 בין אם יש בריפו שלוש התאמות ובין אם אלפיים — כי אחרי שנאספו מספיק תוצאות התהליך נהרג ואיש לא ספר את השאר. זו הייתה מלכודת ולא רק חוסר: באותו שרת, query= של codekeeper_get_file מחזיר בשדה בעל אותו שם את הסך האמיתי. היום total הוא מספר המופעים בריפו, ו**קיים רק כשהוא מדויק**; כשהספירה נקטעת חוזרים total_at_least ו-truncation_reason במקומו, ולעולם לא שניהם יחד. ראו כמה מופעים יש באמת (total מול total_at_least).

  • feat: קוד חיצוני וקבצים מקומפלים מוחרגים מהחיפוש בריפו, וניתן להחזיר אותם. node_modules בכל עומק, וגם *.bundle.js, *.min.js, *.min.css ו-*.map, אינם נסרקים ואינם נספרים כברירת מחדל — נמדד: באנדל אחד החזיק 64% מהמופעים של function בריפו. הם — הוא מילא חיפושים רחבים ודחק את הקוד שבאמת נכתב בפרויקט. include_vendored=true מחזיר אותו. ההחרגה יושבת במנוע, ולכן היא חלה גם על החיפוש בדפדפן הריפו בוובאפ, וקבצים כאלה ממשיכים להיקרא כרגיל ב-codekeeper_get_repo_file. אפס תוצאות אינו אומר שהמחרוזת לא קיימת בריפו, וזה כתוב גם בתיאור הכלי.

  • fix: חיפוש רחב בריפו הפסיק להיכשל על בייט שאינו UTF-8. הפלט של git grep פוענח ב-strict, ולכן קובץ טקסט אחד עם בייט חריג (docs/images/onboarding-flow.svg כאן) הפיל את כל החיפוש ל-search_error — תשובה ריקה על חיפוש תקין. עד היום זה הוסתר בכך שהזרם נהרג מוקדם, ומעבר הספירה החדש היה חושף את זה בכל חיפוש רחב.

  • fix: קובץ חסום במדיניות הסודות אינו נסרק ואינו נספר. הסינון קרה על התוצאות אחרי החיתוך, ולכן קובץ חסום בין ההתאמות הראשונות הקטין את התשובה בלי לומר דבר. ההחרגה נכנסת עכשיו ל-git grep עצמו, ונגזרת מאותה רשימת תבניות שחוסמת קריאה — לא מרשימה שנייה; הסינון על התוצאות נשאר כשכבה אחרונה.

2026-09-16

  • feat: ‏``codekeeper_update_file_description`` — סוכן יכול לרענן תיאור של קובץ קיים. עד היום התיאור נקבע רק ב-codekeeper_save_file, שמסרב לקובץ שכבר קיים, ול-codekeeper_edit_file ול-codekeeper_append_file אין פרמטר description — הם מעתיקים את הקיים לגרסה החדשה. כלומר תיאור שהתיישן ביחס לתוכן היה ניתן לתיקון רק מהדפדפן. הכלי החדש מקבל file_name ו-description בלבד, ומחזיר את התיאור הקודם, את החדש ואת מספר הגרסה שלא השתנה. הוא אינו יוצר גרסה, ולכן התיאור הקודם אינו נשמר בהיסטוריה ואינו ניתן לשחזור — התשובה מחזירה אותו כי זה המקום היחיד שבו הוא עוד קיים; ורק הגרסה האחרונה מתעדכנת, כך שקריאה של גרסה קודמת מחזירה את התיאור שהיה בה. שלוש ההצהרות האלה כתובות בתיאור הכלי עצמו, כי דוקסטרינג שקרי גרוע מחסר. תיאור ארוך מהמותר נדחה ואינו נחתך (description_too_long עם ה-max): הראוט בוובאפ חותך כי אדם רואה את התיבה, וסוכן אינו רואה את התוצאה. ראו עדכון תיאור בלי גרסה חדשה.

  • refactor: ”עדכון תיאור מהיר“ בוובאפ והכלי החדש חולקים מסלול כתיבה אחד. POST /api/file/<id>/quick-update החזיק update_one משלו ישירות מול code_snippets, ולא עבר דרך שכבת ה-repository. כלי שני לאותה כתיבה היה הופך את זה לשני עותקים שרק אחד מהם יקבל את התיקון הבא, ולכן הלוגיקה חולצה ל-database.repository.update_file_metadata_in ושני הערוצים קוראים לה. ההתנהגות כלפי הדפדפן לא זזה — אותו 404, אותה חתימת updated_at (רק כשהתיאור נכלל, לא על תגיות), ואותם שדות בתשובה. בדרך נסגר גם חלון TOCTOU: הבעלות נבדקה ב-find_one נפרד לפני ה-update_one, והיא עברה לתוך הפילטר של find_one_and_update עצמו.

  • fix: עדכון תיאור השאיר את החיפוש מגיש את התיאור הישן עד חמש דקות. הראוט של העדכון המהיר קורא רק ל-cache.invalidate_file_related, ורשימת הדפוסים שלה כיסתה את user_files, latest_version ו-web:files — אבל לא את search_code, שה-cache שלו הוא 300 שניות. ‏``invalidate_user_cache`` תפסה אותו ממילא דרך fallback רחב שיש שם ואין כאן, ולכן הפער היה גלוי רק בהשוואה בין שתי הרשימות. נוספו search_code, regular_files ו-files_by_repo — שלוש הרשימות שמחזירות description של הגרסה האחרונה, כלומר אותה מחלקה ולא מופע בודד.

2026-09-15

  • fix: כלי ה-MCP רצו כולם על לולאת האירועים, ובקשה אחת איטית השתיקה את כל הסשנים. ה-docstring של mcp_server/server.py הצהיר שנים ש“FastMCP מריץ כלים סינכרוניים ב-worker thread“, וזה פשוט לא נכון — האמונה השגויה הזאת היא הסיבה שאיש לא בדק. נמדד מול ה-SDK המותקן (mcp 1.28.1, func_metadata.call_fn_with_arg_validation): פונקציית כלי אסינכרונית נקראת await fn(...), וסינכרונית נקראת return fn(**arguments_parsed_dict) — ישר, בלי to_thread בשום מקום במסלול. כלומר גוף כלי שרץ שנייה אחת עצר את כל התהליך ולא רק את הקורא שלו, וזו מחלקת השבתה משותפת ולא בקשה איטית. התיקון יושב במקום אחד: AdminAwareFastMCP.add_tool עוטף כל גוף סינכרוני בזמן הרישום, ושני מסלולי הרישום (@mcp.tool ו-add_tool ישיר) עוברים שם — אומת ב-SDK. ולא בגוף של כל כלי בנפרד, כי כל אתר קריאה הוא הזדמנות לשכוח, והכלי הבא היה נולד שוב על הלולאה; במקום זה יש טסט שדורש שכל כלי רשום יהיה coroutine function, כך שרגרסיה נופלת בקול. ושני יעדים ולא אחד: קריאה הולכת ל-asyncio.to_thread ולמאגר המשותף, וכתיבה למאגר ייעודי בעל worker יחיד. כך גוף כתיבה אחד רץ בכל רגע — הסדר שהיה לכלים כשהכול ישב על הלולאה — והתור מוסר אותם לפי סדר ההגעה. גרסה ביניים ניסתה מנעול ברמת התהליך במקום מאגר, והמדידה פסלה אותה: כותב שחסום על מנעול עדיין תופס חוט מהמאגר המשותף, ולכן ב-40 כתיבות מקבילות קורא חיכה 16.51 שניות (20.02 לפני התיקון כולו) — ועם מאגר ייעודי הוא חוזר ב-0.00. גם הסדר: 16 כותבים על פני 30 סבבים יצאו מחוץ לסדר ב-25 סבבים תחת המנעול, ובאפס עם המאגר. שלושה דברים אומתו שהם שורדים את הקפיצה ולא הונחו: הסכימה המפורסמת (functools.wraps שומר על __wrapped__, כולל הזרקת Context), ctx.request_context (מאפיין של האובייקט, לא contextvar), ו-get_access_token() — שכן contextvar. asyncio.to_thread מעתיק את ההקשר בעצמו, loop.run_in_executor אינו מעתיק, ולכן מסלול הכתיבה מעתיק אותו במפורש; בלי זה require_admin/require_write מפסיקים לראות מי שואל. ומה שהשתנה בסמנטיקה, במפורש: קריאות יכולות להשתלב עכשיו זו בזו, וזו התוצאה המכוונת. כתיבות אינן, אבל כתיבות של משתמשים שונים ממתינות בתור אחד — המחיר, והוא כתוב בקוד ובתיעוד. כתיבה שבוטלה בעודה בתור אינה רצה כלל; כתיבה שבוטלה אחרי שהתחילה רצה עד הסוף. פער ה-read-then-write בבחירת מספר הגרסה (U1 וריאציה b) אינו נעשה שגוי בגלל השינוי, אבל הוא מפסיק להיות מוסתר מ-MCP, והוא ראוי לתיקון משלו. ומיפוי בטיחות החוטים נעשה לפני המיזוג, כפי שהאישו דורש: pymongo בטוח לחוטים ואין motor בכל mcp_server, המצב ברמת המודול הוא קבועים לקריאה בלבד, אין threading.local, והשירות רץ תחת uvicorn בלי monkey-patching של gevent. סוגר את #3379 — חסם השורות בפרסור נשאר פתוח, ומתועד בסורקים.

  • fix: תיאור codekeeper_get_repo_file היה ארוך מכדי שהלקוח יגיש אותו, והסוף — שפות האאוטליין ו-symbol= — נחתך. התיאור הגיע ל-2,482 תווים, פי 3.8 מהכלי השני בגודלו (652) ופי שמונה מהחציון (303), ונמדד שהוא מגיע לסוכן חתוך באמצע המשפט על RST ועל symbol=. כלומר שני פיצ’רים עבדו ואף לקוח לא קרא עליהם — בדיוק מחלקת הכשל שהמשפטים האלה נכתבו כדי למנוע. הפתרון הוא העברה ולא מחיקה: כל משפט שם נולד מבאג אמיתי ויש עליו טסט, ולכן הפירוט על השפות עבר לתיאור הפרמטר outline והפירוט על הסינון לתיאור הפרמטר symbol, ששניהם יושבים ב-inputSchema ואינם מתחרים על תקציב התיאור. סך שלושת השדות גדל (2,711 מול 2,482) — אף לקח לא נמחק — ותיאור הכלי ירד ל-1,125. ונוסף טסט תקרה על כל 29 הכלים, כי זו מחלקת בעיה ולא מופע; הוא רץ על _tool_manager.list_tools() ולא על mcp.list_tools(), שמסנן את כלי האדמין ומחזיר 22 — ושבעת החסרים כוללים את codekeeper_get_repo_file עצמו, כלומר טסט על התצוגה המסוננת היה ירוק בלי לכסות את המקרה היחיד שהפיל אותנו. ומה שנמדד, כדי שלא ייקרא כאן יותר ממה שכתוב: שהשרת שולח את תיאורי הפרמטרים במלואם ב-mcp==1.28.1 (עם ריצת בקרה שבלי Field השדה חוזר None), ושהזרקת context של PostHog אינה דורסת אותם — לא מה שלקוח מציג מהם.

  • fix: טסט התקרה תפס כלי שני יומיים אחרי שנכתב — codekeeper_get_file עבר את הסף. הפרמטר query נוסף עם תיאור בן 1,376 תווים שצורף לתיאור הכלי, והביא אותו מ-349 ל-1,726 — כלומר סופו נחתך אצל הלקוח, בדיוק כמו ב-codekeeper_get_repo_file. זה מה שהופך את התקרה ממופע בודד ל**מחלקת בעיה**, ולכן התרופה זהה: _QUERY_DOC עבר ל-Field(description=...) של הפרמטר query, ותיאור הכלי ירד ל-464 תווים עם משפט שמפנה לפרמטר. _RANGE_DOC לא נגע — הוא משותף לשני הכלים ו-קריאת טווח שורות מחייב שיתארו את lines= באותן מילים. ומה שההשוואה משפט-משפט מול הנוסח הישן העלתה: הפסוקית ”symbol= filters on that full name“ נשמטה בסבב הקודם, והיא נושאת מידע — הסינון הוא על השם המנוקד השלם ולא על החלק האחרון שלו, ולכן symbol="method" מוצא גם Class.method. היא הוחזרה. ומבחן מוטציה מצא assertion שלא הייתה מסוגלת ליפול: "query" in description עברה גם אחרי מחיקת ההפניה, כי התיאור נושא ממילא את הדוגמה query="..." — היא הוחלפה בבדיקה על ההפניה לשם הפרמטר.

  • fix: page/per_page היה הפיצ’ר היחיד בתיאור בלי אף טסט, ונשמט בטיוטה הראשונה של הפיצול בלי שאף בדיקה שמה לב. הוא הוחזר לתיאור הפרמטר outline עם טסט שישמור עליו. עמוד ראשון שנראה כמו כל המפה הוא כשל שקט: OUTLINE_PER_PAGE_DEFAULT הוא 100, ולכן 486 הסימבולים שנמדדו על הקובץ הצפוף בקורפוס מתפרסים על חמישה עמודים. באותה הזדמנות נוספה בדיקה על ה-escape עצמו ב-services.backup\_service, שעד כה נבדק רק דרך symbol="backup_service" — טענה שעוברת גם על טקסט שאיבד את הלוכסן, כלומר בדיוק מה שקורה בהעתקה דרך שכבת escaping.

  • fix: שלוש שתיקות בקריאת קובץ — שאילתה שלא יכלה להתאים, פרמטר שנזרק, וקריאה שנספרה בעמודה הלא נכונה. שלושתן חלקו צורה אחת: התשובה נראתה תקינה, לא הייתה שום שגיאה, ומי שקרא לא היה יכול לדעת שמה שביקש לא קרה. (א) שאילתה רב-שורתית. ההתאמה ב-query נעשית שורה אחר שורה, ולכן מחרוזת שיש בה \n אינה יכולה להתאים לעולם — ואפס מופעים מוצהר כ**הצלחה**. נמדד: query in text הוא True בעוד התשובה מדווחת total: 0 עם ok. זה לא קצה, אלא בדיוק מה שסוכן מייצר כשהוא מדביק קטע מקובץ שקרא לפני רגע. נדחית עכשיו כ-query_multiline; דחייה ולא תמיכה, כי כל רשומה עוגנת ל-line אחד ולהתאמה שחוצה שורות אין line מוגדר. (ב) ``context_lines`` ו-``max_results`` בלי ``query``. נמדד שקריאה עם context_lines=5 בלי query מצליחה ומחזירה את הקובץ המלא, ומפתחות התשובה הם בדיוק ['file', 'found'] — כלומר הפרמטר נזרק בלי סימן. זו אותה שתיקה שהשינוי הזה עצמו אוסר על query``+``lines. והשורש היה בברירות המחדל: 0 ו-50 לא אפשרו להבדיל בין ”לא נשלח“ לבין ”נשלח בדיוק הערך הזה“, ולכן אי אפשר היה לדחות. שתיהן null עכשיו, ההצמדה מותנית, והסירוב יושב בראש הקריאה ב-backend לפני הגישה למסד — context_lines_without_query או max_results_without_query, שני קודים כדי שהקורא ידע איזה. הסכימה שהלקוח רואה משתנה בהתאם, וזה הפרש מכוון מ-codekeeper_search_repo. (ג) עמודת ``ck_read_mode``. הקולבק של האנליטיקס שאל ”מה נשלח“ במקום ”מה הכלי הזה בכלל מקבל“, והוא מקבל את מילון הארגומנטים הגולמי — לפני ש-pydantic מסלק ממנו מפתחות שאינם בסכימה. נמדד בארבעה צירופים: codekeeper_get_repo_file עם query תועה נספר כ-query, ו-codekeeper_get_file עם outline תועה נספר כ-outline — והחצי של ``outline`` קדם לפיצ’ר ``query`` לגמרי. לא רק שהעמודה השגויה מתנפחת: שתי האחרות יוצאות חסרות באותה מידה, וזו בדיוק העמודה שנבנתה כדי למדוד עלות ניווט. השיוך מפורש עכשיו לפי כלי, FILE_READ_TOOLS נגזר ממנו במקום להיכתב פעמיים, וטסט שואל את הכלים הרשומים עצמם אילו פרמטרי קריאה הם מצהירים עליהם ומשווה — כלי שיקבל מחר query בלי שהמפה תעודכן מפיל את הבדיקה במקום להיספר בשקט במקום הלא נכון.

  • המספרים בתיאור הכלי נשתלים מהקבועים, ולא נכתבים כטקסט. התיאור הבטיח ”50 כברירת מחדל, עד 100“, ושום בדיקה לא קשרה את המספרים ל-QUERY_RESULTS_DEFAULT ול-QUERY_RESULTS_MAX. העלאת תקרה הייתה משאירה כל סוכן מגביל את עצמו למספר שכבר אינו התקרה, עם סוויטה ירוקה. בניית התיאור עברה לפונקציה _build_query_doc דווקא כדי שהטענה תהיה בת-הפרכה: הבדיקה מריצה את הבנייה עם קבועים אחרים ורואה את הטקסט זז, במקום להשוות לערכים הנוכחיים — השוואה כזו עוברת גם על טקסט קשיח שבמקרה נכון היום.

  • ושתי בדיקות שלא היו מסוגלות להיכשל, ושלושה מסלולים בלי כיסוי. שתי הצהרות בקובץ הבדיקות תפסו Exception גנרי, כך שגם שגיאת ייבוא או נפילת דמה היו נקראות כהצלחה; הן צרות עכשיו ל-ToolError עם התוכן validation error, שנמדד מול mcp 1.28.1. ההצהרה על שם כלי שאינו מחרוזת בודקת עכשיו את הלוג ולא את ערך ההחזרה, כי ה-except שעוטף את הקולבק מחזיר None בכל מקרה — בלי ההגנה על הטיפוס כל אירוע כזה כותב אזהרה עם traceback, ועם ההגנה אין רעש כלל. ובנוסף נוספו הבדיקות לשלושה מסלולים שהתנהגו נכון ולא נבדקו: קובץ חסר, file_id, ו-version — query רץ אחרי בחירת המסמך, ולכן הסריקה על version=1 היא על תוכן הגרסה הישנה ולא על האחרונה.

  • ומה שלא שונה, במפורש. הסף של תו אחד נשאר — הוא הפרש מכוון מ-codekeeper_search_repo, כי קובץ בודד אינו ריפו שלם — ומה שחסר היה תיעוד ולא יישור. max_results נשאר פרמטר שהקורא קובע, מיושר ל-codekeeper_search_repo.

2026-09-14

  • ‏``query`` ב-``codekeeper_get_file`` — חיפוש בתוך קובץ פרטי. סוכן שרצה שדה אחד מתוך JSON גדול, או כלל אחד מתוך מסמך, משך עד היום את הקובץ כולו — או ניחש טווח. codekeeper_search_repo כבר עושה בדיוק את זה לקבצי ריפו, והקבצים השמורים פשוט לא קיבלו את הכלי. query="..." מחזיר עכשיו את המופעים במקום את התוכן, בדיוק בצורת התשובה של codekeeper_search_repo — אותם count, total, truncated ו-results, ולכל פגיעה line ו-snippet, ואותו context_lines. ההמשך הוא lines=[line, line], ומה שמבטיח שזה עובד הוא שהסריקה מפצלת שורות באותה צורה כמו קריאת הטווח. שלוש החלטות: query יחד עם lines נדחה כ-query_and_lines ולא מתעלם בשקט מאחד מהם; אפס מופעים הוא הצלחה עם רשימה ריקה ולא error; ותקרת המופעים ותקציב הבתים מוצהרים ב-truncated במקום לחתוך בשקט. התקרה על טקסט הרשומה נמדדת בבתים ולא בתווים, והחיתוך נוחת על גבול תו. הפרמטר תוספתי לחלוטין — קריאה בלי query מחזירה בדיוק את מה שהחזירה קודם. עוגן חדש: חיפוש בתוך קובץ שמור (query).

  • fix: אאוטליין של ``.rst`` פרסר את הקובץ כולו לפני שהתקרה נגעה בו. התקרה על מספר הסימבולים יושבת בסורקים בכוונה — סינון של פלט אינו חסימה של עבודה — אבל בסורק ה-RST היא נגעה רק ברשימה שנבנתה אחרי ש-parse_document סיים. כלומר קובץ שנכנס בנוחות לתקרת ה-10MB של קריאת הטווח יכול לקנות עבודה גדולה: נמדד על 10MB של כותרת בת תו אחד בכל שתי שורות — 2.6 מיליון סקשנים — 18.5 שניות ו-1,132MB, מול 0.30 שניות ו-83MB אחרי התיקון. הזיכרון הוא מה שמצדיק את זה: בקשה איטית היא בקשה איטית, אבל ג’יגה-בייט בתהליך משותף מפיל שירות. parse_document מקבל עכשיו max_sections שברירת המחדל שלו ללא תקרה, ולכן docs_get_section — הצרכן השני של הפארסר — זהה בית-בית, והתשובה על קובץ שחוצה את התקרה נשארה בדיוק אותה תשובה: no_outline עם too_many_symbols, בלי רשימה חלקית. ומה שלא נחסם, במפורש: התקרה מגבילה סקשנים ולא שורות, ולכן 10MB של שורות ריקות הוא אפס סקשנים ו-6.3 שניות — זהה עם התקרה ובלעדיה.

  • docs: הקבועים והתקרות של שרת ה-MCP במקום אחד, ואוצר המילים של התשובה. נוסף סעיף הקבועים, התקרות ואוצר המילים של התשובה עם כל תקרה שנאכפת בקוד — כולל תקרות העימוד, שלא היו מתועדות כלל — ועם הכלל שערך מעל התקרה נצמד בשקט ואינו נדחה, כלומר per_page=1000 באאוטליין מקבל 500 ואין שדה שמצהיר על זה. ובנוסף: הרשימה הסגורה של ערכי status בתשובת כלי (תשובת HTTP של השרת אינה תשובת כלי — 401 נושא error בלי ok), ההסבר למה ל-error אין רשימה כזאת, המחלקה היחידה שסורק ה-RST אינו ממודל (בלוק literal מצוטט), ושורה בפתרון תקלות על כך שתהליך ה-MCP אינו מגדיר לוגים — ולכן היעדר לוג אינו סימן שהכלי לא נקרא. ובנוסף הוסבר מה ``file.encoding`` באמת אומר: utf-8 ו-utf-8-sig הם זיהוי, ו-latin-1 הוא נפילה-לאחור שאינה נכשלת לעולם — נמדד שקובץ עברי ב-cp1255 חוזר עם התווית latin-1 ועם תוכן משובש. וש-BOM מוסר מ-content בזמן ש-size סופר אותו, כלומר זה החריג היחיד לכלל שהטקסט חוזר בית-בית.

  • fix: שעון חוזר של קורא חיצוני הפך לחד-פעמי בשקט אחרי הערכת regex. ConditionOperators.regex דורס את SIGALRM לשנייה אחת כדי לעצור ביטוי שמתפוצץ, ומשחזר אחר כך את השעון של מי שקרא לו. signal.getitimer מחזיר זוג — מה שנשאר עד הירייה הבאה, ומרווח החזרה — והקוד שמר את האיבר הראשון בלבד והשחזור העביר ארגומנט אחד. כלומר שעון חוזר שוחזר כחד-פעמי: הירייה הבאה כן מגיעה, וכל אלה שאחריה אינן, בלי שום שגיאה. נמדד: על שעון של 30 שניות עם חזרה כל 5, הקוד שלפני התיקון החזיר מרווח 0.0 אחרי הקריאה והמתוקן מחזיר 5.0. בריפו הזה אין מסלול הגעה ידוע — pytest-timeout מצמיד שעון חד-פעמי — ולכן זה פגם נכונות בקוד ייצור ולא תקלה שנצפתה. שלושת הטסטים שכיסו את השחזור הדליקו שעון חד-פעמי בלבד, ולכן אף אחד מהם לא היה יכול לראות את זה, והעזר שבטסטים נשא בעצמו את אותו פגם — גם הוא שמר איבר אחד.

  • fix: שתי בדיקות שלא היו מסוגלות לתפוס את מה שהן שומרות עליו. העד של סורק ה-escape-ים שחזר את הסריקה בתוך עצמו במקום לקרוא למימוש, ולכן מי שישבור את המימוש היה מקבל אפס ממצאים ושתי הבדיקות היו ממשיכות לעבור; הוא עובר עכשיו דרך _invalid_escapes על קובץ שנשתל ב-tmp_path. ושורת הסיכום שאומרת ”כל בדיקות הדפדפן דולגו והכיסוי אפס“ לא נכתבה דווקא בתצורה שה-CI מריץ. הסיבה נרשמה במשתנה ברמת המודול שהפיקסצ’ר ממלא, וה-CI מריץ pytest -n auto --dist=loadscope — כלומר הפיקסצ’ר רץ ב-worker ו-pytest_terminal_summary רץ ב-controller, ושם המשתנה ריק לעולם. נמדד על קובץ דפדפן אחד בלי דפדפן: בלי -n השורה נכתבת, ועם -n 2 --dist=loadscope הריצה מסתיימת ב-4 skipped בלי שום אזכור של הסוויטה. הפתרון הוא מקור אחד במקום שניים: הסיבה נקראת מדיווחי הדילוג של pytest, שכן עוברים ל-controller בשתי התצורות — when == "collect" כשהחבילה חסרה, ו-when == "setup" כשרק הדפדפן חסר, וזו הצורה שה-CI מגיע אליה כי requirements/base.txt מצמיד את playwright ואין באף workflow שלב שמתקין דפדפן. אומת בהרצה על pytest 8.4.2 עם pytest-xdist 3.8.0 — הגרסאות שה-CI מתקין, ולא אלה שמותקנות בקונטיינר הפיתוח. ושתי הבדיקות ההתנהגותיות מריצות עכשיו את תת-התהליך בשתי התצורות, כי שתיהן הריצו אותו בלי -n ולכן אף אחת מהן לא הייתה מסוגלת לראות את זה.

2026-09-13

  • fix: כותרת שנגמרת ב-``::`` נעלמה מהמפה, ושורה בתוך פסקה הפכה לסעיף מומצא. סבב סקירה נוסף מצא שני באגים באותו ענף, ושניהם נבעו מאותה סיבה: הענף שזיהה שורה שנגמרת ב-:: ודילג על הבלוק המוזח שאחריה רץ לפני בדיקת הכותרות, וקידם שורה אחת ולא את בלוק הפסקה. הראשון: במצב Text שב-docutils הסדר הוא blank ← indent ← underline ← text, כלומר כשהשורה שאחרי הטקסט היא קו פיסוק זה סעיף וה-:: אינו מתפקד כסמן — ולכן Configuration:: עם קו מתחתיה היא סעיף ש-Sphinx בונה, והמפה החסירה אותו לגמרי; codekeeper_docs_get_section ענה עליו ”סעיף לא נמצא“. והשני: ב-docutils ה-literal block נכנס רק אחרי שהפסקה נצרכה, ולכן שורות שהיו בתוך אותה פסקה נבחנו כאן שוב ככותרות והמפה המציאה סעיף — ובצורה אחת זו הייתה רגרסיה, כלומר מפה ריקה ב-main והמצאה אחריה. הפתרון הוא הסרת הענף כולו: בלוק literal מוזח, ולכן שומר ההזחה מדלג עליו ממילא, וכך גם תוכן של דירקטיבה. נמדד על אורקל דיפרנציאלי מול docutils עם :: באלפבית, 6,000 קלטים: 245 אי-הסכמות עם הענף, ארבע בלעדיו, ו-706 בקוד שלפני ה-PR. ארבע הנותרות הן מחלקה מוצהרת אחת — quoted literal block, בלוק שאינו מוזח ששורותיו נפתחות בתו פיסוק — שאין לה אף מופע בקורפוס, והאורקל הבלתי-תלוי סוטה על אותן ארבע בדיוק. הפלט על כל קובצי ה-RST כאן לא זז: אפס מתוך 208, והסכמה מלאה עם docutils. ובנוסף שדה הלוג בנתב שונה מ-bytes ל-chars, כי len על מחרוזת מודד תווים — נמדד שעברית היא 1.83 בתים לתו, ולכן השדה היה מדווח עמוד עברי כחצי מגודלו בדיוק ברשומה שנכתבה כדי לזהות קלט פתולוגי.

  • fix: כותרת שכתובה מיד אחרי שורה מוזחת נעלמה מהמפה גם במסלול השני, וזו הייתה רגרסיה. הכלל של Text.text — שהבלוק נגמר בשורה ריקה או בשורה מוזחת — היה כתוב בפארסר בשני מקומות, כי docutils מגיע לאותו מסלול משני כיוונים: מעבר ה-text מ-Body, והחזרה אליו מ-short_overline דרך state_correction. התיקון הקודם נתן את העצירה על ההזחה לאחד מהם, והשני נשאר כפי שהיה — ולכן קו פיסוק קצר, ואחריו שורה מוזחת, ואחריה כותרת, החזיר מפה בלי הכותרת ועם status: "ok", כלומר codekeeper_docs_get_section ענה ”סעיף לא נמצא“ על סעיף שכתוב בקובץ ו-Sphinx בונה אותו. וזו הייתה רגרסיה ולא פער חדש: הפארסר שב-main מחזיר את הכותרת בהסכמה עם docutils, והשינוי שקדם לזה לא. הכלל יושב עכשיו בהגדרה אחת, _skip_paragraph_block, ששני האתרים קוראים לה — כי שני נוסחים של אותו כלל הם בדיוק מה שנסחף כאן. נמדד על מדגם של 37,376 צורות: 280 מהן חלקו על docutils, וכולן חזרו להסכמה, ואפס צורות שהיו נכונות נשברו. ולולאת ה-doctest נשארה בכוונה מחוץ לאיחוד, כי Body.doctest קורא get_text_block() בלי flush_left ושם רק שורה ריקה מסיימת — אומת במקור של docutils 0.23, ויש על זה טסט בקרה שיתפוס ”איחוד“ שגוי. ובנוסף יושר האורקל הבלתי-תלוי שבטסטים, שנשאר מאחור בשני כללים והפסיק להיות עוגן בדיוק להם: בכלל הרוחב הוא המציא כותרת ש-docutils דוחה, ובבלוק הפסקה הוא איבד כותרת ש-docutils מחזיר. שני הכללים נגזרו מחדש מהמקור של docutils ולא מהמימוש, והפלט על כל קובצי ה-RST כאן לא זז — אפס מתוך 208.

  • fix: כותרת שבאה אחרי טבלה פשוטה עם מפריד כותרת נעלמה מהמפה, ויעד חיצוני נכנס אליה. סבב סקירה נוסף על הענף העלה שני ממצאים, ושניהם אומתו במדידה מול הפארסר של docutils. הראשון: היקף הטבלה נקרא עד הגבול הראשון, וטבלה עם מפריד כותרת יש בה שני גבולות — כלומר הסריקה נעצרה על המפריד, גוף הטבלה נקרא כפסקה, והפסקה בלעה את הכותרת שבאה מיד אחרי הגבול הסוגר. ההיקף נגזר עכשיו משלושת תנאי הסגירה של המקור: הגבול שהוא השני שנמצא, או האחרון בקלט, או אחד שאחריו שורה ריקה — ועד בכלל; שורה ריקה בתוך גוף הטבלה אינה מסיימת אותה; וטבלה בלי גבול סוגר בולעת את שאר הקלט, כפי שהמקור מתנהג. נמדד על מדגם צורות טבלה: שבע חולקות לפני, ואפס אחרי — ואחת מהן הייתה בכיוון ההפוך, כלומר כותרת שהמפה המציאה ו-Sphinx אינו בונה. והשני: .. _label: שאחריו שורה מוזחת הוא יעד חיצוני ואינו יעד של :ref: — במקור, כל תוכן בבלוק של היעד הופך ל-URI, בלי שום אימות שזה נראה כמו URI, ולכן גם פרוזה מוזחת. יעדים כאלה אינם במפה יותר, והצורה שבה ה-URI באותה שורה הייתה חסומה ממילא. התנהגות התיעוד בריפו הזה לא זזה: הפלט על כל קובצי ה-RST כאן זהה בית-בית לפני ואחרי, ומספר התוויות לא השתנה.

  • fix: קובץ .rst שנוצר ב-Windows נעל את שרת ה-MCP עד restart. סקירת קוד על השינוי שלמעלה מצאה שהלולאה שבולעת פסקה אינה מובטחת להתקדם: _is_title_text בדק ”שורה ריקה“ לפי המחרוזת הריקה בלבד, ולכן שורה שכולה \r — כלומר שורה ריקה בקובץ עם סיומות שורה של Windows — אושרה כטקסט כותרת, ואז הלולאה, שבודקת strip, רצה אפס איטרציות וחזרה לאותה שורה. בלי מוצא: אין תקרת זמן במסלול, get_repo_file סינכרונית וה-SDK קורא לה על לולאת האירועים, ולכן כל השרת אילם — ולא רק הבקשה הזאת. הכשל הגיע גם ל-codekeeper_docs_get_section, שרץ על אותו פארסר. הפתרון בגבול הקלט: \r\n ← \n מנורמל פעם אחת ב-parse_document, וזה הנרמול היחיד שמותר שם כי הוא היחיד שאינו משנה כמה שורות יש — כל שדות ה-lines בתשובות ה-MCP נספרים באותה חלוקה, ומפה שנספרת אחרת מהחיתוך שיבוא אחריה מצביעה לשורה שאי אפשר להגיע אליה. splitlines() נשקל ונדחה: הוא מפצל על עשרה תווים במקום אחד, מוריד שורה ריקה סופית, ושינה את הפלט כאן על כמעט כל עמוד. ותו whitespace שאין לו נרמול — tab אנכי, form feed, רווח קשיח — נחסם בהאחדת ההגדרה של ”שורה ריקה“, שהיא השורש. ובנוסף תוקן שיעדי .. _label: נעלמו בשקט מקובץ כזה בזמן שהכותרות כן חזרו, כי זיהוי הכותרת מקצץ רווחים בעצמו והתווית דרשה סוף שורה; הנרמול סוגר את שני הסימפטומים במקום אחד.

  • fix: כותרת שכתובה מיד אחרי שורה מוזחת נעלמה מהמפה, והסעיף שמעליה בלע אותה. Text.text ב-docutils קורא את הפסקה ב-get_text_block(flush_left=True), שעוצר על הזחה, והלולאה כאן המשיכה עד השורה הריקה — כלומר lines= שבא אחרי המפה החזיר את הקטע הלא נכון בלי שום סימן שמשהו אבד. זו הייתה רגרסיה: הגרסה שלפני השינוי ו-docutils שהורץ שניהם מחזירים את הכותרת.

  • fix: כלל אורך הקו של כותרת עם overline לא ספר את ההזחה שלה. במקור, הרוחב נמדד על הכותרת אחרי קיצוץ מהסוף בלבד, וקיצוץ ההזחה קורה אחר כך ורק לטקסט שנשמר — כלומר ההזחה כן נספרת. בלי זה המפה הציגה סעיף ש-Sphinx אינו בונה. נמדד על מדגם צורות בממד ההזחה, והמימוש מסכים עם docutils בכולן. והתיאור של הכלי תוקן בשני מקומות: symbol="_" מסנן בהכלה ולכן מחזיר גם כותרות שיש בהן קו תחתון, וכותרת autodoc נושאת את ה-escape של RST — ולכן שאילתה בלי הלוכסן אינה מוצאת את העמוד ששמו כך.

  • feat: ``outline`` עובד גם על קובצי .rst. codekeeper_get_repo_file עם outline=true מחזיר עכשיו תוכן עניינים עם טווחי שורות לקובצי תיעוד, ולא רק לפייתון, לתבניות ול-CSS. השמות מנוקדים לפי ההיררכיה כמו בפייתון, וההיררכיה עצמה נקבעת לפי סדר הופעת תווי הפיסוק בכל קובץ בנפרד — === אינו ”רמה 1“, ולכן קובץ שמשתמש ב-^ לרמה שלישית ואחר ב-~ יוצאים שניהם נכון. ובנוסף, יעדי .. _label: הם סימבולים נפרדים — אלה היעדים שאליהם :ref: מצביע, וכשקישור פנימי נשבר זה בדיוק מה שמחפשים; symbol="_" מגיע אל כולם — וגם אל כל כותרת שיש בה קו תחתון, כי הסינון הוא בהכלה בכל השפות. יעד חיצוני ויעד אנונימי אינם במפה, כי :ref: אינו יכול להצביע אליהם. וקובץ בלי אף כותרת אינו כשל אלא מפה ריקה, כמו קובץ CSS בלי כללים. שתי התנהגויות שכתובות מראש כדי שלא ייראו כבאג: טקסט הכותרת הוא המקור ולא הרינדור (כותרת שנכתבה `` code `` מוחזרת כך), והנקודה בשם אינה מפריד בלעדי — כותרת RST יכולה להכיל נקודה בעצמה, כמו בעמודי ה-API כאן, ולכן השם הוא תווית ל-symbol= וההשתייכות נקראת מטווח השורות. הסורק עצמו דק: הוא נשען על פארסר ה-RST של הפרויקט, שיושר לפארסר של docutils בשינוי שקדם לזה.

  • fix: כותרת שכתובה בקובץ ו-Sphinx מקבל אותה נעלמה מהמפה של codekeeper_docs_get_section, וכותרת ש-Sphinx דוחה הופיעה בה. הפארסר ב-services/rst_parser.py מזהה כותרות לפי כלל שנכתב ביד, והושווה עכשיו מול הפארסר של docutils עצמו — שהורץ, ולא רק נקרא. מה שהיה נשמט: קו פיסוק קצר מהכותרת אך באורך ארבעה תווים ומעלה (docutils מקבל אותו עם אזהרה, והפארסר הפיל אותו); כותרת שהקו שמתחתיה מיושר לרוחב התצוגה ולא לספירת התווים — וזה בדיוק המקרה של עברית מנוקדת ושל אמוג’י, כי column_width של docutils מחסר תווים משולבים ומכפיל תווים רחבים, ובעמוד testing בריפו הזה יש תקדים חי; וכותרת שהקו שלה נכתב בפסיקים או בנקודה-פסיק, שנעדרו מרשימת תווי ה-adornment שהוקלדה ביד. מה שהופיע בלי שצריך: כותרת שתו הפיסוק שלה מדלג רמה אחרי חזרה לרמה קודמת (check_subsection מסמן Inconsistent title style ואינו יוצר את הסעיף), כותרת שה-overline שלה אינו זהה ל-underline גם באורך, וכותרת מדומה שנוצרה משורה שהיא בעצם פריט רשימה. וההיררכיה עצמה תוקנה: כותרת עם overline היא סגנון נפרד מכותרת עם underline באותו תו, ולכן רמה אחרת. התנהגות התיעוד בריפו הזה לא זזה: הפלט של הכלי על כל קובצי ה-RST כאן זהה בית-בית לפני ואחרי, כולל ה-TOC וטווחי השורות — כל אחת מהצורות האלה מייצרת אזהרה או שגיאה ב-docutils, ו-fail_on_warning: true ב-Read the Docs היה מפיל את הבנייה מזמן. הבדיקות נשענות על שני אורקלים שנכתבו בנפרד מהמימוש: אחד מזהה כותרות מצורת הטקסט בלבד, והשני משחזר את חישוב הרמות של check_subsection.

  • fix: פסקה בת שתי שורות ואחריה קו פיסוק ייצרה כותרת מדומה, ושורה מבנית הפכה לכותרת בשם עצמה. סבב ריוויו על התיקון שלמעלה חשף פינה שהטבלה שבה אימתתי אותו לא מגיעה אליה: כל הצורות שנבדקו שם היו כותרת אחת בת שורה אחת. מצב Text ב-docutils הוא ”השורה השנייה של בלוק טקסט“, וכשהיא אינה קו פיסוק הוא קורא את כל הבלוק עד השורה הריקה כפסקה אחת — כלומר קו פיסוק שיושב בתוך פסקה אינו נבדק בכלל. והכלל אינו ”אחרי שורה ריקה“ אלא ”פסקה שכבר נפתחה“, וזו הבחנה שנמדדה: בולט, שורת שדה, דירקטיבה, line_block, ראש טבלת grid ויעד אנונימי — כולם מעל כותרת ובלי שורה ריקה ביניהם — וה**כותרת כן נוצרת**. בכיוון ההפוך, שורה מבנית אינה יכולה להיות הכותרת עצמה, ולפני התיקון כל אחת מהן הפכה לכותרת בשם עצמה. שתי התבניות שיוצאות מהכלל הן enumerator ו-option_marker, שנופלות חזרה למעבר ה-text ולכן מתנהגות כמו פסקה לשני הכיוונים. בנוסף: היקף טבלה פשוטה נקרא עד הגבול הסוגר ולא עד השורה הריקה, וכותרת מוזחת בין שני קווי overline זהים היא כותרת (Line.indent מנותב לאותו מסלול). טבלת האימות הורחבה בהתאם — שורה קודמת מכל סוג כפול שורת כותרת מכל סוג — והמימוש מסכים עם docutils בכל הצורות בשתי הטבלאות. הפלט על קובצי ה-RST בריפו הזה לא זז.

2026-09-10

  • fix: בדיקה שחורגת מתקרת הזמן הרגה את התהליך שמריץ אותה במקום להיכשל, ולקחה איתה את שמה. pytest.ini קבע timeout_method = thread, ובשיטה הזאת pytest-timeout קורא os._exit. תחת pytest-xdist ה-controller רק רואה תהליך שנעלם ומדפיס node down: Not properly terminated — בלי שם הבדיקה, בלי שורה ובלי מחסנית, כי ה-worker כותב אותן ל-stderr שלו ויוצא לפני שהפלט נשטף. וזה קרה בפועל, פעמיים: ריצה אחת נתקעה על 99% ונשרפו בה עשרים דקות עד ביטול ידני, והזיהוי דרש הורדת הלוג המלא והצלבה בין שתי גרסאות פייתון. השורה הוסרה, ו-pytest-timeout בוחר עכשיו את השיטה לפי הפלטפורמה כפי שהוא מיועד. נמדד, עם תקרה של שלוש שניות במקום שישים: בשיטה הקודמת התהליך מת ואפילו הבדיקה שאחרי החורגת לא רצה; עכשיו הבדיקה האיטית נכשלת בשמה והשאר ממשיכות. ונמדד גם שברירת המחדל תופסת את שלוש הצורות שהיה סביר לחשוד בהן: תקיעה ב-thread שאינו הראשי, קריאת C חוסמת, ובדיקות אסינכרוניות בשתי הצורות.

  • fix: ההגנה מ-ReDoS מחקה את שעון הזמן של מי שקרא לה. ConditionOperators.regex דורס את SIGALRM לשנייה אחת כדי לעצור ביטוי שמתפוצץ, וסיים ב-signal.alarm(0). אבל ``alarm`` ו-``setitimer(ITIMER_REAL)`` הם אותו שעון אחד בתהליך — נמדד: אחרי setitimer(60) הקריאה alarm(1) מחזירה 60, כלומר היא רואה אותו, ואחרי alarm(0) נשאר 0.0. הקוד שמר ושחזר את ה-handler ומחק את ה-שעון, ושמירת אחד מהשניים בלי השני היא כל הפער. זה באג בקוד ייצור — הוא מוחק שעון של כל צרכן, מי שזה לא יהיה — והוא נעשה קריטי מהרגע שתקרת הבדיקות עברה לשיטה שמשתמשת באותו שעון: נמדד דרך pytest אמיתי שבדיקה שמחקה את הרצף ואז ישנה עשר שניות תחת תקרה של שלוש עברה. עכשיו נשמר גם השעון, ומה שנשאר בו מוחזר פחות מה שנצרך; getitimer/setitimer ולא alarm, כי alarm עובד בשלמים ומעגל למעלה.

  • fix: בדיקות הדפדפן הכריעו בנפרד בכל בדיקה אם יש דפדפן, כל אחת דרך הרמת תהליך דרייבר ותפיסת חריגה. ”יש דפדפן או אין“ היא עובדה אחת על הסביבה, קבועה לאורך כל הריצה, וההכרעה נעשית עכשיו פעם אחת. נמדד על סוויטת הדפדפן כשאין דפדפן: הזמן ירד פי 33, ומהרמה לכל בדיקה להרמה אחת בסך הכול. והצורה ההיא לא רק בזבזה זמן: מסלול שנשען על חריגה מטופל היטב כשהחריגה נזרקת ואינו מטופל בכלל כשהמסלול פשוט אינו חוזר — ובריצת CI על פייתון 3.12 בדיקות שנשענות על פיקסצ’ר אחד דולגו כרגיל ובדיקה שנשענת על אחר לא חזרה, חצתה את התקרה והרגה עובד xdist שלם, בזמן שאותה בדיקה בדיוק דולגה על 3.11 באותה ריצה ועל אותו קוד. והדילוג נאמר בקול. ל-CI אין שלב שמתקין דפדפן, ולכן זה המצב הרגיל שם — והריצה מצהירה במפורש שהכיסוי של בדיקות הדפדפן בה הוא אפס, במקום להיבלע בתוך שאר הדילוגים.

  • fix: סדרות escape לא חוקיות ב-docstrings, שפייתון 3.12 מזהיר עליהן ובגרסה עתידית לא ייטענו בכלל. לוכסן-רווח הוא ”רווח מוברח“ של RST ונחוץ כדי לחבר סימון inline לטקסט שצמוד לו, אבל במחרוזת שאינה raw הוא סדרה שאינה מוכרת לפייתון. ריצת CI על 3.12 הדפיסה את האזהרה, והתיקון הוא ה-r שלפני שלושת הגרשיים ולא הסרת הלוכסן — שמשנה את מה שהתיעוד מציג. ובאחד המקומות זה שיבש את הטקסט עצמו ולא רק הזהיר: אותו docstring הכיל גם \n, שהיא סדרה חוקית, ולכן היא הפכה לירידת שורה אמיתית וחתכה משפט באמצע. והסריקה שמצאה אותם עברה שני ניסיונות שנכשלו, ושניהם מתועדים בבדיקה שנוספה: הראשון סינן לפי SyntaxWarning בלבד, וב-3.11 הקטגוריה היא DeprecationWarning — הוא החזיר אפס על ריפו שהיו בו מופעים; השני חיפש לוכסן צמוד למרכאות הפוכות ופספס את \s. מה שקבוע בין הגרסאות ובין הצורות הוא נוסח ההודעה, וזה מה שהבדיקה בודקת.

  • docs: ``symbol=`` עובד על כל שם שהמפה מחזירה, ולא רק על המנוקדים — וזה לא היה כתוב. בתיאור הכלי הפילטר ישב בתוך המשפט של פייתון, ומיד אחריו בא המשפט שאומר ש-HTML נותן שמות שטוחים; סוכן שקורא את זה קושר אותו לשמות מנוקדים ולא ינסה אותו על @media. וזה לא היפותטי — נמדד שהוא מצמצם 486 סימבולים בחמישה עמודים לשישה בעמוד אחד, ובכל זאת נשכח. נוספה פסוקית עם שתי דוגמאות קונקרטיות, וגם דוגמה שאינה פייתון בפסקת ה-symbol= בתיעוד: symbol="block " מחזיר את תגיות ג’ינג’ה בלבד, ו-symbol="#" את כל מה שנושא id — גם עוגני HTML בצורת tag#id וגם סלקטורי id מתוך <style>, כי הסינון הוא בהכלה ולא בתחילית. אפס שינוי התנהגות: אף שורת סורק לא נגעה.

  • וההבטחה הזאת קיבלה מי שאוכף אותה. כל טסטי ה-symbol= היו עד כה על שמות פייתון, בזמן שארבעה docstrings כבר מזכירים אותו בהקשר CSS ו-HTML — כלומר פסוקית בתיאור בלי טסט הייתה הבטחה לצרכן שאיש אינו אוכף. נוספו שלושה טסטים על קבצים שנגזרים מהקורפוס ולא נקובים בשם, והטענה בהם היא שהסינון מצמצם ולא שמוחזרות שורות — טסט אי-ריקנות עובר גם על סינון שאינו מסנן כלום. וגם חוזה ההכלה עצמו קובע עכשיו: נמדד שהחלפתו בתחילית מפילה טסט אחד בדיוק, כלומר עד כאן הוא לא היה מכוסה בכלל.

  • fix: הערת Jinja בתוך בלוק ``<style>`` שברה את הסלקטור, ואף ייצרה סימבול מתוך טקסט ההערה. {# הוא שני התווים היחידים שבהם CSS ו-Jinja מתנגשות באמת: בקובץ .css זה סוגר-בלוק ואחריו סלקטור id, ובתבנית זו פתיחת הערה. הוצאת {# מרשימת הפותחים תיקנה את הצד של ה-.css ופתחה שלושה כשלים בצד של התבנית — .a, ואז הערה ואז .b { החזיר שני סימבולים במקום סלקטור אחד, ו-{# TODO .x { #} ייצר סימבול בשם # TODO .x, כלומר שם שנוצר מטקסט של הערה. המפריד אינו צורת הטקסט אלא מי הקורא, וזה מידע שהסורק כבר מחזיק: קובץ .css מגיע דרך נקודת כניסה אחת וגוף <style> דרך אחרת. ואומת ב-Jinja 3.1.6 שבהקשר תבנית אין בכלל אי-בהירות — {# note #}, {# don't do this #} ו-{# TODO .x { #} כולם הערות שנמחקות, ואילו @media print{#a{color:red}} בתבנית מחזיר TemplateSyntaxError: Missing end of comment tag, כלומר תבנית שבה {# אינו הערה אינה מתרנדרת בכלל.

  • fix: מחרוזת CSS שלא נסגרה מחקה מהמפה את כל מה שאחריה. אומת ב-Chromium 141: .x{content:'oops ואז } בשורה הבאה ואז .b{…} נותן שם שני כללים — המחרוזת נקטעת בסוף השורה, ה-} סוגר את .x, ו-.b הוא כלל בפני עצמו. הסורק בלע עד סוף הקובץ, ולכן .b נעלם: תשובת הצלחה עם סימבול חסר. גרש בודד הוא טעות הקלדה נפוצה לגמרי, ולכן זה אינו קלט תיאורטי. ו-\ בסוף שורה כן ממשיך את המחרוזת, וגם זה נמדד.

  • fix: תווית הקידוד הצהירה על חתימת BOM שאינה קיימת. התיקון הקודם הקדים את utf-8-sig ברשימת הקודקים, וזה אכן הוריד את ה-BOM — אבל אז כל קובץ UTF-8 דיווח encoding: "utf-8-sig", גם קובץ בלי BOM, כלומר כמעט כל קובץ בכל ריפו. utf-8-sig פירושו ”UTF-8 עם חתימה“, והתווית נוסעת ל-file בתשובת הכלי. הזיהוי הוא עכשיו ענף מפורש על הבייטים, ולכן התווית אומרת את מה שקרה; וחתימה תקינה מעל גוף פגום נופלת חזרה לרשימה במקום להחזיר כלום.

  • fix: גוף חץ שהמשכיותו מסומנת בתחילת השורה הבאה נסגר מוקדם. const h = () => list ואז .map(…) בשורה נפרדת — שרשור מתודות, כתיב נפוץ לגמרי — קיבל טווח של שורה אחת מתוך שלוש, כי list הוא מזהה ותקין כסוף ביטוי וההסתכלות הייתה אחורה בלבד. הקבוצה נמדדה ב-Node 22 ברמת הפרסינג, דרך טקסט המקור של החץ כפי שנפרס: . + - * / % ^ & | && || ?? < > = ? ?. ( [ ו-backtick ממשיכים את הביטוי. וארבעת החריגים הם העיקר: .5 הוא ליטרל מספרי ולכן נקודה שאחריה ספרה מסיימת, ++ ו--- מסיימים אף ש-+ ו-- ממשיכים, ו-, מסיים כאן כי כל חץ ממתין הגיע מהצהרת const/let/var ושם הפסיק מפריד בין מוצהרים.

  • והקורא-קדימה הזה חייב זיכרון, וזה נמדד ולא הונח. הוא נקרא בכל ירידת שורה שיש בה חץ ממתין, ורצף ארוך של הערות אחרי ה-=> פירושו שכל ירידת שורה סורקת מחדש את שאר הרצף — פי ארבע לכל הכפלה, ו-8.9 שניות על 8,000 שורות מול 0.011 שניות עם הזיכרון, פי 809. זו בדיוק הריבועיות שנמדדה כאן קודם, רק מהצד השני: אז הסריקה החוזרת הייתה אחורה, וכאן קדימה.

  • fix: קובץ CSS ממוזער החזיר מפה ריקה, עם ``status: ok``. {# נקרא כפותח הערת Jinja, אבל ב-CSS ממוזער הוא שני דברים צמודים — סוגר-בלוק-פותח ואחריו סלקטור id. @media print{#a{color:red}} ואחריו .b{color:blue} החזיר רשימה ריקה: הדילוג בלע את כל מה שעד ה-#} הבא, ובהיעדרו את שאר הקובץ. אומת ב-Chromium 141 שהקלט הזה נותן שני כללים, ולכן מפה ריקה עליו היא תשובת הצלחה עם תוכן שגוי. {# הוצא מרשימת פותחי ה-Jinja, וזה אינו מפסיד דבר: {#…#} מאוזן בסוגריים מעצמו, ולכן הערת Jinja ממשיכה להיעלם מהמפה בלי טיפול מיוחד. ומבנה Jinja שבאמת לא נסגר מדלג עכשיו על שני תווי הפותח בלבד ואינו מוחק את הכללים שמתחתיו — אותה החלטה שכבר נלקחה בסורק ה-HTML.

  • fix: ``url()`` שמכיל ביטוי Jinja סגר את הבלוק בשורה הלא נכונה. url({{ url_for('static', filename='a.png') }}) הוא הצורה הרגילה בתבנית, ובה ה-) הראשון סוגר את url_for ולא את url — משם הלקסר חזר לקוד בתוך הביטוי, ראה שם } וסגר בלוק שעוד לא נגמר. הדילוג הוא עכשיו לולאה שמכבדת מבני Jinja כיחידה.

  • fix: קלט של עשרות קילובייטים תפס את השרת לשניות ארוכות, בשני מסלולים. בגוף חץ ללא סוגריים מסולסלים, השאלה ”האם הגוף בכלל התחיל“ נשאלה מחדש בכל ירידת שורה בסריקה חוזרת מה-=> — גדילה של פי ארבע לכל הכפלה, 80KB ב-1.7 שניות, ובהסקה לתקרת ה-10MB שעות. עכשיו התשובה נגזרת מהיסט של הטוקן האחרון, כלומר השוואת שני מספרים: אותו קלט ב-0.003 שניות, פי 554, וגדילה לינארית. במקביל, שלוש קריאות חיפוש בסורק ה-CSS לא קיבלו גבול — לא נראה בקובץ .css שלם, אבל html.py קורא לסורק פעם אחת לכל בלוק <style>, ולכן חיפוש שמתעלם מהגבול סורק את כל שאר הקובץ בכל קריאה. תבנית של 1MB ירדה מ-5.7 שניות ל-0.27. זה חשוב במיוחד כאן כי הכלי סינכרוני וה-SDK של MCP קורא לו ישירות — קלט אחד כזה נועל את הלולאה לכל השאר.

  • feat: תקרה על מספר הסימבולים בקובץ, משותפת לשלושת הסורקים. קלט קטן יכול לקנות עבודה גדולה: 3MB של <a> שאין לו id אינו מייצר אף שורה במפה ובכל זאת נמדד ב-122.5MB, כי כל תגית ממתינה במחסנית לסוגר שלא יבוא, ו-3MB של a{ נמדדו ב-363MB. שניהם נכנסים בנוחות לתקרת ה-10MB שלפני הסורק. מעל 50,000 סימבולים התשובה היא no_outline עם reason: too_many_symbols — בלי symbols, בלי total ובלי חיתוך, כי רשימה חלקית שנראית שלמה היא בדיוק הכשל שהמפה קיימת כדי למנוע. התקרה חוסמת גם את המחסניות ולא רק את רשימת השורות, והתקציב הוא לכל הקובץ ולא לכל בלוק <style>/<script>. המספר נמדד ולא נבחר, והנימוק כולל שתי המדידות כתוב ליד הקבוע.

  • fix: BOM בתחילת קובץ נסע לתוך הטקסט, ופגע בשני מסלולים. רשימת הקודקים בשירות המראה ניסתה utf-8 לפני utf-8-sig, וקובץ עם BOM נפרס בהצלחה כ-utf-8 — כלומר utf-8-sig היה בלתי ניתן להגעה בדיוק במקרה שהוא קיים בשבילו. הנזק נמדד: בקובץ פייתון ast.parse נכשל ב“invalid non-printable character U+FEFF“ והאאוטליין חזר ריק, ובקובץ CSS ה-BOM נכנס לשם הסימבול הראשון. אומת ב-Chromium שגיליון חיצוני עם BOM נותן ``.hero`` בלבד, כלומר ה-BOM הוא מטא-דאטה של קידוד ולא תוכן — ובתוך <style>, שם הוא מגיע כתו, הדפדפן כן משאיר אותו בסלקטור. החלפת הסדר שקילה לחלוטין: על 60,000 קלטים אקראיים שני הקודקים החזירו פלט זהה, פרט לקלט שמתחיל ב-BOM.

  • fix: ``<style type=“ text/css ”>`` נסרק כ-CSS בזמן שהדפדפן אינו מחיל אותו. גטר התכונות המשותף עשה strip() בשביל צרכן אחד, ושלושת הצרכנים דורשים שלושה דברים שונים — נמדד ב-Chromium 141: <script type=" text/javascript "> כן רץ, <style type=" text/css "> אינו יוצר גיליון (התאמה מדויקת, וכל רווח בכל מקום מבטל אותה), ו-<span id=" x "> שומר את הרווחים — getElementById(" x ") מוצא אותו. הערך חוזר עכשיו גולמי וכל צרכן מנרמל בעצמו, ושלושתם מסכימים עם הדפדפן.

  • fix: גוף חץ שהוא מערך רב-שורתי נסגר לפני ה-``]``. const f = () => [ ואז שלוש שורות נסגר בשורה השלישית, כי 2 הוא סוף ביטוי תקין ואין מי שיידע שהמערך עוד פתוח. עומק הסוגריים המרובעים נמדד עכשיו, בדיוק כמו העגולים. ומה שנשאר פתוח מוצהר במפורש: המשכיות שמסומנת בתחילת השורה הבאה — שרשור מתודות — עדיין נסגרת מוקדם, כי ההסתכלות היא אחורה בלבד, ויש לזה טסט שמקבע את המצב הקיים.

  • וההגנה על התפר קיבלה מיקום ואיזון, ולא רק ספירה. לבלוקי ה-<style> הייתה עד כה בדיקת ספירה בלבד, וספירה אינה אומרת דבר על מקום: מוטציה שמזיזה כל שורה באחת עברה את כל החבילה. שני אורקלים חדשים נופלים עליה ב-1,995 הפרות מיקום וב-1,378 הפרות איזון. במקביל יושר האורקל הבלתי-תלוי של ה-CSS לשני הכללים החדשים, ונוסף בו במפורש שאסור לייבא ממנו מהמימוש — כי השכפול שם הוא ההגנה, וברגע ששני צידי ההשוואה יוצאים ממקור אחד קריסה חלקית עוברת בשקט.

  • fix: גוף חץ שמתחיל בשורה שאחרי ה-``=>`` קיבל טווח באורך שורה אחת. const f = (a) => ואז a + 1; בשורה הבאה החזיר end == start על פונקציה שלמה, וגם גוף ביטוי שנפרס על כמה שורות נסגר מוקדם. זו אותה מחלקה בדיוק שסגנון Allman היה בה: הענף שסוגר חץ בגבול שורה לא הבחין בין ”אין גוף מסולסל“ לבין ”הגוף מתחיל בשורה הבאה“. שתי עובדות דקדוק אומתו ב-Node 22 ולא נכתבו מהזיכרון: גוף חץ אינו יכול להיות ריק — const f = (a) => ואז ; הוא שגיאת תחביר, ולכן ירידת השורה שצמודה ל-=> לעולם אינה מסיימת את הגוף; ושורה שנגמרת באופרטור משאירה את הביטוי חסר, בשאלה דקדוקית טהורה שאין בה תלות ב-ASI — (a +) הוא שגיאת תחביר בזמן ש-(a + b) תקין. אותה מדידה דחתה את ! ~ { ; ) ] ואת מזהים וספרות, ואישרה את : בהקשר של תלתן. הפלט על כל התבניות, על 41 קובצי ה-JS ועל ה-bundle של 7MB זהה לחלוטין לפני ואחרי — הצורה אינה קיימת בקורפוס בשם, ושני המופעים שכן קיימים הם חצים אנונימיים ב-.map().

  • feat: מפת הסימבולים (``outline``) תומכת ב-CSS, וגם יורדת לתוך בלוקי ``<style>`` בתבניות. .css מקבל סימבול לכל בלוק סלקטור, ובעיקר ל-at-rules — @media (max-width: 768px) ו-@supports (display: grid) מקבלים טווח שורות משלהם, ושם קבורים המובייל וה-RTL. סלקטורים מרובים שפרוסים על כמה שורות הופכים לשם אחד מנורמל, בלוקים שבתוך @media הם סימבולים שטוחים בפני עצמם, וצעדי @keyframes (0%, to) אינם סימבולים כי הם רעש ולא ניווט. at-rule שנגמרת ב-; אינה סימבול — אין לה טווח.

  • וזה מה שפתח את בלוקי ה-``<style>`` שהיו גבול אטום. בתבניות של הפרויקט יושב בבלוקים האלה נפח CSS שדומה לזה של קובצי ה-.css עצמם, והם הוחזרו כסימבול אחד לכל בלוק — ב-dashboard.html בלוק אחד נמשך יותר מאלף שורות. זה בדיוק הכשל ש-<script> תוקן ממנו, ולא היה אפשר לתקן אותו עד שיהיה סורק CSS. עכשיו גם מקור האמת של טוקני הערכה נגיש: ה-:root הגלובלי ובלוקי :root[data-theme="..."] יושבים ב-base.html ולא בקובץ CSS.

  • הסורק לקסיקלי, ו-Jinja מדולג ללא תנאי. בקובצי .css בריפו אין מבני Jinja בכלל, אבל בבלוקי <style> יש — :root[data-theme="custom"] בונה את הטוקנים שלו בלולאת {% for %}. לקסר שאינו מדלג סופר שם בלוק לכל שורה במקום בלוק אחד. שני הכיוונים נמדדו, ולכן הדילוג אינו דגל אלא התנהגות.

  • ההערה שמעל הסלקטור אינה חלק מהשם, וזה הדבר המרכזי בסורק. אב-טיפוס שלא הסיר אותה החזיר שם באורך 1,699 בתים שהוא הערה בעברית ולא סלקטור, וגם עיוות את ספירת ה-@media. אחרי ההסרה כל המספרים התיישבו בדיוק על מונה { בלתי-תלוי שנכתב בנפרד. הערה בתוך סלקטור אינה שוברת אותו: .a /* x */ .b הוא סלקטור אחד.

  • שני כללים חיצוניים אומתו מול Chromium ולא נכתבו מהזיכרון. ב-CSSOM, @keyframes הוא היחיד שהילדים שלו אינם כללים עם סלקטור — @media, @supports, @layer, @container ו-@scope כולם מחזירים כלל עם סלקטור, ו-@-webkit-keyframes ממופה לאותו כלל כמו הצורה בלי תחילית. ובבדיקה השנייה: <style type="text/plain"> אינו יוצר גיליון סגנון, וגם type="text/css; charset=utf-8" אינו — פרמטרים נדחים, בדיוק כמו כלל ה-essence של <script>.

  • מונה התפר תפס ``<style>`` שאינו אלמנט בכלל. admin_observability.html בונה מסמך להדפסה בתוך מחרוזת JavaScript, ובה <style> עם כללים. הסורק צדק שהוא אינו מדווח אותו, והמונה — רג’קס על הטקסט הגולמי — היה זה שספר יותר. אומת בדפדפן ש-<style> בתוך גוף <script>, <textarea>, <title> או הערת HTML אינו אלמנט סגנון, והמונה מנטרל את ארבעת האזורים לפני שהוא סופר.

  • בקובץ ממוזער כל הסימבולים מצביעים לאותה שורה, וזו התנהגות מוצהרת ולא באג. קובץ שכל תוכנו בשורה אחת מחזיר מפה שכל רשומה בה אומרת אותה שורה, כי שם הבלוקים באמת יושבים; ה-start וה-end נכונים והחוזה נשמר. ההצהרה נכתבה בתיעוד ולא רק בהערת קוד, כי מפה כזאת נראית כמו סורק שבור למי שלא יודע.

  • וקבוצת הסימבולים שהייתה לפני נשמרה בדיוק. הפלט על כל התבניות הושווה לפני מול אחרי כ**השוואת קבוצות** ולא כספירה — סימבול שזז בשורה וסימבול חדש שנוסף באותו מקום נותנים אותה ספירה ומסתירים זה את זה. כל סימבול קיים נשאר עם אותו שם ואותן שורות, וכל סימבול חדש נבדק שהוא יושב בתוך גבולות בלוק <style> ושהטווח שלו מאוזן בסוגריים.

  • fix: סוגר מסולסל בשורה נפרדת סגר את הפונקציה בשורת החתימה. בסגנון Allman — function foo() ואז { בשורה הבאה — המפה החזירה טווח באורך שורה אחת על פונקציה שלמה, בשלוש הצורות: הצהרה, ביטוי מוצב וחץ. הענף שסוגר בסוף שורה קיים בשביל חץ בלי גוף מסולסל, ולא הבחין בין ”אין גוף“ לבין ”הגוף מתחיל בשורה הבאה“. ההחלטה נלקחת עכשיו ברגע ההתאמה: אומת ב-Node 22 ש-``function`` בכל צורותיו הוא שגיאת תחביר בלי גוף בסוגריים מסולסלים, ולכן צורה כזאת ממתינה תמיד; אצל חץ נבדק מה בא אחרי ה-=>, תוך דילוג על הערות — כי function foo() ואחריו שורת הערה ואז { הוא קוד תקין.

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

2026-09-09

  • fix: מספר השורה במפת ה-HTML נגזר מהאינדקס במקום להיות מתוחזק תוך כדי סריקה. קפיצה שמזיזה את מקום הקריאה ביותר מתו אחד עקפה את ספירת השורות, ומשם כל סימבול נוסף באותו בלוק סקריפט קיבל שורה שגויה — בשקט, עם status: "ok". שני מסלולים היו כאלה: \ ואחריו שורה חדשה אמיתית בתוך מחרוזת (המשך שורה חוקי ב-JavaScript), וחתימת פונקציה שנפרסת על כמה שורות. עכשיו הטבלה נבנית פעם אחת מכל \n בקובץ, ואין ספירה שאפשר לדלג עליה.

  • fix: ``const f = function (a, opts = {})`` קיבל טווח באורך שורה אחת. התיקון הקודם ל“ברירת מחדל סוגרת את הפונקציה בשורת החתימה“ נשען על צורת הטקסט שהותאם, ולכן לא חל על צורת הביטוי המוצב. ”האם אנחנו עדיין ברשימת הפרמטרים“ נגזר עכשיו מעומק הסוגריים העגולים שהלולאה סופרת בעצמה.

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

  • fix: תגית Jinja שלא נסגרה גנבה את הסוגר של התגית התקינה שמתחתיה. חיפוש ה-%} החזיר את המופע הבא בקובץ ולא את הסוגר של התגית עצמה, ולכן {% block %} תקין שיושב אחרי תגית שבורה נעלם מהמפה לגמרי. תגית שלא נסגרה אינה תגית: מדלגים עליה וממשיכים לסרוק, וגם אינה מחזירה עוד שם קטום.

  • fix: ``id`` או ``type`` שיושבים בתוך ערך של תכונה אחרת ניצחו את האמיתיים. התכונות נקראו ברג’קס על המחרוזת הגולמית ונפרסות עכשיו פעם אחת. שתי תוצאות: עוגן שגוי שאינו קיים בקובץ, ובלוק <script> שסווג כלא-JavaScript וכל הפונקציות שבתוכו נעלמו. אומת מול Chromium 141: <div title="x id=decoy" id="real"> נותן real, והבלוק עם data-note="see type=text/plain" כן רץ.

  • fix: לוכסן בסוף ערך תכונה לא מצוטט נקרא כסגירה עצמית. <a id="k" href=/> סומן כתגית שסוגרת את עצמה, ולכן קיבל טווח באורך שורה וה-</a> שאחריו לא מצא התאמה. אומת מול Chromium: הלוכסן שייך לערך, והטקסט שאחרי התגית יושב בתוכה. /> על אלמנט ב-SVG ממשיך לסגור את עצמו.

  • fix: הרג’קס שמזהה ``function`` היה ריבועי, ורקורסיה בסורק המחרוזות הייתה בלי חסם. בצורה הקודמת שני \s* היו צמודים ומופרדים באטום אופציונלי, ולכן התאמה כושלת אחת מול רצף רווחים עלתה ריבועית: על אותו קלט סינתטי, 9.8 שניות ל-40KB לפני ולעומת אלפית שנייה אחרי, וסדר גודל של שבוע בתקרת ה-10MB שהכלי מתיר. ובמקביל, ${…} מקונן נכנס למסגרת רקורסיה חדשה לכל רמה, ולכן קובץ של כשלושה קילובייטים הפיל RecursionError שאיש לא תפס לאורך המסלול עד לקוח ה-MCP — סתירה למה שהמודול מצהיר על עצמו, שערוץ הכשל הוא ערך ההחזרה ולא חריגה. מחסנית מפורשת החליפה את הרקורסיה, וחמישים אלף רמות קינון עוברות עכשיו.

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

  • feat: מפת הסימבולים (``outline``) תומכת בתבניות HTML/Jinja. {% block %}, {% macro %}, {% extends %}/{% include %}, אלמנטים עם id, בלוקי <script>/<style> — ובעיקר הגדרות הפונקציות בתוך בלוק סקריפט. ב-base.html הבלוק הגדול ביותר הוא מעל שבע-מאות שורות, ובלי ירידה לתוכו המפה נותנת גבול ולא ניווט. השמות שטוחים ולא מנוקדים, כי ב-HTML אין מרחבי שמות; התחילית נוספת רק כשלבלוק יש id.

  • הסורק הוא לקסיקלי ולא פרסר עץ, ובכוונה. תבנית Jinja אינה HTML תקין — תגית שנפתחת בענף אחד של {% if %} ונסגרת באחר היא הכתיב הרגיל. פרסר DOM מאזן את זה בשקט ומחזיר שורות שאינן במקום שבו הטקסט יושב.

  • שלושה כללים חיצוניים אומתו מול Chromium ולא נכתבו מהזיכרון. רשימת ה-void elements (param הוצא מהמפרט אבל הדפדפן עדיין מתייחס אליו כך — נלקח האיחוד); ההבחנה בין <script> שהוא JavaScript לבין data block, לפי ”MIME type essence match“ — text/javascript; charset=utf-8 אינו רץ; והעובדה ש-</script> בתוך מחרוזת JavaScript כן סוגר את האלמנט, כך שהיציאה מהבלוק אינה מכבדת מחרוזות.

  • refactor: ``extract_outline`` הפכה למנתב לפי סיומת, והלוגיקה של כל שפה יושבת ב-mcp_server/outline_scanners/. המיון והסינון נשארו במנתב, כדי שסורק חדש לא יוכל לשכוח אחד מהם.

  • fix: קובץ עם ``r`` בודד נדחה כ-``no_outline`` במקום להפיל ``IndexError``. ast סופר עם universal newlines וקריאת הטווח מפצלת ב-split("\n"); בקובץ כזה השתיים נפרדות, ומפה שהייתה חוזרת מצביעה לשורה ש-lines= לא מגיע אליה. CRLF אינו מושפע.

  • feat: בורר גודל טקסט לפתקים בעמוד ההגדרות. רגיל (14px), בינוני (15px) וגדול (16px), בסעיף ”גופן הפתקים“. הבחירה חלה על שני המשטחים יחד — דפדפן הריפו וקבצי Markdown — ואי אפשר להפריד ביניהם. הלוחות אינם מושפעים: להם נשאר הבורר שבמודאל, לכל לוח בנפרד.

  • הבחירה נשמרת בשרת ולא ב-``localStorage``, ולא מטעמי סגנון. ה-cookie של ההעדפה הוא httponly, ולכן JS אינו יכול לקרוא אותו כלל; והיא צריכה לעבור בין מכשירים, מה ש-localStorage אינו עושה. אותו מסלול בדיוק שבו עוברת בחירת כתב היד שלצידה.

  • בורר תחולה נפרד לגודל. ”לכל המכשירים“ / ”רק במכשיר הזה“ משלו, ולא זה של כתב היד — כדי שאפשר יהיה להחזיק טקסט גדול בטאבלט וכתב יד בכל המכשירים. שני cookies נפרדים, ובדיקה שמוודאת שאחד אינו גורר את השני.

  • ההעדפה נכנסה לוולידטור של ה-ETag, ולא רק ל-DB. /md/<id> מרנדר את הגודל לתוך ה-HTML; בלי זה שינוי ההגדרה היה מחזיר 304 והדפדפן היה מציג את הגודל הישן. אותה מלכודת שבגללה נוצר _note_fonts_etag_key עבור כתב היד — והמפתח נושא היום את שתי ההעדפות. באותה נשימה נוספו השדה לפרויקציה של שליפת מסמך המשתמש ולתנאי שמדלג על השליפה: שדה שחסר באחת מהן אינו קורס, הוא פשוט חוזר לברירת המחדל.

  • הקוקי נבדק בתגובה עצמה, ולא רק הסטטוס. במצב ”רק במכשיר הזה“ שום דבר אינו נכתב ל-DB, ולכן ערך שנשכח ברשימת הקוקיז מחזיר 200 בלי לשלוח את הקוקי — כשל שכבר קרה כאן פעם. בדיקה שהסתפקה ב-200 הייתה עוברת עליו במלואו.

  • refactor: ”אילו גדלים קיימים“ ו“מה כל תפריט מציע“ הופרדו לשני מקורות. STICKY_NOTE_FONT_MENUS הצטרפה למפה, כי שני הבוררים אינם מציעים את אותם גדלים — הלוח 14/16/18 ועמוד ההגדרות 14/15/16. מקור אחד היה מכריח כל תפריט להציע את מה ששייך לשני.

  • fix: ערך ששייך לעמוד ההגדרות היה מרוקן את הבורר שבלוח. הלוח הציב את הערך השמור על ה-<select> אחרי אימות מול המפה; ערך שאין לו <option> הופך את selectedIndex ל--1 במקום ליפול ל“רגיל“. הלוח מאמת עכשיו מול התפריט שלו, גם בהצבת הבורר וגם בסקריפט הראש — אחרת התצוגה והבורר מציגים שני דברים שונים.

  • fix: מנשא בדיקות ה-JS החליף רק את המופע הראשון של ביטוי Jinja. ביטוי שני היה נשאר בקוד כטקסט ומפיל את ההרצה בשגיאת תחביר שאינה מרמזת על הסיבה. ריצת בקרה: 25 מתוך 26 בדיקות נפלו. replaceAll מסיר את המלכודת, וההערה בתבנית כבר אינה מנמקת את מבנה הקוד במגבלת הבדיקה.

  • fix: בדיקות עמוד הלוח טענו על מחרוזת ולא על האלמנט. 'noteFontSizeSelect' in html התקיים גם אחרי שהבורר נמחק מהמודאל, כי אותו מזהה חוזר גם ב-getElementById שבגוף העמוד. שתי הבדיקות — הבורר ומתג כתב היד — טוענות עכשיו על התגית עצמה.

  • feat: בורר גודל טקסט בהגדרות הלוח. שלוש אפשרויות — רגיל (14px, ברירת המחדל), גדול (16px) וגדול מאוד (18px) — לכל לוח בנפרד, נשמר מקומית בדפדפן כמו שאר הגדרות הלוח. הפתק כולו גדל: נמדד בכרומיום, ותשעה רכיבים — תצוגה, תיבת עריכה, כותרת, קוד בשורה, בלוק קוד, תווית שפה, טבלה, גוף אלרט והזחת קינון — יצאו ביחס זהה בדיוק בשלושת המצבים. לוח שנשאר על ”רגיל“ נראה ביט-זהה למצב הקודם. הבורר הזה הוא לכל לוח בנפרד; לשאר המשטחים יש בורר משלהם בעמוד ההגדרות, ראו למעלה.

  • refactor: ``font-size: 14px`` היה מוצהר פעמיים ואוחד לטוקן אחד. הוא ישב על תיבת העריכה ועל התצוגה שמחליפה אותה, עם הערה שהן ”אותו ארגז בדיוק“ — שני מספרים שחייבים להישאר שווים ואיש לא אכף. שניהם קוראים עכשיו מ---sticky-note-font.

  • הערכים בפיקסלים ולא ב-``em``, וריצת בקרה הראתה למה — חמור ממה שתועד. ההערה הקיימת בקובץ תיעדה ניסיון קודם שבו 1.08em החליף 14px ב-17.28px, כי em ב-font-size נפתר מול ההורה. במדידה הפעם, בסיס ב-em נתן לשני הצרכנים ערכים שונים — 18.24px לתצוגה ו-14.82px לתיבת העריכה — כלומר הוא שובר גם את ההבטחה ששני הארגזים זהים.

  • הערך השמור מאומת מול מפה ואינו מורכב לשם מחלקה. localStorage הוא קלט חיצוני; 'sticky-font-' + size היה מכניס כל מחרוזת ל-classList. הבדיקה מריצה שבעה ערכים פגומים, ובהם __proto__ ו-constructor.

  • feat: בלוקי אלרט (``::: note``) מרונדרים בתוך פתק דביק. כל סוגי האלרט שקיימים בתצוגת המסמך — note, tip, warning, danger, important, info, success, question, example, quote, experimental, deprecated, todo ו-abstract — עובדים עכשיו גם בפתק, עם אותו אייקון, אותו צבע ואותה כותרת בעברית. אין כאן פלטה שנייה: המחלקות .admonition/.admonition-<type> מגיעות מ-markdown-enhanced.css, שנטען ב-base.html ולכן זמין בכל משטח שמציג פתקים; sticky-notes.css מחזיק רק כיול לפתק הצר. בתוך האלרט עובד כל מה שעובד בפתק — מודגש, קוד, רשימות, טבלאות, גדרות וצ’קבוקסים — כי במקום ענף רינדור שני משתנה בלולאה דבר אחד: לאן שורה נכתבת.

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

  • התחביר נמדד מול ``markdown-it-container@4.0.0`` ולא נזכר. הושוו רצפי פתיחה-וסגירה מול הספרייה שמרנדרת את תצוגת המסמך, על עשרות קלטים. מכאן: :::note בלי רווח תקף; ::: NOTE תקף; ::: note כותרת נותן כותרת מותאמת; ::: note2 ו-::: note_x אינם אלרט ואילו ::: note.x כן; אלרט בלי שורת סגירה נמשך עד סוף הפתק; ובקינון — שורת סגירה סוגרת את החיצוני ביותר שאורך המרקר שלו קטן או שווה לה, ואיתו כל מה שבתוכו. הכלל האחרון הוא ההפך מהאינטואיציה (”סוגר את הפנימי“), והוא מכוסה בבדיקה על שלוש רמות בשני סדרי סגירה.

  • שתי סטיות מכוונות, ושתיהן מתועדות. בתוך גדר קוד ::: נשאר טקסט ליטרלי — ב-markdown-it הוא כן סוגר, שובר את הגדר לשניים ומוציא את שאר התוכן החוצה, וזו תוצאה גרועה למשתמש פתק וגם סותרת את מה שהפתק כבר עושה עם טבלה בתוך גדר. והזחה אינה פוסלת מרקר: לפתק אין מושג של בלוק קוד מוזח, ו-MD_FENCE_RE כבר מזהה גדר בכל הזחה.

  • feat: בלוק קוד בפתק מוצג ככרטיס — בלי תווי הגדר, עם שם השפה וכפתור העתקה. שתי שורות ה-``` נצרכות ואינן מופיעות בתצוגה, בדיוק כמו שורת המפריד של טבלה. שם השפה שאחרי הגדר הפותחת מוצג כתווית קטנה — הסתרת הגדר היא הסתרה ולא איבוד — ולצידו כפתור שמעתיק ללוח את הקוד בלבד, עם חיווי הצלחה וגם חיווי כשל.

  • שורת הפתיחה הפכה לכותרת הכרטיס, ונושאת את ה-``charOffset`` שלה. זה מה שמונע מבוי סתום: בלי שורת מקור בראש הבלוק, בלוק ריק (גדר ומיד גדר) היה יוצא בלי שום שורה לחיצה, ולא הייתה שום דרך לחזור ממנו לעריכה. שורת הסגירה נצרכת בלי אלמנט — החריג היחיד, וזהה לזה של הטבלה ושל האלרט.

  • refactor: הצריכה כיחידה מחקה שלושה סייגים. inFence ו-isFenceLine חייבו חישוב מוקדם של isFenceLine לפני בדיקת הטבלה, הבחנה בין !inFence ל-!inCode בכלל המחסנית, והחרגה של שורת הסגירה. עם _appendCodeBlock הלולאה לעולם אינה נמצאת בתוך גדר, ושלושתם נמחקו יחד עם הדגלים. ההתנהגות המתועדת ”רק הזחת שורת הפתיחה קובעת“ נשמרה ביט-זהה, והבדיקה שמכסה אותה עברה בלי שינוי.

  • fix: ההערה שנכתבה על הסדר בלולאה הייתה חצי נכונה, ותוקנה לפי מדידה. נטען בה שסדר הבדיקות מגן גם על הטבלה וגם על האלרט. בהיפוך סדר בפועל: מול הטבלה הסדר אכן ההגנה (```sh | x היא גם פותחת גדר וגם כותרת טבלה סבירה, והזזת הטבלה קדימה מפילה בדיקה), ומול האלרט הוא אינו משנה דבר — השורות זרות זו לזו, ומה שמשאיר ::: בתוך גדר כקוד ליטרלי הוא הצריכה ולא הסדר. סייג שנכתב בלי לבדוק אם הוא נדרש הוא חוב, לא הגנה.

  • ההעתקה קוראת את המקור ולא את ה-DOM. שורה ריקה בבלוק מרונדרת כרווח בודד, אחרת ה-div בגובה אפס והשורה נעלמת; קריאה מה-DOM הייתה מחזירה רווח במקום שורה ריקה, כלומר קוד שמודבק עם רווח מיותר בכל שורה ריקה. אומת בשני הכיוונים: נמדד ההפרש, ואז לחיצה אמיתית בכרומיום עם קריאה חוזרת מהקליפבורד שהחזירה את המקור ביט-זהה.

  • refactor: מנגנון קליפבורד אחד לשני הכפתורים. _copyText הוא התשובה היחידה ל“איך מעתיקים“, ושני הכפתורים עוברים דרכו; _flashCopyResult מקבל יעד מפורש, אחרת לחיצה על כפתור של בלוק קוד הייתה מהבהבת את כפתור הפתק. וה-title המקורי נשמר ומשוחזר במקום להיות מוקלד מחדש — כשל בהעתקת קוד היה משנה את ההסבר של הכפתור ל“תוכן הפתק“.

  • fix: רשימה שנפתחה בתוך אלרט דלפה החוצה. שורת הסגירה לא נגעה במחסנית הרשימות, בנימוק שזה מה שעושה שורת גדר סוגרת — נימוק שהעתיק מסקנה במקום את הראיה שמתחתיה. אצל הגדר זו הוכחה ולא בחירה: בתוך גדר שום דבר אינו נדחף למחסנית כי התוכן ליטרלי, ולכן לסגירה אין מה לסגור. בתוך אלרט התוכן עובר את המנוע המלא ו**כן** דוחף. התסמין: - א ואז ␣␣- ב בתוך האלרט, ו-␣␣- ג אחריו יצא בעומק 1, כבן של פריט שכבר אינו קיים. שורת הסגירה עוברת עכשיו בכלל האחיד — _closeListsAbove לפי ההזחה של עצמה — ולכן היא גם סוגרת את מה שנפתח בפנים וגם משמרת רשימה חיצונית כשהאלרט מוזח לתוכה. נמדד מול markdown-it על חמישה-עשר צירופים של רשימה × אלרט: חמישה סטו לפני, ואחד נשאר אחרי — והנותר הוא סטיית בלוק הקוד המוזח שכבר מתועדת. החלופה של שמירת עומק המחסנית בפתיחה ושחזורה בסגירה נמדדה גם היא ותיקנה פחות (שלושה סוטים מול אחד), כי היא מתעלמת מההזחה.

  • refactor: התוויות בעברית של האלרטים אוחדו למקור אחד. admonition-icons.js מחזיק עכשיו גם ADMONITION_TITLES לצד האייקונים, ושלושת הצרכנים קוראים משם — md_preview.html, live-preview.js והפתקים. קודם התוויות הוחזקו פעמיים, וכל עותק יכול היה לקבל סוג חדש בלי שהשני ידע. אומת בהרצה: כל הסוגים שבמפה ממשיכים להתרנדר בתצוגת המסמך עם התווית הנכונה, דרך הקוד שחולץ מהתבנית עצמה.

  • fix: ``note_board.html`` לא טען את מפת האלרטים כלל. הוא טוען את sticky-notes.js, ולכן בלוח כל אלרט היה מוצג כטקסט רגיל — בלי שגיאה ובלי שום סימן. נוספה שם הטעינה, ולצידה בדיקה שסורקת את כל התבניות ומאמתת שכל אחת שטוענת את המודול טוענת גם את המפה, ולפניו.

  • fix: שורת CSS שנראתה כמו הגנה ולא עשתה דבר. הכיול לפתק כתב margin: .35em 0 ואחריו margin-inline: 0 כדי לבטל את המרווח השלילי שכלל המובייל מחיל על .admonition. מדידה בכרומיום הראתה שהשורה השנייה חסרת השפעה — הקיצור כבר איפס את הצדדים — כלומר גם השומר הטקסטואלי שנכתב עליה שמר על כלום. הפיצול ל-margin-block ול-margin-inline הופך אותה לנושאת משקל, כי המפל פועל לכל תכונה בנפרד: נמדד בבקרה, פתק ברוחב 260 באזור תצוגה של 390 מקבל 0px עם השורה ו--8px בלעדיה, והאלרט חוצה את גבול הפתק. באזור תצוגה של 1024 אין הבדל כלל.

2026-09-08

  • feat: ערכה מיובאת יכולה לקבוע לעצמה את צבע שמות הקבצים בכרטיס אוסף. שם הקובץ בדף /collections הוא <a>, ולכן dark-mode.css צובע אותו ב-var(--primary) דרך [data-theme="custom"] a — ספציפיות שגוברת על כלל המחלקה שב-collections.css. כרטיס האוסף נשאר לבן גם בערכה כהה, ולכן ערכה שה---primary שלה לבן הפיקה טקסט לבן על רקע לבן: נמדד בכרומיום מול השרת האמיתי, ניגודיות 1.00. הפתרון אינו דריסה גורפת אלא וו בהצטרפות מרצון: --collections-link-override נכנס לרשימה הלבנה, ובכוונה נשאר ללא ערך ברירת מחדל בשום מקום — כך שני הכללים ב-collections.css נופלים ל-var(--primary) במצב רגיל ול-var(--primary-dark) ב-:hover, בדיוק הערכים שנצבעו קודם. נמדד עם שתי ערכות במקביל: המצהירה 7.00 בשני המצבים, שאינה מצהירה 1.00 ו-4.81 — זהה לחלוטין למצב שלפני השינוי. הווו חל על שני המסכים שמציגים שמות קבצים: כרטיס אוסף (.collection-card__link) ושולחן העבודה (.workspace-card__link). שולחן העבודה הוא מסך נפרד עם מחלקות משלו, ולכן נשאר שבור בסבב הראשון — אותו <a> עם color:inherit, אותה דריסה, ואותם מספרים: 1.00 ← 7.00.

  • fix: ניסיון ראשון של הווו שינה גם ערכות שלא הצהירו, ותוקן. ברירת מחדל שנקבעה ב-:root[data-theme-type="custom"] גרמה ל-:hover להיפתר ל-var(--primary) בכל ערכה מיובאת, במקום ל-var(--primary-dark). בערכה שה---primary שלה לבן זה הוריד את ה-:hover מניגודיות 4.81 ל-1.00 — כלומר שם הקובץ נעלם גם במצב שבו קודם היה קריא. הלקח: טוקן שאמור לשמש כווו דריסה חייב להישאר בלי ערך ברירת מחדל, אחרת var(--token, <ברירת מחדל>) לא נכנס לפעולה והשינוי הופך לגורף.

  • feat: ערכת VS Code יכולה לשאת בלוק variables אופציונלי לצד colors. parse_vscode_theme קורא רק colors ו-tokenColors, ול-VSCODE_TO_CSS_MAP אין מפתח שמוביל לטוקנים שאין להם מקבילה ב-VS Code. בלי זה לא הייתה דרך להצהיר על הטוקן בלי לוותר על הדגשת התחביר, כי הפורמט המקומי אינו מעבד tokenColors.

  • fix: ערך פגום בבלוק variables נדחה במפורש ולא נזרק בשקט. ולידציית הערכים ב-validate_theme_json ישבה בתוך הענף שרץ רק כשאין colors, ולכן בערכת VS Code ערך כמו "teal" עבר את הוולידציה, נזרק אחר כך עם אזהרת לוג בלבד, והמשתמש קיבל 200 ו“הערכה יובאה בהצלחה!“ על ערכה שלא תוקנה. הבדיקה חולצה ל-_validate_variables_block ורצה עכשיו בשני המסלולים, עם הודעה שמציינת את המפתח.

  • docs: תוקנה סתירה בין התיעוד לקוד ב-POST /api/themes/import. העמוד תיעד גוף בקשה עם source ו-content; הקוד קורא json_content, ומזהה את הפורמט מתוך התוכן עצמו לפי נוכחות colors.

  • fix: מחיקה מהוובאפ הורידה לסל גרסה אחת, והקובץ חזר ברענון. קובץ שהמשתמש רואה הוא (user_id, file_name), ובמסד כל גרסה היא מסמך נפרד. עמוד הקבצים מקבץ את הגרסאות לפי שם ומוסר לממשק את ה-_id של הגרסה האחרונה בלבד, ו-POST /api/files/bulk-delete סינן בדיוק לפי המזהה הזה: הגרסה העליונה ירדה לסל, מה שמתחתיה נשאר פעיל, והקובץ חזר לרשימה גרסה אחת אחורה. קובץ עם גרסה יחידה נעלם סופית, ולכן שני קבצים שנמחקו באותה פעולה התנהגו שונה. המזהה משמש עכשיו לזיהוי הקובץ בלבד, והמחיקה עצמה לפי שם — כלומר כל הגרסאות.

  • fix: אותו באג היה גם בבוט, במחיקה המרובה. rf_delete_do רץ בלולאה על delete_file_by_id, שסינן אף הוא לפי מזהה גרסה. מחיקה של קובץ בודד — בבוט ומעמוד הקובץ בווב — הייתה תקינה מלכתחילה, ולכן הפער נראה כמו הבדל בין בוט לווב במקום מה שהוא: הבדל בין מחיקה בודדת למחיקה מרובה.

  • fix: כשל במחיקה מהבוט הוצג כהצלחה. הלולאה בלעה חריגות והמונה נשאר 0, ולכן תקלה במסד הופיעה למשתמש כ“✅ הועברו לסל 0 קבצים“. עכשיו יש הבחנה בין ”לא היה מה למחוק“ לבין ”לא ידוע אם נמחק“, והשנייה מוצגת כשגיאה.

  • refactor: שאילתת המחיקה מוגדרת פעם אחת, ב-file_deletion.pyשבשורש. הוובאפ החזיק מימוש מקביל שכותב ישירות ל-code_snippets, ולא עבר דרך database/repository.py — הוא מריץ על חיבור מונגו משלו. המודול מקבל את ה-collection כפרמטר, ולכן שני הצדדים מריצים את אותו קוד בלי לחלוק חיבור. אותה תבנית של file_dates.py.

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

  • change: ימי השהות בסל המיחזור אוחדו ל-30 לכל מסלולי המחיקה. עמוד הקובץ הבטיח 30 יום ומחיקה מרובה נתנה 7, כי כל מסלול קרא מקור אחר — קבוע בוובאפ מול config.RECYCLE_TTL_DAYS. עכשיו יש ערך אחד, והמספר במודאל האישור נגזר ממנו במקום להיות מוקלד בתבנית.

2026-09-07

  • feat: מתג ”תצוגה מצומצמת“ בהגדרות, לעמוד הקבצים. כשהוא דלוק כרטיס הקובץ מציג את שם הקובץ, באדג« השפה והתגיות בלבד; אייקון השפה, מספר השורות, הגודל, התיאור, שורת ”נוצר/עודכן“ וכפתור ההורדה אינם מרונדרים. צ’קבוקס הבחירה המרובה ושאר הכפתורים נשארים — data-file-id ו-file-checkbox הם חוזה עם הבחירה המרובה, והסתרתם הייתה שוברת פעולות קבוצתיות בשקט. ההעדפה נשמרת בחשבון (ui_prefs.files_compact_view) ותקפה בכל המכשירים, ונכנסת לתוקף בטעינה הבאה של העמוד. המידע מוסתר בכך שהתבנית אינה מרנדרת אותו, ולא ב-CSS: שלושת האזורים נושאים style="display: flex" inline, שגובר על כל מחלקה, ובדרך הזו גם לא נדרש שום CSS חדש ואין מה להתאים לערכות הנושא.

  • 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 (פרופיילר): דגלי ``$project`` נשמרים אמיתיים, ובלעדיהם השאילתה השמורה הייתה פעולה אחרת. $project נשאר בשלד המנורמל, ולכן כל שאילתה שנשמרה עם ערכים אמיתיים והכילה אותו יצאה עם {"file_name": "<value>"}. וזו אינה היטלה מוסתרת: מחרוזת שאינה מתחילה ב-$ בתוך היטלה נקראת כ**קבוע**, כלומר ”החזר את הקבוע <value>“ במקום ”החזר את השדה file_name“. נמדד מול MongoDB 8.0.32 — ה-explain מחזיר {"file_name": {"$const": "<value>"}}, ו-queryShapeHash שונה מזה של ההיטלה האמיתית, כלומר המנוע סופר אותן כשתי שאילתות. שלב שמושך את code נותח כשלב שאינו קורא שום שדה. הכשל היה שקט לגמרי כי בניגוד ל-$limit מחרוזת בהיטלה אינה גורמת למונגו לזרוק, ולכן _fix_pipeline_for_explain — שמתקנת רק את מה שזורק — לא נגעה בה. ⚠️ הוולידציה צרה בכוונה: התיעוד של $project אומר ”Non-zero integers are also treated as true“, כלומר {"file_name": 6865105071} הוא היטלה חוקית לגמרי שמזהה משתמש יושב בה בגלוי, וסריקת הבעלות עוברת על $match בלבד ולעולם לא תראה אותו. לכן מותרים 0/1/בוליאני/נתיב שדה בלבד, וזה חל ברקורסיה גם על היטלה מקוננת. $project שיש בו ולו ביטוי אחד חוזר כשלד שלם ולא כתערובת — שלב שחציו אמיתי נראה שלם ומתפרש אחרת ממה שרץ. $addFields/$set ו-$unset של אגרגציה נשארו בחוץ, כי אין להם היום מופע אמיתי לאמת מולו.

  • 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} אינו מתאים לאף מסמך במונגו, כלומר טבלה ריקה בלי הסבר.

  • fix (פרופיילר): הסיכום מהזיכרון מכבד את החלון. כשאין DB, או כשהחישוב נכשל, הסיכום נבנה מה-buffer שבזיכרון — וזה נעשה עד כה בלי חלון בכלל, כולל unique_patterns שספר את כל הדפוסים מאז עליית התהליך. כלומר בדיוק הפער שהחלון המשותף בא לסגור, ברגע שבו קשה לשים לב אליו. שני אתרי הפולבאק עברו לספירה מסוננת, ו-unique_patterns נספר כמו ב-$addToSet שבמסלול ה-DB.

  • fix (פרופיילר): ”יש דף נוסף“ נגזר מרשומה שנראתה ולא מניחוש. הקורסור נפלט כשהדף התמלא, ולכן בסך שמתחלק בדיוק בגודל הדף הכפתור ”טען עוד“ נשאר גלוי לצד כותרת שאומרת ”מוצגות 6 מתוך 6“, והלחיצה החזירה אפס שורות. השאילתה מושכת limit + 1 ומחזירה limit.

  • fix (פרופיילר): בקשות עימוד ומיון מקבילות כבר אינן דורסות זו את זו. לחיצה על כותרת מיון ואז על ”טען עוד“ לפני שהראשונה חזרה — והתגובה שמגיעה אחרונה כתבה את הטבלה ואת הקורסור. וזה חמור במיוחד כאן: הקורסור נטבע למיון מסוים, אז תגובה מאוחרת השאירה קורסור של מיון ישן, והלחיצה הבאה נדחתה ב-400 או החזירה שורות אחרות. נוסף מזהה דור, והכפתור מנוטרל בזמן בקשה — כך אותו קורסור אינו נשלח פעמיים. ההחזרה לפעילות יושבת ב-finally: בקשה אחרונה שנכשלה הייתה משאירה כפתור מנוטרל לצמיתות בלי יציאה חוץ מרענון.

  • fix: גודל קובץ מוצג בכל מקום לפי אותו כלל, ובסדר קריאה נכון. 105.0 KB הפך ל-105 KB — ספרה אחרי הנקודה נשארת רק כשהיא אומרת משהו. וחשוב מזה: "105 KB" בתוך כרטיס בעברית היה מתהפך על המסך ל-KB 105, כי אלגוריתם ה-bidi אינו מדביק מספר למילה לטינית דרך רווח ניטרלי — הרווח נופל לכיוון הפסקה והמחרוזת נשברת לשני קטעים. נמדד ב-Chromium: KB ב-x=325 מול 105 ב-x=350. הערך נושא עכשיו בידוד דו-כיווני (LRI/PDI) בתוך המחרוזת עצמה ולא ב-dir על האלמנט, כי לא לכל גודל יש אלמנט משלו — "הקובץ גדול מדי לתצוגה (105 KB)" נבנה כמחרוזת אחת. המשמעות לקוד שקורא את הערך: "105 KB" in result עדיין נכון, השוואת שוויון מדויקת דורשת את העטיפה.

  • change: שישה מימושים של עיצוב גודל בצד הלקוח אוחדו לאחד (webapp/static/js/utils/size-format.js, נטען מ-base.html). הם נבדלו זה מזה בתקרת היחידות, ברווח לפני היחידה ובעיגול, ושלושה באגים אמיתיים נבעו מכך: live-preview חילק ב-1024 פעם אחת בלבד והציג קובץ של 3.5 מגה כ-3584KB ושל 582 בתים כ-0.6KB; global_search עצר ב-MB והציג 2 ג’יגה כ-2048 MB; repo-browser עצר ב-GB והחזיר 3 undefined מעל טרה-בייט. כל שלושתם תוקנו בעצם האיחוד.

  • fix: השרת והדפדפן הסכימו על כל גודל חוץ מאחד. f"{1.25:.1f}" בפייתון מעגל חצי לזוגי ומחזיר "1.2", ו-(1.25).toFixed(1) ב-JS מעגל חצי כלפי מעלה ומחזיר "1.3" — כלומר קובץ של 1280 בתים הוצג 1.2 KB מהשרת ו-1.3 KB מהדפדפן. הפער נתפס בבדיקה שמריצה את שני המימושים על אותו וקטור ומשווה, ולא בקריאת הקוד: שני הקבצים נראים זהים, וכל אחד פשוט נשען על ברירת המחדל של שפתו. העיגול נכתב עכשיו במפורש בשתי השפות באותן פעולות על אותם doubles.

  • fix: המודול המשותף נטען בלי defer, וזו לא השמטה. compare_files.html קורא ל-CompareView.initFilesMode ב-script אינליין שרץ בזמן ניתוח המסמך, ומשם — כשיש קבצים נבחרים מראש — הוא מגיע ל-formatFileSize מיד. סקריפט דחוי עדיין לא רץ באותו רגע, ולכן עמוד ההשוואה נפל ב-TypeError וכרטיסי התצוגה לא נטענו. בדיקת הרגרסיה שולפת את תג ה-script מ-base.html** עצמו** ולא כותבת אותו מחדש, ולכן החזרת defer מפילה אותה.

2026-09-06

  • feat (פרופיילר): הדשבורד קיבל מיון בעמודות, כפתור ”טען עוד“, ומקטע דפוסים חוזרים. וקודם כול — חלון זמן אחד: הכרטיס למעלה ספר 24 שעות, הטבלה משכה 50 שורות בלי חלון בכלל, ו-get_pattern_statistics עבדה על שבעה ימים. שלושה מספרים על שלוש אוכלוסיות, על אותו מסך. עכשיו PROFILER_WINDOW_HOURS הוא המקור היחיד, והטבלה אומרת ”מוצגות X מתוך Y“ — כששניהם סופרים את אותו דבר.

  • fix (פרופיילר): הקאש של הסיכום ממופתח לפי החלון. כל עוד החלון היה קשיח ערך יחיד היה נכון; מרגע שהוא פרמטר, בקשה על 24 שעות הייתה מקבלת תוצאה שחושבה עבור שבוע — תשובה של פרמטר אחר, בשקט מוחלט. _invalidate_summary_cache מנקה את כל החלונות, כי רשומה חדשה משנה את כולם.

  • feat (פרופיילר): העימוד הוא cursor ולא skip, לפי docs/database/cursor-pagination. האוסף מקבל כתיבות בזמן שמסתכלים בו — זו כל מטרתו — ועם skip שאילתה איטית שנרשמת בין שתי לחיצות מזיזה את החלון: שורה אחת מוצגת פעמיים והבאה נדלגת. הקורסור נושא את ערך עמודת המיון ואת _id, מקודד ב-Extended JSON כך שתאריך ומספר עוברים באותו מנגנון, ונושא גם את השדה והכיוון שהוא נטבע עבורם — קורסור שנשלח עם מיון אחר נדחה ב-400 ולא מנוחש.

  • fix (פרופיילר): כפתור ”טען עוד“ נשאר גלוי אחרי הדף האחרון. .btn מגדיר display:inline-flex, וכל הכרזת display של המחבר מנצחת את [hidden]{display:none} של הדפדפן — כלומר כפתור שסומן מוסתר המשיך להיראות, ולחיצה עליו לא עשתה כלום. אותה טעות בדיוק מתועדת ב-note-boards.css, ואותו כלל הוחל כאן. נתפס בטסט דפדפן.

  • feat (פרופיילר): כרטיס ”דפוסים ייחודיים“ הפך לקישור עוגן אמיתי למקטע הדפוסים, כמו כרטיס ”שאילתות איטיות“. get_pattern_statistics הייתה כתובה, מאונדקסת, ובלי אף קורא בכל הריפו; היא קיבלה $facet עם ספירה, כי קודם היא החזירה 50 שורות בלי לדעת כמה יש — ולכן החיתוך שלה לא היה ניתן לדיווח.

  • fix (פרופיילר): שאילתה עם תאריך נשמרת עם הערכים האמיתיים במקום להידחות. query_raw נוסע עכשיו ב-Extended JSON — ניב JSON שנושא את הטיפוס בתוך ה-JSON עצמו ({"$date": …}) — ולכן datetime, ObjectId, Decimal128 ו-bytes חוזרים מהמסע שווים למקור. קודם הם נדחו, וזו הייתה דחייה נכונה אך יקרה: היא חסמה בדיוק את שאילתת העמוד השני של /files, זו שבגללה הפיצ’ר נבנה. נמדד מול הקלאסטר למה לא לשמור אותם כמחרוזת: created_at < <תאריך> מתאים ל-1,157 מסמכים, ואותו תאריך כמחרוזת ל-0 — כלומר explain מהיר עם אפס סריקה ויעילות מושלמת, דוח שנראה מצוין ומסקנתו הפוכה. הבקשה שמחזירה את הערכים לניתוח מצהירה על הניב (encoding) ולא מסיקה אותו: פענוח גורף היה חל גם על השלד המנורמל, ושם {"$options": "<value>"} הופך בשקט ל-Regex עם דגלים אקראיים במקום לייצר שגיאה רועשת ממונגו. inf/NaN ממשיכים להידחות, כי ההחלטה מה בטוח לשמור נעשית בזמן הכתיבה ולא בזמן ההגשה.

  • fix (פרופיילר): הדוח שמועתק ל-AI הפסיק להצהיר ”אין בדוח נתונים אישיים“ כשיש בו כאלה. המשפט נכתב ללא תנאי, ומרגע שהניתוח רץ על הערכים האמיתיים הוא הצהיר בדיוק את ההפך ממה שהדוח מכיל. עכשיו הוא נגזר מהניב שנשלח בפועל.

  • fix (פרופיילר): כשל בלתי צפוי בהחלטה על הערכים האמיתיים כבר אינו מפיל את הרשומה. עד כה נתפסה שם רק חריגת הדחייה המתוכננת, וכל חריגה אחרת ברחה עד המאזין ב-DB — כלומר השאילתה האיטית לא נרשמה בכלל, ונשארה רק שורת Profiler Error. query_raw הוא העשרה, והרשומה היא המוצר: מעכשיו התקלה נרשמת ללוג, מוצגת כ-internal_error בדשבורד, והרשומה שורדת.

  • feat (פרופיילר): שאילתה איטית שלך נשמרת גם עם הערכים האמיתיים, ולא רק כשלד. עד כה כל ערך הוחלף ב-<value>, כך שגם האדמין שניתח את השאילתות של עצמו קיבל explain על {"user_id": "<value>"} — אפס תוצאות ומסקנות ריקות. PROFILER_UNREDACTED_USER_IDS (ריק = כבוי) מחריג מזהים מפורשים, ורק שאילתה שמצהירה בוודאות על אחד מהם נשמרת עם ערכים. כל דחייה נרשמת ב-raw_withheld_reason ומוצגת בדשבורד — גם בשורות update/delete שאין להן כפתור ניתוח, כי דווקא שם אין רמז אחר. ”ניתן להרצה חוזרת“ מוגדר בסיבוב JSON ולא ברשימת טיפוסים, ולכן datetime ו-inf נדחים בשמם במקום להישמר כמחרוזת שמריצה שאילתה אחרת. $limit/$skip/כיווני $sort כן נשמרים אמיתיים — הם צורת השאילתה ולא נתוני משתמש, ובלעדיהם ה-explain מתאר מיון חוסם במקום top-k. query_shape ו-query_id לא השתנו, כך שקיבוץ הדפוסים נשאר כשהיה, והערכים חיים ב-DB בלבד תחת ה-TTL — ה-buffer שבזיכרון מקבל עותק בלי הערכים, כי הוא חסום בגודל ולא בגיל.

  • fix (תיעוד): הטענה ש-X-Profiler-Token הוא דרך גישה חלופית לפרופיילר הוסרה. _profiler_is_authorized מסתיימת בבדיקת אדמין בכל מסלול, וכשיש סשן אדמין היא אינה בודקת את הטוקן כלל — כלומר הוא אינו פותח גישה ואינו חוסם אותה. אומת בהרצה. הקוד לא שונה: הרפיית בדיקת הרשאות היא החלטת מוצר, ולא משהו שמתקנים בשקט מתוך תיקון תיעוד.

  • docs (תפעול): התרופה שב-**``performance-sticky-notes``** תוקנה — ההנחיה שהייתה שם לא השפיעה על השירות. העמוד הנחה להגדיר GUNICORN_CMD_ARGS="--timeout 180 --graceful-timeout 180" וקרא לזה ”תרופה מוכחת“. scripts/start_webapp.sh מעביר ל-Gunicorn דגלי --timeout ו---graceful-timeout מפורשים, ו-Gunicorn מחיל את GUNICORN_CMD_ARGS לפני דגלי שורת הפקודה ומיד אחר כך דורס אותם — אומת בהרצת Gunicorn 23.0.0 (הגרסה בפרודקשן) ובקוד gunicorn/app/base.py. העמוד מתאר עכשיו את המנגנון האמיתי: WEBAPP_GUNICORN_TIMEOUT/GUNICORN_TIMEOUT, ולמה עם worker של gevent ה---timeout מודד שתיקה של worker ולא אורך בקשה. שמות הסעיפים בעמוד השתנו בהתאם.

  • docs: ``DISABLE_STARTUP_WARMUP`` מכבה שני חימומים ולא אחד — גם את ה-Observability וגם את אינדקסי הפתקים הדביקים — והוא דלוק כברירת מחדל בקוד. התיאור שלו ברפרנס וב-Config Inspector עודכן, כי ”חימום שרץ בעלייה“ היה ההנחה שהעמוד הישן נשען עליה.

  • fix (חיפוש סמנטי): הצ’אנקים נחתכים לפי תקציב בייטים ולא רק לפי מספר שורות. ל-gemini-embedding-001 תקרת קלט של 2,048 טוקנים, והוא חותך בשקט כל מה שמעבר — בלי שגיאה, בלי אזהרה, עם וקטור שנראה תקין לגמרי. החיתוך הישן ספר 220 שורות בלי לבדוק כמה טקסט יצא: ב-JSON עם מספר בכל שורה זה ~4,300 בייט, ובמארקדאון עברי צפוף עד 24,000. בפרודקשן חצי מהצ’אנקים חצו את הסף, והווקטור שלהם תיאר רק את ההתחלה שלהם — כלומר סוף של קובץ ארוך פשוט לא היה נמצא בחיפוש, בלי שום סימן שמשהו שבור. נוסף CHUNK_MAX_BYTES (ברירת מחדל 2,000) עם חפיפה של 15%, שורה ארוכה מהתקציב (SVG/JS ממוזער) נחתכת לחתיכות, ואין יותר השמטת זנב — איחוד טווחי השורות מכסה את כל הקובץ. קישור ל-Issue רלוונטי: #3332.

  • feat: chunkerVersion על כל קובץ מחליף פקודת re-index ידנית. אחרי דיפלוי ה-worker מזהה לבד אילו קבצים נחתכו לפי כלל ישן ומעבד אותם מחדש ברקע. השדה נכתב רק בנתיב שבו הטיפול במסמך באמת הסתיים — אחרת מסמך ריק או גרסה ישנה היו נשלפים בכל סבב ותופסים את חמשת המקומות בבאץ«, ועבודה אמיתית לא הייתה מתוזמנת לעולם.

  • fix: כשל בהטמעת צ’אנק בודד כבר אינו מחזיר את הקובץ לתור לנצח. עד כה כל כשל סימן needs_embedding=True, והקובץ נשלף שוב כל 300 שניות עם כל הצ’אנקים שלו — נמדד על הקוד הישן. מעכשיו רק כשל זמני (timeout, רשת, 5xx) מחזיר לתור; 400 נרשם כאירוע ולא חוסם. מיצוי ה-retries על 429 מדווח כ-429 ולא כ-0, כך שמכסה שנגמרה נראית שונה מ-timeout: ה-worker עוצר את הבאץ« ומחכה במקום לשרוף עליו עוד קריאות.

  • fix: מחיקת קובץ מורידה גם את הצ’אנקים הסמנטיים שלו. ה-delete_many היחיד על snippet_chunks בכל הריפו היה בתוך save_snippet_chunks, ולכן נמדדו בפרודקשן 355 צ’אנקים יתומים (6.5MB) על פני 118 קבצים מחוקים. הניקוי חובר לכל נתיבי המחיקה — בשכבת ה-DB ובראוטי סל המיחזור שכותבים ישירות לאוסף — ושחזור מסמן את הקובץ לבנייה מחדש.

  • feat: ג’וב יומי מנקה צ’אנקים יתומים. הוא נחוץ כי שני מקורות של יתומים אינם עוברים דרך קוד אפליקציה בכלל: פקיעת סל המיחזור נעשית ב-TTL index בצד השרת, ושמירת גרסה חדשה אינה מכבה את הקודמת — כך שכל גרסה היסטורית נשארה מאונדקסת ומתחרה על מקומות ה-ANN.

  • fix: אינדקס (userId, snippetId) על snippet_chunks נוצר באתחול הרגיל. הוא הוגדר עד כה רק בסקריפט מיגרציה חד-פעמי, ובקלאסטר שנמדד נותר רק _id_ — כלומר כל מחיקת צ’אנקים סרקה את כל הקולקציה.

  • feat: רף ציון על החיפוש הווקטורי (SEMANTIC_MIN_VECTOR_SCORE). חיפוש וקטורי עונה על ”מה הכי קרוב“ ולא על ”מה מתאים“, והוא תמיד ממלא את ה-limit: חיפוש ”open“ החזיר קובץ שהמילה אינה מופיעה בו אפילו פעם אחת. הרף חל על הציון הגולמי של $vectorSearch (טווח 0..1) ולא על ציון ה-RRF, שהוא בסקאלה אחרת לגמרי — סף שנבחר בטעות על הסקאלה הלא נכונה כבר סינן פעם אחת את כל התוצאות. ברירת המחדל 0 (כבוי) עד לכיול על נתונים אמיתיים.

  • fix: numCandidates בחיפוש הווקטורי גדל עם הקורפוס. limit * 20 הוא מספר קבוע — 200 מועמדים ל-limit=10, שהם 5.7% מ-3,483 צ’אנקים ורק 1.2% מ-17,000. אותו מספר בדיוק פוגע ברקול ככל שהקורפוס גדל, וזה היה נראה כאילו הצ’אנקים הקטנים הרעו את החיפוש.

  • change: הווקטורים נשמרים כ-BSON BinData subtype 9 (float32) במקום כמערך doubles. נמדד: 9,887 בייט למסמך מול 3,087 — חיסכון של 3.2×. אומת מול הקלאסטר לפני המימוש: מסמך BinData נכנס ל-vector_index הקיים, החזיר ציון 1.0 מדויק מול הווקטור של עצמו, ובאותה שאילתה חזרו גם מסמכי מערך — כלומר שתי הצורות חיות יחד תחת אותו path בזמן ה-re-index, ולא נדרש אינדקס חדש.

  • feat: צ’אנקים שהם dump של מספרים (קובץ ה-export של טבלת האמבדינגים עצמה חולק ל-88 צ’אנקים ונשלח להטמעה) מדולגים. הסף כויל על כל 3,483 הצ’אנקים בפרודקשן: התוכן ה“מספרי“ ביותר שאינו dump עוצר ב-0.556, ומעל 0.6 יושבים רק ה-dump ונתיבי SVG.

  • מגבלה ידועה: במהלך ה-re-index (מספר שעות ברקע) החיפוש ממשיך לעבוד, אבל קובץ שטרם עובד נמצא באיכות של לפני התיקון. save_snippet_chunks מוחק את הצ’אנקים הישנים של קובץ רק אחרי שכל החדשים שלו כבר בזיכרון, ולכן בכל רגע נתון לכל קובץ יש או צ’אנקים ישנים או חדשים — אף פעם לא שניהם.

  • fix: הודעת ולידציה עם \r\n איבדה את הניקוי של שורת התיעוד, וסוגריים ריקות בתוך הערך שנדחה (input_value=[]) נמחקו יחד עם רעש ה-type=. שניהם היו מחיקה של מידע מאבחן, וזה בדיוק מה שהסיכום אמור לא לעשות.

  • feat: הודעת השגיאה ב-/admin/mcp מוצגת נקייה — שורה אחת לכל שדה שנדחה (lines.1 · Input should be a valid integer [input_value='9', input_type=str]) במקום ארבע שורות שרובן רעש: כותרת שנושאת את שם הכלי שכבר יש לו עמודה, הזחות, וקישור לתיעוד של Pydantic. הפירסור נכשל בטוח: מה שאינו נראה כמו הודעת Pydantic מוחזר כפי שהוא. המבנה נמדד על pydantic 2.12.3 ולא נלקח מהתיעוד — הרינדור הוא ב-Rust ואין קוד פייתון לקרוא.

  • fix: ההודעה והכוונה מוצגות ב-LTR מבודד בתוך העמוד ה-RTL. בלי זה האלגוריתם הדו-כיווני מזיז סוגריים וסימני שוויון לקצה הלא נכון, ו-[input_value='9'] נראה שבור. הכיווניות יושבת על התא, ולכן סדר העמודות נשאר RTL.

  • feat: לחיצה על הכוונה המקוצצת פותחת חלון עם הטקסט המלא. התא הפך ל-<button> אמיתי במקום span עם tabindex, ולכן Enter ו-Space עובדים בלי קוד משלנו וקורא מסך מכריז ”כפתור“. החלון עצמו הוא <dialog> נייטיב שנפתח ב-showModal(): נעילת הפוקוס בתוכו, סגירה ב-Escape והחזרת הפוקוס לכפתור שפתח מגיעות מהדפדפן ולא מקוד שלנו. הטקסט נכתב ב-textContent — מסלול שני לאותו טקסט שסוכן חיצוני כתב, ולכן הוא נבדק בנפרד בדפדפן.

  • feat: באנר ”X שגיאות חדשות מאז הביקור האחרון“ מעל טבלת הכשלים. הטבלה מציגה חלון נע של 30 יום, ולכן המספר הכולל יורד מעצמו כששגיאות ישנות נושרות ואינו יכול לשמש איתות; הבאנר משווה מול חותמת הזמן של החדשה ביותר שכבר נראתה. בביקור ראשון הוא שותק — אז הכול ”חדש“. localStorage חסום פשוט לא מציג אותו. כשהטבלה נחתכה בתקרה וכל השורות שהוצגו חדשות, הניסוח הוא ”לפחות X“: הבאנר סופר שורות ב-DOM, ואי אפשר לספור מה שהשאילתה לא החזירה.

2026-09-02

  • feat: מסך /admin/mcp מציג את הודעות השגיאה עצמן, מתחת לטבלת הכלים באותו טאב. הטבלה אמרה עד כה ”20% שגיאות“ ולא אמרה למה — כמו דוח מסירה בלי פתק המסירה. אנדפוינט חדש ב-PostHog (ck_mcp_tool_failures) מחזיר את הקריאות שנכשלו עם הכלי, הזמן, הלקוח וההודעה. קריאה שנכשלה לפני שההודעות נשמרו מוצגת עם — בעמודת ההודעה: הצינזור קרה בזמן השליחה ואינו הפיך, ותא ריק אינו כשל.

  • feat: עמודת file_reads בטאב עלות הניווט פוצלה לשתיים — אאוטליין מול קריאת תוכן. הן היו אותו כלי ולכן אותה עמודה, בזמן שהן הפוכות במשמעות: אאוטליין הוא המפה, קריאת תוכן היא הניווט שהמפה באה להחליף, ועמודה שסופרת את שתיהן יחד לא יכולה להראות שהאחת החליפה את השנייה. ההבחנה מגיעה מ-ck_read_mode — תווית מתוך קבוצה סגורה שהשרת מחשב מנוכחות הפרמטרים, ולא מהפרמטרים עצמם, שנשארים חסומים בשער הפרטיות. גרסה חדשה של האנדפוינט (ck_mcp_navigation_cost_v2); הקודמת נשמרת ב-PostHog כבסיס להשוואה.

  • feat: טור בטאב עלות הניווט שמציג את המשפט שהסוכן כתב על מה שהוא מנסה להשיג, במקום מזהה סשן אטום. הטקסט עצמו, לא סיכום — מקוצץ בתצוגה עם המלא ב-title, ומרונדר כטקסט בלבד (בלי |safe, בלי innerHTML).

  • feat: קישורים יוצאים מהעמוד לתצוגות של PostHog שאי אפשר להביא לכאן — אשכולות כוונות וסיכומי כוונה לסשן. הם כלי API ולא שאילתות, והעמוד מדבר עם PostHog רק דרך אנדפוינטים שמורים.

  • change (משפיע על לקוחות MCP): לכידת הכוונה נדלקה, ולכן לכל כלי נוסף פרמטר context. הוא מוצהר בסכימה של כל הכלים ומופיע ברשימת ה-required שלהם. קריאה שאינה מעבירה אותו אינה נדחית — נמדד: הכלי רץ בדיוק כמו קודם, והפרמטר אינו מגיע לגוף הכלי כלל. מה שהשתנה הוא מה שרשימת הכלים מצהירה. בלי זה $mcp_intent אינו נוצר על קריאת כלי, וטור הכוונה היה נשאר ריק לנצח. התיאור של הפרמטר הוא שלנו ולא ברירת המחדל הארוכה של ה-SDK, והוא מבקש מהסוכן במפורש לא לכתוב שם תוכן קבצים או סודות.

  • change (פרטיות): $mcp_error_message נשלח עכשיו על כל סוג שגיאה, ולא רק על ValidationError; ו-$mcp_intent נשלח על כל אירוע, ולא רק על $mcp_missing_capability. שניהם עדיין עוברים רק כשהערך מחרוזת. $mcp_parameters ו-$mcp_response נשארים חסומים בכל מסלול, ו-$exception_list[*].value נשאר מושחר בכל אירוע. המחיר מתועד ולא מוסתר: הודעת חריגה יכולה לשאת קטע מהקלט שנדחה (Pydantic שומר ראש וזנב של input_value), ומאז ההרחבה גם הודעה של ספרייה — נתיב, כותרת שחיפשנו. ראו את האזהרה ב-מדידת שימוש (PostHog MCP Analytics).

  • fix (אבטחה): POSTHOG_HOST שנושא פרטי הזדהות נדחה. urlsplit מחזיר username='' — מחרוזת ריקה, שהיא falsy — עבור https://:secret@us.posthog.com, ולכן בדיקה על הערך בלבד אישרה את הכתובת. הסיסמה נשארה בערך הגולמי שממנו נבנים גם נתיב ה-API וגם הקישורים היוצאים שמרונדרים לעמוד: סוד ב-href שנפתח בדפדפן, כלומר בהיסטוריה וב-Referer. הבדיקה עברה ל-is not None על username ועל password. אותה משפחה של POSTHOG_PROJECT_ID, בפעם השלישית באותו קובץ.

  • change (פרטיות): $mcp_error_message ו-$mcp_intent עוברים סינון סודות לפני השליחה — אותה רשימת דפוסים שמסננת את הפריימר, שעברה ל-mcp_server/redaction.py כדי ששני הצרכנים יייבאו אותה ולא יחזיקו עותק כל אחד. נמדד מה היא תופסת: כל צורת סוד מוכרת בכל מקום במחרוזת, כולל מפתח AWS בזנב של input_value של Pydantic. ונמדד גם מה לא: הכלל לפי שם (API_KEY=…) מעוגן לתחילת שורה ולכן אינו יורה על הודעה חד-שורתית. המסנן מצמצם חשיפה ואינו הופך את השדות לבטוחים.

  • change (פרטיות): $mcp_intent_source נאכף כתווית סגורה (context_parameter / inferred) במקום לעבור כמחרוזת. הוא ישב עד כה ברשימת המטא-דאטה, שאינה בודקת טיפוס כלל, ולכן מבנה שהיה מגיע תחתיו במהדורה עתידית של ה-SDK היה עובר שלם.

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

  • fix: הכוונה המקוצצת נגישה גם בלי עכבר — tabindex ו-aria-label לצד ה-title, שנחשף רק ב-hover.

2026-09-01

  • fix: שחזור ZIP לריפו חוזר להעלות את הקבצים לשורש הריפו. ה-ZIP של גיבוי ריפו הוא ה-zipball של GitHub — שכל תוכנו תחת תיקייה בשם owner-repo-sha — עם metadata.json בשורש. המסלול החזיק חישוב שורש משלו שסופר תיקיות בלבד, ולכן הקובץ בשורש לא הפריע; המעבר ל-detect_zip_common_root, שבה קובץ בשורש מבטל את הזיהוי, גרם לכל הריפו להיפרס בתוך תיקייה. החישוב המקורי הוחזר, ונוספה בדיקה מקצה לקצה למסלול — שהיעדרה הוא שאיפשר לרגרסיה לעבור בשקט. המסך שמבקש את הקובץ מתריע עכשיו שמבנה עץ התיקיות נשמר עבור קובץ גיבוי, וש-ZIP מסוג אחר — עם קובץ בשורש לצד תיקייה אחת — עלול להיפרס שטוח.

2026-08-31

  • fix: תאריך היצירה של קובץ נשמר בין גרסאות. כל עריכה יוצרת מסמך חדש ב-code_snippets, ועד עכשיו כל מסמך כזה נולד עם created_at טרי — כך ש“נוצר“ בוובאפ ובמסך המידע של הבוט הציג בפועל את זמן העריכה האחרונה. הירושה נוספה בשכבת ה-DB ובכל ראוט שכותב ישירות לאוסף: עריכה, שחזור גרסה, העלאה על קובץ קיים, שמירת מסמך משותף וייצוא סיפור תקלה. אותו תיקון הוחל על large_files.

  • fix: קובץ שמעולם לא נערך מקבל created_at ו-updated_at זהים בדיוק, במקום שני ערכים שנוצרו בקריאות נפרדות ל-datetime.now().

  • fix: שורת ”עודכן“ מוסתרת בוובאפ בקובץ שמעולם לא נערך. ההחלטה נקבעת בשרת מהתאריכים הגולמיים ולא מהשוואת המחרוזות המוצגות — הפורמט הוא ברזולוציית דקה, ולכן עריכה שקרתה באותה דקה שבה הקובץ נוצר הייתה נעלמת מהמסך. גם קובץ בלי updated_at מפסיק להציג שורת ”עודכן“ ריקה. בעמוד הקובץ ההסתרה נעשית עם hidden, ונוסף כלל CSS שגובר על .meta-item{display:flex} מ-global_search.css — בלעדיו התכונה לא הסתירה כלום.

  • refactor: שני כללי תאריכי הקובץ עברו ל-file_dates.py בשורש הריפו — מודול טהור שמייבא רק datetime ו-typing. כך שכבת ה-DB והוובאפ מייבאים את אותו כלל ישירות, בלי עותק fallback שצריך לתחזק במקביל. אותה תבנית של user_roles ושל sticky_notes_scope.

  • fix: שחזור מגיבוי אישי משמר את התאריכים שנשמרו בגיבוי. הייצוא כבר שמר created_at ו-updated_at כמחרוזות ISO, והשחזור לא קרא אותם — כך שכל קובץ, סימנייה או פתק שנעדר מהמסד קיבל את תאריך היום. חל על קבצים, קבצים גדולים, סימניות ופתקיות. נוספה _str_to_dt, ההפוכה של _dt_to_str שהייתה חסרה; ערך חסר או פגום מתנהג בדיוק כמו לפני התיקון, ולכן גיבויים ישנים ממשיכים לעבוד. אין שינוי בפורמט ואין bump ל-BACKUP_FORMAT_VERSION.

  • fix: updated_at של סימניות נכלל עכשיו בגיבוי, בשני מסלולי הייצוא. השדה קיים במסד אך מעולם לא נכתב לקובץ הגיבוי, ולכן השחזור לא יכול היה לקרוא אותו וכל סימנייה קיבלה את תאריך העדכון של רגע השחזור — מה שמשפיע על סדר הצגת הסימניות ועל הסטטיסטיקה ”נוצרו השבוע“.

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

  • fix: פעולות מטא-דאטה אינן מדווחות עוד על ”עריכה“. נעיצה לדשבורד, סימון מועדף, מחיקה רכה ושחזור מהסל חתמו updated_at על כל גרסאות הקובץ, למרות שאף בית של תוכן לא השתנה. התוצאה הייתה שקובץ שמעולם לא נערך הציג ”עודכן“, והוא קפץ לראש המיון ”עודכן לאחרונה“ — ובהיסטוריית הפעולות בדשבורד כל גרסאותיו הופיעו בבת אחת ברגע הנעיצה. לכל פעולה כזו יש שדה משלה (pinned_at, favorited_at, deleted_at), ו-updated_at נשאר על העריכה האחרונה בפועל. הכלל חל גם על ראוטי הוובאפ שכותבים ישירות ל-code_snippets ולא דרך שכבת ה-DB — מועדפים, מועדפים מרובים, העברה לסל, מחיקה מרובה, שחזור מהסל ותיוג מרובה. בעדכון המהיר, שמטפל גם בתיאור וגם בתגיות, החתימה נעשית רק כשהתיאור השתנה. בתיוג מרובה המונה שחוזר ללקוח עבר ל-matched_count, כדי שהמספר המוצג יישאר מה שהיה — $set על updated_at הפך עד כה כל התאמה למודיפיקציה, ובלעדיו תיוג חוזר באותה תגית היה מדווח אפס.

  • fix: היסטוריית הפעולות בדשבורד מציגה קובץ ולא מסמך גרסה, גם ב“טען עוד“. כל עריכה יוצרת מסמך חדש ב-code_snippets, והשאילתה לא קיבצה לפי שם קובץ — כך שקובץ עם חמש גרסאות הופיע בחמש שורות נפרדות, וגם המונה של ”טען עוד“ ספר מסמכים ולא קבצים. השאילתה, הקיבוץ ובניית האירוע מוגדרים עכשיו פעם אחת ומשמשים גם את העמוד וגם את ה-endpoint — עד כה הם היו שני עותקים, והקיבוץ תוקן בצד אחד בלבד. המיון קיבל נפילה ל-created_at (קובץ בלי updated_at היה שוקע לתחתית, כי מונגו משווה שדה חסר כ-null שנמוך מ-Date) ושובר שוויון על _id ($sort אינו יציב, ובדפדוף זה מתורגם לשורות כפולות בדף אחד וחסרות בבא). וכשל בספירת הקבצים כבר אינו מסתיר את כפתור ”טען עוד“: נשלפת שורה אחת מעבר לעמוד, וקיומה מכריע אם יש המשך. כך גם מספר קבצים שהוא כפולה מדויקת של גודל העמוד אינו מציע עוד לחיצה שחוזרת ריקה.

  • fix: ה-ETag של עמוד הקובץ הוא הוולידטור היחיד שלו. מצב המועדף והנעיצה מרונדרים לתוך ה-HTML אך נעדרו מהוולידטור, ונכונות הקאש ניצלה רק בגלל שפעולות המטא-דאטה הזיזו את updated_at — תופעת לוואי שנעלמה כשהפסקנו לחתום אותו. שני השדות נכנסו ל-ETag, ובמקביל If-Modified-Since לבדו כבר אינו מייצר 304 בעמוד הזה: אין שדה שמתעד מתי מצב המועדף השתנה — favorited_at אומר מתי סומן, ובהסרת הסימון הוא מתאפס ו-Last-Modified נסוג אחורה, כך שלקוח שהחזיק את הערך המאוחר היה מקבל 304 עם כוכב תקוע. Last-Modified ממשיך להישלח כמידע.

  • fix: מספר גרסה ייחודי לכל קובץ, גם כשגרסאות יושבות בסל המיחזור. מחיקה רכה אינה מוחקת — המסמכים נשארים ויכולים לחזור בשחזור — אבל חישוב הגרסה הבאה התעלם מהם, ולכן שמירה בזמן שהקובץ בסל קיבלה מספר שכבר תפוס. אחרי שחזור מהסל הבחירה לפי הגרסה הגבוהה ביותר נתנה לתוכן הישן לגבור, והתוכן שנשמר אחריו נקבר בלי סימן. המספור נשאל עכשיו על כל המסמכים; ירושת המטא-דאטה נשארה על הגרסה הפעילה, כדי שקובץ חדש בשם ממוחזר לא יירש תאריך של קובץ שנזרק.

  • change: codekeeper_save_file ב-MCP חוסם שמירה על שם קובץ שכבר קיים, ומפנה ל-codekeeper_edit_file או ל-codekeeper_append_file. שמירה כזו יצרה גרסה חדשה, והתוכן הקודם נעלם משני המקומות שבהם מחפשים אותו — החיפוש מקבץ לגרסה האחרונה לכל שם, ועמוד הקובץ מציג אותה בלבד. קובץ ותיק שחלק שם עם מה שנשמר הפך לבלתי נגיש בלי שהכותב ידע שדרס משהו. וכשל בבדיקת הקיום אינו נחשב ”אין קובץ“ אלא מוחזר בקוד נפרד (existence_check_unavailable) שעוצר את השמירה — דווקא שם דריסה שקטה אפשרית, ולכן תשובה מנוחשת גרועה מסירוב.

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

2026-08-25

  • docs: DEV_WEB_PUSH.md הוסר, ותוכנו מוזג ל-עובדי Push שהוא מעכשיו העמוד היחיד ל-Web Push. שני העמודים תיארו את אותה מערכת באותה רמה, והישן כבר היה מיושן בשלוש נקודות. הקישור הישן /DEV_WEB_PUSH.html אינו קיים עוד — סימניות ישנות יקבלו 404, והיעד הוא /deployment/workers.html.

  • docs: תוקן משפט שגוי שהיה ב-DEV_WEB_PUSH.md: ”מפתח ה-VAPID הפרטי אינו נדרש ע"י Flask“. הוא נדרש במסלול המקומי (pywebpush), ונכון רק כשהמשלוח מואצל ל-Worker.

  • docs: תועד מי באמת שולח את תזכורות הפתקים — thread דמון push-sender בתוך תהליך ה-WebApp, עם נעילת flock שמונעת שני שולחים. קודם זה הופיע כ“תהליך רקע בשרת“ בלבד.

  • docs: אוחדו כפילויות בין פתקים דביקים (Sticky Notes) ל-עקרונות להוספת פיצ’ר לסטיקי-נוטס — הנימוקים חיים בעמוד המפתחים, ועמוד המשתמש מקצר לתוצאה ומקשר.

2026-08-21

  • feat: לוחות פתקים — פתקים שאינם צמודים לקובץ. יצירה, שינוי שם, מחיקה עם העברת הפתקים ללוח ברירת המחדל, ושני מצבי מיקום (מוצמד ללוח / צמוד למסך). כניסה מכפתור קיצורי הדרך בסרגל העליון.

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

  • feat: קישור קבוע /note/<note_id> שמפנה לקובץ או ללוח לפי סוג הפתק. התראות תזכורת והפעמון עברו להשתמש בו במקום לבנות /md/<file_id>, מה שגרם לפתקי לוח ליפול לשורש האתר.

  • fix: תקרות הפתקים (200 ללוח, 1000 למשתמש) נאכפות בשכבת ה-API. הן היו מתועדות ונאכפו רק חלקית במסלול ה-MCP. אדמין פטור.

  • fix: פתקי לוח שורדים גיבוי ושחזור. השחזור דילג בשקט על כל פתק בלי file_name.

  • fix: _notes_scope_filter ב-MCP החזיר את כל הפתקים של המשתמש כשאין scope, במקום את הפתקים של הקובץ המבוקש.

  • fix: נוסף אינדקס (user_id, scope_id) שחסר ב-webapp, למרות שזה ענף מרכזי בשאילתת הפתקים.

  • refactor: is_admin/is_premium אוחדו ל-user_roles. הלוגיקה הייתה משוכפלת מילה במילה בשני קבצים.

2026-01-29

  • feat: תיוג פריטים ב“אוספים שלי“ עם תגיות אימוג’י, עורך תגיות, סינון/מיון ובחירה מרובה.

  • feat: נוספו endpoints ל־metadata ול־עדכון תגיות + אירועי observability.

  • docs: עודכן user/my_collections עם תיאור תיוג, סינון וייצוא/ייבוא.

2025-12-11

  • docs: עמוד חדש webapp/theming_and_css כולל טבלת טוקנים, שכבות, בדיקות, דוגמאות קוד ותרשימי SVG עבור Classic ו‑High Contrast.

  • docs: עודכן index.rst עם קטגוריה ”Frontend > Theming“ וקישורים מ-development.rst ו-README.

  • docs: נוספו קישורים הדדיים ל‑css_refactor_plan.md (FEATURE_SUGGESTIONS + WebApp) ול‑webapp_theme_palettes.md.

2025-11-11

  • docs: עמוד חדש ”web 🌐 ממשקי משתמשים“ עם זרימות בוט, שדות חובה, חיווי מצב וממשק אדמין.

  • docs: עדכון ”webapp/snippet-library“ לגרסה המשודרגת – איחוד Curated+DB, הגבלות דפדוף, Deferred Highlight, ושיפורי אדמין.

  • docs: מדריך קצר לסוכני AI להפעלה דרך הבוט וה‑WebApp בשני הפיצ’רים.

2025-11-06

  • docs: WebApp Onboarding – דף חדש עם זרימה, קישורים ו‑JS לדגל has_seen_welcome_modal.

  • docs: WebApp API Reference – נוספו POST /api/welcome/ack ו‑POST /api/shared/save כולל קלט/פלט ושגיאות.

  • docs: Observability – דף ”Tracing Hotspots“ עם תרשימי Mermaid, טבלת כיסוי ודוגמאות @traced.

  • docs: Log‑based Alerts – פרק ”טקסונומיית שגיאות וחתימות“, ”תצוגה ב‑ChatOps“ ו‑classify_error().

  • docs: Resilience – דף חדש למדיניות Retry + Circuit Breaker עם טבלת ENV ודוגמת שימוש.

  • docs: Architecture – הופרדה אחריות למסמכים (DocumentHandler) + HOWTO חדש handlers/document-flow.

  • docs: Runbooks – צ’קליסט Incident חדש.

קישורים ל‑Issues רלוונטיים: #1198, #1239.

2025-11-05

  • docs: הרחבת דף הבית – נוספו Bookmarks, Collections, Sticky Notes, Favorites, Reminders ל“סקירה כללית“ ו“תכונות עיקריות“, כולל הבהרה ש‑WebApp בלבד.

  • docs: הרחבת webapp/overview – הוספת פירוט (CodeMirror, Markdown מתקדם, Bulk Actions, Status) וקישורי :doc: לעמודים רלוונטיים; תיקון קישורים מוחלטים למניעת אזהרות RTD.

  • docs: עדכון examples – שימוש ב‑create_application ו‑app.run_polling() במקום API ישן.

  • docs: תיקון installation – קישור ריפו ל‑https://github.com/amirbiron/CodeBot.git.

  • docs: quickstart – קישור ל‑webapp/overview בסעיף ”מה הלאה?“.

2025-10-30

  • fix: תמיכה בגרירה לסידור פריטים באוספים במגע (נייד/טאבלט). גרירה מתבצעת מהידית ⋮⋮ והסדר נשמר אוטומטית. בדסקטופ אין שינוי.

2025-10-29

  • נוסף סשן aiohttp משותף דרך http_async.get_session + כיבוי אוטומטי ב‑atexit.

  • תיעוד עודכן: Configuration (Async HTTP), Architecture (תשתית HTTP), Troubleshooting (לולאות asyncio), ו‑API Reference (http_async).

2025-10-15

  • נוספו עמודים: Caching, Indexing, Cursor Pagination, Static Checklist.

  • הורחב WebApp API Reference עבור /files.

  • נוספה טבלת ENV מרוכזת.

  • הורחב Troubleshooting עם Gotchas.

  • נוסף מדריך כותבי תיעוד.

  • הוגדרה מדיניות עוגנים יציבים.