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 ו-\בשם (textהוא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 מוצגת.
הוצג כתמונה שבורה בכל עמוד שמציג 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_VERSION2.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, ושילוב של הכללה והחרגה נדחה ב-OperationFailure31254, כמו במונגו (נמדד מולmongod7.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 💫, מוצגת משמאל לימין, כך שהאימוג’י נשאר בסופה. מה צריך להגדיר (ה-secretsANTHROPIC_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-container4.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מקבל, ב-HEADfa4e8abשל 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הפעיל את ה-jobstorepersistentשל 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): פתקים שומרים בדיוק את מה שהוקלד — ``&``, ``<div>`` ו-``"`` כבר לא הופכים ל-``& <div> ”``. טקסט כזה שהוקלד בפתק — בטקסט רגיל, בקוד בשורה ובבלוק קוד — הוצג תקין עד ריענון, ואחריו, גם במצב עריכה, הוצג
& <div> ". הסיבה: מאז #1227 השרת הריץhtml.unescapeעל כל גוף של פתק בשמירה (_sanitize_textבוובאפ, ו-_sanitize_note_textב-MCP מאז #3189) וגם בקריאה (_coerce_content_from_doc,_as_note). לכן הטקסט המקורי לא הגיע למסד כבר בשמירה הראשונה,©=בתוך כתובת הפך ל-©=, ו-note_str_replaceכתב בחזרה את כל הפתק מפוענח. עכשיו הגוף נשמר בדיוק כמו שנשלח ונקרא כמו שהוא שמור, בוובאפ וב-MCP — אותו כלל של קבצים — וה-escape נעשה רק בתצוגה, ב-textContent. הוסרו גם שאר השינויים שהניקוי עשה: המרה של CRLF ל-LF, מחיקה של תווי בקרה, ו-.strip()ב-MCP. גוף שכולו רווחים עדיין נדחה ב-empty_content, אבל הבדיקה רצה על עותק, ומה שנשמר הוא המקור. חלונית התזכורות בנתה את השורה ב-innerHTMLעם בריחה של<ו->בלבד, ולכן פענחה ישויות בעצמה; היא נבנית עכשיו בצמתים. בוובאפcontentשאינו מחרוזת נדחה ב-400invalid_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מפענח — נבדקו&,<,>,"ו-', ואחד-אחד כל פתק שיש בו&ואחריו אות, ספרה או#— וגם אף גרסה ב-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, רשימה או מילון — מחליף אותה (נמדד עלmcp1.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-code2.1.284 ו-Anthropic/ClaudeAI1.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שלmcp1.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היה 400invalid_refוהוא 404ref_not_mirrored; ב-/repo/api/file-at-commitענף שלא במראה היה 400invalid_commitוהוא 404, ref פגום הוא 400invalid_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, שדורש את הגוף הנוכחי המדויק, חייבה משיכה של הלוח כולו. הכלי החדש מחזיר את הגוף הנוכחי בדיוק כפי שהוא מאוחסן — פתק ישן עם"חוזר עם הישות, כמו ב-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: טסט שמקבע שגם במסלול ה-Markdownsuggestionsהוא רשימת מחרוזות ולא ה-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.
נוסף מדריך כותבי תיעוד.
הוגדרה מדיניות עוגנים יציבים.