📝 פרק 6

קובץ CLAUDE.md, תיקיית .claude והרחבות

כל סשן של קלוד קוד (Claude Code) מתחיל עם חלון הקשר ריק. שני מנגנונים מעבירים ידע בין סשנים: קבצי CLAUDE.md (או קבצי AGENTS.md שהכלי תומך בקריאתם ישירות) שאתם כותבים כדי לספק לקלוד הנחיות קבועות, וזיכרון אוטומטי (Auto memory) שבו קלוד רושם לעצמו תובנות ודפוסים מתוך תיקונים והעדפות שלכם.

שני המנגנונים נטענים בתחילת כל שיחה. קלוד מתייחס אליהם כהקשר (context), ולא כהגדרה אטומה הנאכפת טכנית. כדי לחסום פעולה תמיד, ללא תלות בהחלטות של קלוד, השתמשו ב-hook מסוג PreToolUse. ככל שההנחיות שלכם ממוקדות וקצרות יותר, כך קלוד יפעל לפיהן בעקביות רבה יותר.

השתמשו בקבצי CLAUDE.md כאשר אתם רוצים להנחות את ההתנהגות של קלוד. זיכרון אוטומטי מאפשר לקלוד ללמוד מהתיקונים שלכם בלי מאמץ ידני. בסשן מקומי הוא פעיל כברירת מחדל. מחוץ לסשנים של Claude Tag, סשן בסביבה באירוח עצמי (self-hosted) מתחיל איתו כבוי. סוכני משנה (subagents) יכולים גם הם לנהל זיכרון מתמיד משלהם.

בנוסף להנחיות ולזיכרון, פרויקט מחזיק הגדרות, הרשאות והרחבות במקומות קבועים. רוב המשתמשים עורכים רק את CLAUDE.md ואת settings.json. אם המאגר שלכם כבר כולל קובץ AGENTS.md עבור סוכני קוד אחרים, קלוד קוד יודע לקרוא אותו ישירות בפני עצמו או לצד CLAUDE.md. שאר התיקייה אופציונלית, ומוסיפים בה skills, חוקים, סוכני משנה או סגנונות פלט לפי הצורך. ב-Windows הנתיב ~/.claude נפתר ל-%USERPROFILE%\.claude. אם מגדירים את משתנה הסביבה CLAUDE_CONFIG_DIR, כל נתיבי ~/.claude יושבים תחת התיקייה הזו במקום. אותו דבר חל על .claude.json, שבלי המשתנה יושב ב-~/.claude.json.

יש כאן שלושה סוגים שונים של רכיבים:

• הנחיות לקלוד: CLAUDE.md, CLAUDE.local.md, AGENTS.md, קבצים ב-.claude/rules/, סגנונות פלט ב-output-styles/, וזיכרון אוטומטי. קלוד קורא אותם כהקשר.
• הגדרות של קלוד קוד: בעיקר .claude/settings.json, .claude/settings.local.json, והגדרות מנוהלות (managed-settings.json). הרשאות, hooks, משתני סביבה ומודל חלים ישירות דרך הלקוח, גם אם קלוד מתעלם מהטקסט.
• הרחבות: skills/, commands/, agents/, workflows/, ושרתי MCP דרך .mcp.json.

[!NOTE] CLAUDE.md, חוקים וזיכרון אוטומטי הם טקסט לקלוד. אם משהו חייב להיחסם או להיאכף תמיד, למשל חסימת rm -rf או הרצת formatter אחרי עריכה, הגדירו אותו ב-permissions או ב-hooks (למשל PreToolUse או PostToolUse).

סדר העדיפויות בין ההגדרות:

• הגדרות מנוהלות (managed-settings.json) של הארגון גוברות על כל קובץ הגדרות ועל ערכי --settings, למעט חריגים צרים בסדר העדיפויות של ההגדרות. בתוך השכבה המנוהלת עצמה יש סדר בין המקורות. פירוט הסדר בעמוד ההגדרות המנוהלות בתיעוד הרשמי.
• דגלי CLI (כמו --permission-mode או --settings) דורסים את settings.json עבור אותו סשן.
• משתני סביבה מסוימים גוברים על ההגדרה המקבילה להם. זה משתנה ממשתנה למשתנה.
• הגדרות מערך (כמו permissions.allow) מתמזגות בין כל הרמות, ואילו הגדרות סקלריות (כמו model) לוקחות את הערך הספציפי ביותר. זה שונה מקבצי CLAUDE.md: שם הקובץ הגלובלי וקובץ הפרויקט נטענים שניהם להקשר, משורשרים ולא מתמזגים מפתח מול מפתח. אם ההנחיות סותרות, קלוד עלול לפעול לפי כל אחת מהן.

אם הגדרה, hook או קובץ אינם נכנסים לתוקף, עמוד Debug your configuration בתיעוד הרשמי מרכז פקודות בדיקה וטבלת איתור לפי תסמין.

כדי לוודא אילו קבצים נטענו בפועל בסשן הנוכחי, הריצו /context all ובדקו את הרשימה תחת Memory files. במצב מסך מלא, /context לבד מקפל את הרשימה הזו.

#בחירת הקובץ הנכון לכל מטרה

התאמות שונות נשמרות בקבצים ייעודיים. הטבלה מרכזת היכן לבצע כל שינוי:

#שדות frontmatter לפי סוג קובץ

skills, קבצי פקודה, סוכני משנה, סגנונות פלט וחוקים קוראים את ההגדרות שלהם מ-YAML frontmatter בראש הקובץ. לכל סוג קובץ סט שדות משלו. השמות בטבלה הם השדות שהכלי קורא. סוכנים שנשלחים בתוך תוסף מכבדים רק חלק משדות סוכן המשנה.

#קובץ CLAUDE.md

קבצי CLAUDE.md הם קבצי Markdown שמספקים לקלוד הנחיות קבועות עבור פרויקט, תהליך עבודה אישי או הארגון כולו. אתם כותבים את הקבצים כטקסט רגיל, וקלוד קורא אותם בתחילת כל סשן. אם המאגר משתמש ב-AGENTS.md במקום זאת, ראו את הסעיף קובץ AGENTS.md.

#מתי להוסיף ל-CLAUDE.md

התייחסו לקובץ CLAUDE.md כמקום שבו כותבים את מה שהייתם צריכים להסביר שוב:

• קלוד עשה את אותה טעות בפעם השנייה.
• תהליך בדיקת קוד (code review) תפס משהו שקלוד היה אמור לדעת על בסיס הקוד הזה.
• הקלדתם בצ'אט את אותו תיקון או אותה הבהרה שהקלדתם בסשן הקודם.
• חבר צוות חדש היה זקוק לאותו הקשר כדי לעבוד ביעילות.

התמקדו בעובדות שקלוד צריך להחזיק בכל סשן: פקודות build, מוסכמות, מבנה הפרויקט, וכללי פעולה קבועים. אם הוראה מסוימת היא הליך מרובה שלבים או נוגעת לחלק בודד בקוד, העבירו אותה ל-skill או לחוק מוגבל נתיב תחת .claude/rules/. סקירת ההרחבות בתיעוד הרשמי מתארת מתי להשתמש בכל מנגנון.

ניתן להריץ /memory מתוך הסשן כדי לפתוח ולערוך את CLAUDE.md ישירות.

#בחירת מיקום לקבצי CLAUDE.md

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

קבצי CLAUDE.md ו-CLAUDE.local.md בהיררכיית התיקיות שמעל תיקיית העבודה נטענים בשיגור. קבצים בתתי תיקיות שמתחת לתיקיית העבודה נטענים לפי דרישה כאשר קלוד קורא קבצים באותן תיקיות. סדר הרזולוציה המלא מופיע בסעיף איך קבצי CLAUDE.md נטענים.

בפרויקטים גדולים אפשר לפצל הנחיות לקבצים לפי נושא באמצעות חוקים ב-.claude/rules/. חוקים מאפשרים להגביל הנחיות לסוגי קבצים או לתתי תיקיות.

#הגדרת קובץ CLAUDE.md לפרויקט

קובץ CLAUDE.md ברמת הפרויקט יכול להישמר ב-./CLAUDE.md או ב-./.claude/CLAUDE.md אם מעדיפים לשמור על שורש פרויקט נקי. צרו את הקובץ והוסיפו הנחיות שחלות על כל מי שעובד על הפרויקט: פקודות build ובדיקות, תקני קוד, החלטות ארכיטקטורה, מוסכמות שמות ותהליכי עבודה נפוצים. הנחיות אלו משותפות לצוות דרך בקרת גרסאות, ולכן יש להתמקד בתקנים ברמת הפרויקט. כדי לוודא שהקובץ נטען, הריצו /context all בסשן ובדקו את הרשימה תחת Memory files. במצב מסך מלא, /context לבד מקפל את הרשימה הזו.

[!TIP] הריצו /init כדי לייצר קובץ CLAUDE.md התחלתי באופן אוטומטי. קלוד מנתח את בסיס הקוד ויוצר קובץ הכולל פקודות build, הנחיות בדיקה ומוסכמות פרויקט שגילה. אם הקובץ כבר קיים, /init מציע שיפורים במקום לדרוס אותו. אחר כך אפשר להוסיף הנחיות שקלוד לא היה מגלה בעצמו.

לתהליך אינטראקטיבי רב שלבי, הגדירו את משתנה הסביבה CLAUDE_CODE_NEW_INIT לערך 1 לפני הרצת /init. אפשר להגדיר אותו ב-shell או בבלוק env של קובץ הגדרות. עם המשתנה הזה, /init שואל אילו תוצרים להגדיר: קבצי CLAUDE.md, skills ו-hooks. לאחר מכן הוא חוקר את בסיס הקוד באמצעות סוכן משנה, משלים פערים בעזרת שאלות המשך, ומציג הצעה לבדיקה לפני כתיבת הקבצים. המשתנה משנה רק את אופן הריצה של /init, ולכן אפשר להשאיר אותו מוגדר.

#כתיבת הנחיות יעילות

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

• גודל הקובץ: כוונו לפחות מ-200 שורות לכל קובץ CLAUDE.md. קבצים ארוכים צורכים יותר הקשר ומפחיתים את רמת הציות. קובץ CLAUDE.md שנטען בשיגור וגודלו מעל 4 MiB נדלג במלואו, וקלוד קוד אינו טוען ממנו דבר. הוראות שחשובות רק לחלק מבסיס הקוד העבירו לחוקים מוגבלי נתיב ב-.claude/rules/, שנטענים רק כשקלוד עובד עם קבצים תואמים. ייבוא עם @ עוזר לארגן קובץ ארוך, אבל אינו מקטין את עלות ההקשר, כי הקבצים המיובאים נטענים יחד עם קובץ ה-CLAUDE.md שמייבא אותם.
• מבנה: השתמשו בכותרות Markdown וברשימות תבליטים כדי לקבץ הנחיות קשורות. קלוד סורק מבנה בדיוק כמו קורא אנושי: סעיפים מאורגנים קלים יותר למעקב מאשר פסקאות דחוסות.
• ספציפיות: נסחו הנחיות קונקרטיות שניתן לאמת. לדוגמה:
  • Use 2-space indentation במקום Format code properly
  • Run npm test before committing במקום Test your changes
  • API handlers live in src/api/handlers/ במקום Keep files organized
• עקביות: אם שני כללים סותרים זה את זה, קלוד עלול לבחור אחד מהם באופן שרירותי. בדקו מעת לעת את קבצי CLAUDE.md, קבצים מקוננים בתתי תיקיות ואת תיקיית .claude/rules/ כדי להסיר הנחיות ישנות או סותרות. כדי שקלוד יאתר אותן, הריצו ביקורת פרומפט כמו בסעיף הבא.

#בדיקת קבצי ההנחיות

כדי לבקש מקלוד לבדוק קבצים אלו לאיתור הוראות ישנות או סותרות, הריצו בסשן את הפקודה /doctor prompt-audit. כברירת מחדל קלוד קורא את קבצי CLAUDE.md, CLAUDE.local.md, AGENTS.md, וכן חוקים, skills, פקודות, סוכני משנה וסגנונות פלט תחת .claude/ ו-~/.claude/. הוא מחפש בעיות כמו הוראות שנכתבו למודלים ישנים, הפניות לקבצים או לפקודות שאינם קיימים, וסתירות בין קבצים. תקבלו דוח ממצאים והצעת עריכות, ושום קובץ אינו משתנה עד שתאשרו לקלוד להחיל אותן. כדי לבדוק קובץ או תיקייה בודדים, העבירו את הנתיב, למשל /doctor prompt-audit .claude/skills/deploy. הבדיקה רצה דרך ה-skill המובנה /claude-api, ולכן אינה זמינה כשה-skill כבוי ב-skillOverrides או עם disableBundledSkills. הפקודה /doctor prompt-audit דורשת קלוד קוד בגרסה v2.1.283 ומעלה.

דוגמה למבנה יעיל:

# Project conventions

## Commands
- Build: `npm run build`
- Test: `npm test`
- Lint: `npm run lint`

## Stack
- TypeScript with strict mode
- React 19, functional components only

## Rules
- Named exports, never default exports
- Tests live next to source: `foo.ts` -> `foo.test.ts`
- All API routes return `{ data, error }` shape

#ייבוא קבצים נוספים עם @

קבצי CLAUDE.md יכולים לייבא קבצים נוספים באמצעות התחביר @path/to/import. הקבצים המיובאים נפרסים ונטענים להקשר לצד הקובץ שמפנה אליהם.

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

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

- API conventions @Design\ Docs/api-conventions.md

מנתח הייבוא מדלג על קטעי קוד בתוך backticks ועל בלוקי קוד. כדי להזכיר נתיב בלי לייבא אותו, עטפו אותו ב-backticks: כתיבת `@README` משאירה את הטקסט כפשוטו, בעוד ש-@README ללא backticks ייבא את הקובץ.

דוגמה לייבוא קבצים:

See @README for project overview and @package.json for available npm commands for this project.

# Additional Instructions
- git workflow @docs/git-instructions.md

עבור העדפות אישיות לפרויקט שאינן מיועדות לשמירה בבקרת גרסאות, צרו קובץ CLAUDE.local.md בשורש הפרויקט. הוא נטען לצד CLAUDE.md ומטופל באותו אופן. הוסיפו את CLAUDE.local.md לקובץ .gitignore. כאשר משתנה הסביבה CLAUDE_CODE_NEW_INIT=1 מוגדר, בחירה באפשרות האישית בעת הרצת /init מבצעת זאת אוטומטית.

אם אתם עובדים על פני מספר worktrees של אותו מאגר ב-Git, קובץ CLAUDE.local.md שמוחרג ב-git קיים רק ב-worktree שבו נוצר. כדי לשתף הנחיות אישיות בין worktrees, ייבאו קובץ מתיקיית הבית שלכם:

# Individual Preferences
- @~/.claude/my-project-instructions.md

[!WARNING] ייבוא בקובץ זיכרון ברמת הפרויקט נחשב לייבוא חיצוני (external import) כאשר הנתיב שלו נפתר מחוץ לתיקיית העבודה שלכם, כמו ייבוא מתיקיית הבית בדוגמה למעלה. בפעם הראשונה שקלוד קוד נתקל בייבוא חיצוני בפרויקט, הוא מציג חלון אישור עם רשימת הקבצים. אם תסרבו, הייבוא יישאר מושבת והחלון לא יוצג שוב.

קלוד קוד מציג את החלון כדי להגן עליכם מפני קבצים שאנשים אחרים דוחפים למאגר משותף. קבצי זיכרון ברמת המשתמש, כמו ~/.claude/CLAUDE.md ו-~/.claude/rules/, הם קבצים שכתבתם בעצמכם. למעט בסשנים של Cowork בשולחן העבודה, קלוד קוד טוען ייבוא שלהם ללא חלון אישור ונותן בהם אמון כמו בשאר ההגדרות האישיות.

בסשנים של Cowork בשולחן העבודה, קלוד קוד מדלג על כל ייבוא בקובץ משתמש שנפתר מחוץ לתיקיית העבודה של הסשן וטוען את שאר הקובץ. בסשנים אלה הוא גם מדלג על קובץ ~/.claude/CLAUDE.md שהוא בעצמו קישור סימבולי או hard link, ועל תיקיית ~/.claude/rules/ או קובץ חוק שהם קישור סימבולי שמצביע מחוץ לתיקיית העבודה.

#איך קבצי CLAUDE.md נטענים

קלוד קוד טוען את קבצי CLAUDE.md ו-CLAUDE.local.md מתיקיית העבודה הנוכחית ומכל תיקייה שמעליה בהיררכיה. אם תריצו את קלוד קוד בנתיב foo/bar/, הוא יטען הנחיות מ-foo/bar/CLAUDE.md, מ-foo/CLAUDE.md ומכל קובץ CLAUDE.local.md שיושב לצידם.

כל הקבצים שהתגלו משורשרים יחד לתוך ההקשר ולא דורסים זה את זה. הסדר נקבע משורש מערכת הקבצים ומטה עד לתיקיית העבודה הנוכחית. בדוגמה של foo/bar/, הקובץ foo/CLAUDE.md יופיע בהקשר לפני foo/bar/CLAUDE.md, כך שההנחיות הקרובות ביותר למקום השיגור של קלוד נקראות אחרונות. בתוך כל תיקייה, הקובץ CLAUDE.local.md משורשר לאחר CLAUDE.md, כך שההערות האישיות שלכם נקראות אחרונות באותה רמה. ~/.claude/CLAUDE.md נטען לצד קובץ הפרויקט. אם הנחיה בקובץ המשתמש סותרת הנחיה בקובץ הפרויקט, קלוד עלול לפעול לפי כל אחת מהן.

קלוד מגלה גם קבצי CLAUDE.md ו-CLAUDE.local.md בתתי תיקיות שמתחת לתיקיית העבודה. במקום לטעון אותם בשיגור, קלוד קוד טוען כל אחד מהם פעם אחת כשקלוד קורא, כותב או עורך קובץ אחר באותה תת תיקייה. קריאה כוללת צפייה בקובץ באמצעות פקודת Bash שנחשבת לקריאה, כמו cat או head על קובץ בודד. לקבצים בתוך worktree תחת .claude/worktrees/ יש כללי טעינה נפרדים. לפי התיעוד הרשמי (נכון ל-2026-11-03) הם מתוארים בעמוד בידוד סוכני משנה עם worktrees, והעמוד הזה אינו מפרט אותם.

אם אתם עובדים ב-monorepo גדול שבו נאספים קבצים של צוותים אחרים, השתמשו בהגדרה claudeMdExcludes כדי לדלג עליהם. פריסה מלאה של קבצי CLAUDE.md וחוקים בשורש וברמת תיקייה מתוארת בעמוד monorepos בתיעוד הרשמי.

הערות HTML ברמת בלוק (<!-- maintainer notes -->) בקבצי CLAUDE.md מוסרות לפני שהתוכן מוזרק להקשר של קלוד. השתמשו בהן כדי להשאיר הערות למתחזקים אנושיים בלי לבזבז טוקנים של הקשר. הערות בתוך בלוקי קוד נשמרות. כאשר אתם פותחים קובץ CLAUDE.md ישירות עם הכלי Read, ההערות נשארות גלויות.

#טעינה מתיקיות נוספות

הדגל --add-dir מעניק לקלוד גישה לתיקיות נוספות מחוץ לתיקיית העבודה הראשית. כברירת מחדל, קבצי CLAUDE.md מתיקיות אלו אינם נטענים.

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

CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD=1 claude --add-dir ../shared-config

הצורה הזו מגדירה את המשתנה עבור אותה הרצה בודדת ב-Bash או Zsh. כדי להשאיר אותו פעיל בכל סשן, הוסיפו אותו לבלוק env בתוך ~/.claude/settings.json.

הגדרה זו טוענת את CLAUDE.md, .claude/CLAUDE.md, .claude/rules/*.md ו-CLAUDE.local.md מהתיקייה הנוספת. קובץ CLAUDE.local.md אינו נטען אם החלפתם את מקורות ההגדרות והחרגתם את local מתוך --setting-sources.

#ארגון חוקים ב-.claude/rules/

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

[!NOTE] חוקים נטענים להקשר בכל סשן או כאשר נפתחים קבצים תואמים. עבור הנחיות ספציפיות למשימה שאינן צריכות להימצא בהקשר כל הזמן, השתמשו ב-skills, הנטענים רק כשמפעילים אותם או כשקלוד מזהה שהם רלוונטיים לבקשה.

#הגדרת חוקים

מקמו קבצי Markdown בתיקיית .claude/rules/ של הפרויקט. מומלץ שכל קובץ יעסוק בנושא יחיד ויישא שם תיאורי, כגון testing.md או api-design.md. כל קבצי .md מתגלים באופן רקורסיבי, כך שניתן לארגן אותם בתתי תיקיות כמו frontend/ או backend/:

your-project/
├── .claude/
│   ├── CLAUDE.md           # הנחיות ראשיות לפרויקט
│   └── rules/
│       ├── code-style.md   # הנחיות סגנון קוד
│       ├── testing.md      # מוסכמות בדיקות
│       └── security.md     # דרישות אבטחה

חוקים ללא שדה paths ב-frontmatter נטענים בשיגור באותו סדר עדיפות כמו .claude/CLAUDE.md.

חוקי פרויקט אינם נטענים אם מחריגים את project מתוך --setting-sources. לפני גרסה v2.1.211, חוקים שנטענים לפי דרישה, כולל חוקים מוגבלי נתיב וחוקים בתתי תיקיות .claude/rules/ מקוננות, נטענו גם כש-project הוחרג. החל מגרסה v2.1.211 ההחרגה חלה גם עליהם.

#חוקים מוגבלי נתיב (Path-specific rules)

ניתן להגביל חוקים לקבצים מסוימים באמצעות YAML frontmatter עם השדה paths. חוקים מותנים אלה חלים רק כאשר קלוד עובד עם קבצים התואמים לתבניות שהוגדרו:

---
paths:
  - "src/api/**/*.ts"
---

# API Development Rules

- All API endpoints must include input validation
- Use the standard error response format
- Include OpenAPI documentation comments

חוקים ללא שדה paths נטענים ללא תנאי וחלים על כל הקבצים. חוק מוגבל נתיב נטען כשקלוד משתמש בכלי Read, Write או Edit על קובץ שתואם לתבנית, ולא בכל שימוש בכלי. הוא נטען גם כשקלוד צופה בקובץ תואם באמצעות פקודת Bash שנחשבת לקריאה, כמו cat או head על קובץ בודד. ההתאמה עובדת גם כאשר קלוד מגיע לקובץ דרך נתיב של קישור סימבולי לתיקיית הפרויקט, למשל ב-checkout שמקושר בקישור סימבולי.

כל תבנית יחסית לתיקיית הבסיס של החוק:

• חוקי פרויקט: התיקייה שמכילה את תיקיית .claude של החוק.
• חוקים ברמת המשתמש: תיקיית העבודה הראשית של הסשן.

כדי שחוקים מוגבלי נתיב ייטענו עבור קבצים ב-worktree אח של אותו מאגר, הפעילו את קלוד קוד באותו worktree, או העבירו את הסשן לשם עם /cd.

השתמשו בתבניות glob בשדה paths כדי להתאים קבצים לפי סיומת, תיקייה או שילוב ביניהן. ההתאמה היא ביחס לתיקיית הבסיס של החוק:

ניתן להגדיר מספר תבניות ולהשתמש בהרחבת סוגריים מסולסלים (brace expansion) כדי להתאים מספר סיומות בתבנית אחת:

---
paths:
  - "src/**/*.{ts,tsx}"
  - "lib/**/*.ts"
  - "tests/**/*.test.ts"
---

כל קבוצת סוגריים מסולסלים מכפילה את מספר התבניות המורחבות: src/*.{ts,tsx} מתרחב לשתי תבניות, ו-{a,b}/{c,d}/*.{ts,tsx} לשמונה תבניות. כדי לשמור על מגבלה סבירה, כל רשימת ה-paths של חוק חולקת תקציב כולל של 1,000 תבניות מורחבות וגודל של 4 MiB, כאשר תבניות ללא סוגריים מסולסלים אינן נספרות כנגד תקציב זה. אם תבנית חורגת מהתקציב, קלוד קוד משתמש בה ללא הרחבה, והסוגריים המסולסלים המילוליים לא יתאימו לקבצים.

תחביר glob מתייחס ל-[ כפתיחה של ביטוי סוגריים מרובעים כגון [abc]. תבנית עם [ שאינה ניתנת לקריאה כביטוי כזה (כגון photos [2024/**) אינה חוקית: היא אינה מתאימה לשום קובץ, ושאר התבניות של החוק ממשיכות לפעול כרגיל. כדי להתאים תו [ מילולי בשם קובץ, בצעו escape באמצעות photos \[2024/**.

#מבנה ה-frontmatter של חוק

הגדרת חוק נעשית עם YAML frontmatter בין סימוני --- בראש הקובץ. השדה paths הוא השדה היחיד שקלוד קוד קורא מחוק, וכל שדה אחר מקבל התעלמות ללא שגיאה. קלוד קוד מסיר את ה-frontmatter לפני טעינת החוק להקשר.

אם ה-YAML בין הסימונים אינו תקין תחבירית, קלוד קוד מתעלם מה-frontmatter וטוען את החוק כאילו אין לו paths. הריצו claude --debug כדי לצפות בשגיאת הפיענוח.

#שיתוף חוקים בין פרויקטים באמצעות קישורים סימבוליים

התיקייה .claude/rules/ תומכת בקישורים סימבוליים (symlinks), כך שניתן לנהל סט חוקים משותף ולקשר אותו למספר פרויקטים. קישורים מעגליים מזוהים ומטופלים ללא קריסה.

קלוד קוד מתייחס לקישור סימבולי שהיעד שלו מחוץ לתיקיית העבודה כמו לייבוא חיצוני. חוקים מקושרים אלה לא ייטענו עד שתאשרו ייבוא חיצוני עבור הפרויקט, וגם לאחר אישור רק חוקים ללא שדה paths ייטענו. הבקשה מוצגת פעם אחת לכל פרויקט, בחלון בתחילת סשן אינטראקטיבי. החלון מפרט את קבצי החוקים המקושרים לצד כל ייבוא חיצוני עם @path. כדי לטעון חוקים משותפים ללא צורך באישור זה, שמרו אותם ב-~/.claude/rules/, שם הם חלים על כל פרויקט במחשב.

דוגמה ליצירת קישור לתיקייה משותפת ולקובץ בודד:

ln -s ~/shared-claude-rules .claude/rules/shared
ln -s ~/company-standards/security.md .claude/rules/security.md

אם תפנו קישור סימבולי ב-.claude/rules/ או של CLAUDE.md אל נתיב רשת, כגון שיתוף UNC בכתובת \\server\share או נתיב תחת /net או /Network, ההנחיות המקושרות לא ייטענו. קלוד קוד אינו עוקב אחר הקישור כדי למנוע פנייה לשרת המארח. נתיבי \\wsl$ אינם נחשבים לנתיבי רשת.

#חוקים ברמת המשתמש

חוקים אישיים ב-~/.claude/rules/ חלים על כל פרויקט במחשב שלכם, להעדפות שאינן ספציפיות לפרויקט:

~/.claude/rules/
├── preferences.md    # העדפות קידוד אישיות
└── workflows.md      # תהליכי עבודה מועדפים

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

#ניהול קבצי CLAUDE.md בצוותים גדולים

בארגונים ניתן לרכז הנחיות ולשלוט בקבצים הנטענים.

#פריסת CLAUDE.md כלל ארגוני

ארגונים יכולים לפרוס קובץ CLAUDE.md מנוהל מרכזית החל על כל המשתמשים במכונה. מפתחים יכולים להחריג קבצי CLAUDE.md אחרים עם claudeMdExcludes, אבל לא את הקובץ הזה. אם סשן מתחיל כשטעינת CLAUDE.md כבויה לגמרי, הסשן הזה גם לא טוען את התוכן המנוהל. השתמשו בקובץ להכוונה, ואכפו כללים בהגדרות מנוהלות כמו permissions.deny.

1. צרו את הקובץ במיקום המדיניות המנוהלת:
   • macOS: /Library/Application Support/ClaudeCode/CLAUDE.md
   • Linux ו-WSL: /etc/claude-code/CLAUDE.md
   • Windows: C:\Program Files\ClaudeCode\CLAUDE.md
2. פרסו אותו באמצעות מערכת ניהול התצורה הארגונית: השתמשו ב-MDM, ב-Group Policy, ב-Ansible או בכלים דומים.

מפתח ההגדרה claudeMd מאפשר להכניס תוכן הנחיות מנוהל ישירות לתוך קובץ managed-settings.json במקום לפרוס קובץ נפרד.

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

דוגמה להגדרת הנחיות ישירות בתוך קובץ הגדרות מנוהל:

{
  "claudeMd": "Always run `make lint` before committing.\nNever push directly to main."
}

קובץ CLAUDE.md מנוהל והגדרות מנוהלות משרתים מטרות שונות. הגדרות מיועדות לאכיפה טכנית והנחיות להכוונת התנהגות:

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

#החרגת קבצי CLAUDE.md מסוימים

ב-monorepo גדול קבצי אבות עשויים לכלול הוראות שאינן רלוונטיות לעבודתכם. ההגדרה claudeMdExcludes מאפשרת לדלג על קבצים לפי נתיב או תבנית glob. קובץ CLAUDE.md מנוהל אינו ניתן להחרגה.

דוגמה להחרגת קובץ עליון ותיקיית חוקים מתיקיית הורה, מתוך .claude/settings.local.json, כדי שההחרגה תישאר מקומית למחשב:

{
  "claudeMdExcludes": [
    "**/monorepo/CLAUDE.md",
    "/home/user/monorepo/other-team/.claude/rules/**"
  ]
}

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

כדי להחריג קובץ חוקים שהגעתם אליו דרך קישור סימבולי, בין שהקובץ עצמו הוא הקישור ובין שהתיקייה היא הקישור, כתבו תבנית שמתאימה לאחד משני הנתיבים: הנתיב תחת .claude/rules/ או נתיב היעד של הקישור. תבנית שתואמת לאחד מהם תחריג את הקובץ. לפני גרסה v2.1.239, רק תבנית שהתאימה ליעד הקישור החריגה את הקובץ.

#קובץ AGENTS.md

קלוד קוד מסוגל לקרוא קבצי AGENTS.md כהוראות הפרויקט, כך שמאגר שהוגדר עבור סוכני קוד אחרים פועל ללא צורך בהוספת CLAUDE.md, ייבוא או הגדרה ידנית.

ברירת המחדל לפי הרכב הקבצים במאגר:

כדי לשנות את ברירת המחדל, למשל כדי שקלוד תמיד יקרא את שני הקבצים, רק את CLAUDE.md, או רק הנחיות מנוהלות של הארגון, שנו את ההגדרה Project instructions כמו בסעיף בחירת קבצי ההנחיות שייטענו.

[!NOTE] קריאת AGENTS.md ישירות נתמכת החל מגרסה v2.1.277. בחלק מהסשנים קלוד אינו יכול לקרוא את AGENTS.md, ואז מייבאים אותו מתוך CLAUDE.md.

#מתי קלוד קוד קורא את AGENTS.md

כברירת מחדל, קלוד קורא את AGENTS.md רק כאשר אין קובץ CLAUDE.md בתיקיית העבודה או מעליה:

• קבצים שמונעים קריאת AGENTS.md: CLAUDE.md, .claude/CLAUDE.md, או CLAUDE.local.md בתיקיית העבודה או בכל תיקייה מעליה.
• קבצים שאינם מונעים קריאה וממשיכים להיטען לצידו: ~/.claude/CLAUDE.md, קובץ CLAUDE.md מנוהל של הארגון, וקבצים מתוך .claude/rules/.

כאשר אין קבצים שמונעים קריאה:

• בשיגור הסשן: נטענים כל קבצי AGENTS.md ו-.claude/AGENTS.md בתיקיית העבודה ומעליה. בסשן אינטראקטיבי מוצגת הודעה כגון no CLAUDE.md found; AGENTS.md loaded: /home/you/repo/AGENTS.md.
• בעבודה בתתי תיקיות: קובץ AGENTS.md בתת תיקייה נטען כאשר קלוד פותח שם קובץ באמצעות הכלי Read, בתנאי שבאותה תת תיקייה אין אחד משלושת קבצי CLAUDE.md משלה.
• בתוך הקובץ: ייבוא עם @path נפרס, תבניות claudeMdExcludes חלות, וסוכני משנה שמדלגים על הוראות פרויקט מדלגים גם על קבצים אלה.
• קבצים שאינם נקראים: AGENTS.local.md, AGENTS.override.md, או כל תוכן תחת תיקיית .agents/.

[!NOTE] מאחר שקובץ CLAUDE.local.md מונע קריאה ישירה של AGENTS.md, הוספת קובץ מקומי להעדפות אישיות בפרויקט שמסתמך על AGENTS.md תגרום לקלוד להפסיק לקרוא את AGENTS.md. כדי לשמור על הקובץ המקומי ועדיין לקרוא את AGENTS.md, הגדירו את אפשרות הוראות הפרויקט לערך claude-md-and-agents-md.

#בחירת קבצי ההנחיות שייטענו

כדי לשנות את הקבצים שקלוד קורא, הקישו /config בסשן והגדירו את Project instructions לאחד מהערכים:

ניתן להגדיר זאת בקובץ הגדרות תחת מזהה התוסף המובנה cc-plugin-agents-md@builtin בבלוק pluginConfigs, בתוך ~/.claude/settings.json, בקובץ --settings או בהגדרות מנוהלות (ההגדרה מקבלת התעלמות בקבצי הגדרות של הפרויקט או בהגדרות מקומיות):

{
  "pluginConfigs": {
    "cc-plugin-agents-md@builtin": {
      "options": { "instructionFiles": "claude-md-and-agents-md" }
    }
  }
}

לפני גרסה v2.1.285 המזהה היה agents-md@builtin, וקלוד קוד התעלם מרשומה תחת cc-plugin-agents-md@builtin. אם גם גרסאות ישנות יותר קוראות את אותו קובץ הגדרות, השאירו שם את agents-md@builtin. מגרסה v2.1.285 קלוד קוד קורא רשומה תחת כל אחד משני המזהים.

השינוי חל החל מההודעה הבאה שתשלחו ובכל סשן חדש.

#מתי תמיכה ב-AGENTS.md אינה זמינה

במקרים הבאים קלוד קורא קבצי CLAUDE.md בלבד, והאפשרות אינה מופיעה בלוח ההגדרות ב-/config:

• גרסת קלוד קוד ישנה מ-v2.1.277.
• התוסף המובנה שקורא את AGENTS.md הושבת באמצעות /plugin.
• במקרים מסוימים, בסשן הראשון מיד לאחר שדרוג מגרסה v2.1.276 ומטה (בסשן הבא הקריאה פועלת).

לפני גרסה v2.1.281, סשנים מסוימים כגון עבודה דרך Amazon Bedrock או כשאיסוף טלמטריה מושבת קראו רק קבצי CLAUDE.md. בגרסאות אלה עדכנו את קלוד קוד. כדי לתת לקלוד את AGENTS.md בכל אחד מהסשנים שבהם הקריאה הישירה אינה זמינה, ייבאו אותו מתוך CLAUDE.md.

#הבדלים בין AGENTS.md לבין CLAUDE.md

קובץ AGENTS.md שנקרא דרך הגדרת הוראות הפרויקט שונה מקובץ CLAUDE.md בכמה נקודות:

#הסרת מעקפים ישנים עבור AGENTS.md

אם הגדרתם בעבר מעקפים לקריאת AGENTS.md, מומלץ לעדכן אותם:

• קובץ CLAUDE.md המכיל @AGENTS.md: ניתן להשאיר. הייבוא אינו גורם לקלוד לקרוא את AGENTS.md פעמיים, בכל ערך של Project instructions. מחקו את CLAUDE.md אם אינו מכיל דבר נוסף, או השאירו אותו אם חלק מהסשנים אינם יכולים לטעון את AGENTS.md ישירות.
• קובץ CLAUDE.md המורה לקלוד במילים לקרוא את AGENTS.md: קלוד רואה את AGENTS.md רק אם הוא מחליט לפתוח את הקובץ. מחקו את CLAUDE.md כדי שקלוד יקרא את AGENTS.md ישירות, או החליפו את המשפט בייבוא @AGENTS.md.
• קובץ CLAUDE.md כקישור סימבולי ל-AGENTS.md: אין צורך בשינוי, או מחקו את הקישור. בשני המקרים התוכן ייקרא פעם אחת.
• hook מסוג SessionStart שמדפיס את AGENTS.md: מחקו אותו. ברגע שקלוד קורא את הקובץ ישירות, ה-hook יוצר עותק כפול בהקשר.

#שיתוף קובץ יחיד עם כלי קוד נוספים

כשקלוד אינו קורא את AGENTS.md ישירות, אפשר עדיין להשאיר אותו כקובץ היחיד שכל הכלים חולקים, באמצעות ייבוא @AGENTS.md מתוך קובץ CLAUDE.md היושב לצידו. עשו זאת כשבפרויקט יש גם CLAUDE.md, כש-Project instructions מוגדר ל-claude-md, או בסשנים שאינם יכולים לטעון את AGENTS.md. הוסיפו הנחיות ייעודיות לקלוד מתחת לייבוא: קלוד קורא קודם את הקובץ המיובא, ואחר כך את שאר הקובץ.

@AGENTS.md

## Claude Code

Use plan mode for changes under `src/billing/`.

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

ln -s AGENTS.md CLAUDE.md

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

• עריכה: קלוד קורא את הקובץ דרך הקישור, אך כלי העריכה והכתיבה (Edit ו-Write) מסרבים לכתוב דרך קישור סימבולי ומכוונים את קלוד לערוך את יעד הקישור, AGENTS.md.
• Windows: אם אתם, או מי שמשכפל את המאגר, עובדים ב-Windows, עדיף להשתמש בייבוא @AGENTS.md. יצירת קישור סימבולי דורשת הרשאות מנהל או מצב מפתח, ו-Git משכפל קישור כקובץ טקסט פשוט אלא אם core.symlinks מופעל. בשכפול כזה נשאר קובץ CLAUDE.md בן שורה אחת במקום ההנחיות.

בכל אחת מהדרכים, הריצו /context all בסשן הבא וודאו ש-CLAUDE.md מופיע תחת Memory files. במצב מסך מלא, /context לבד מקפל את הרשימה הזו.

#הגירה מכלים אחרים

הרצת /init מזהה קבצי הנחיות של כלים אחרים ומשלבת אותם בקובץ CLAUDE.md שנוצר:

• חוקי Cursor מתוך .cursor/rules/ או .cursorrules
• חוקי Copilot מתוך .github/copilot-instructions.md
• כאשר CLAUDE_CODE_NEW_INIT=1 מוגדר: AGENTS.md, .devin/rules/, .windsurf/rules/ או .windsurfrules, ו-.clinerules

הפקודה /import מייבאת תצורה של סוכן קוד נתמך אל קלוד קוד: היא מוסיפה עותק חד פעמי של קבצי הנחיות כמו AGENTS.md אל קובץ CLAUDE.md המתאים, ומעבירה שרתי MCP, פקודות, סוכני משנה ו-skills.

#זיכרון אוטומטי (Auto memory)

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

• user: התפקיד שלכם, מומחיות והעדפות עבודה.
• feedback: תיקונים שנתתם לקלוד וגישות שאישרתם.
• project: עבודה שוטפת, לוחות זמנים והחלטות שלא ניתן להסיק מהקוד או מהיסטוריית ה-git.
• reference: היכן למצוא מידע מחוץ לפרויקט, כגון מעקב משימות או לוחות בקרה.

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

#הפעלה והשבתה של זיכרון אוטומטי

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

כדי להחליף את מצבו, פתחו את /memory בסשן והשתמשו במתג הזיכרון האוטומטי, ששומר את autoMemoryEnabled בהגדרות המשתמש ב-~/.claude/settings.json.

המתג מכבה את הזיכרון האוטומטי, אבל אינו מדליק אותו בחזרה בסשנים האלה:

• סשן רקע (background session).
• סשן שסשן אחר של קלוד קוד הפעיל, למשל כשקלוד מריץ claude דרך כלי Bash.

כשהזיכרון כבוי שם, המתג מציג off · can't be turned on here; use a session started outside Claude Code. כדי להדליק אותו שוב, הריצו claude ישירות בטרמינל והשתמשו במתג של /memory באותו סשן.

כדי להשבית אותו בפרויקט בודד, הגדירו בהגדרות אותו פרויקט:

{
  "autoMemoryEnabled": false
}

להשבתה באמצעות משתנה סביבה, הגדירו CLAUDE_CODE_DISABLE_AUTO_MEMORY=1.

#מיקום האחסון

כל פרויקט מקבל תיקיית זיכרון משלו בנתיב ~/.claude/projects/<project>/memory/. הנתיב של <project> נגזר ממאגר ה-git, כך שכל ה-worktrees ותתי התיקיות באותו מאגר חולקים תיקיית זיכרון אחת. מחוץ למאגר git נעשה שימוש בתיקיית השורש של הפרויקט.

אם מגדירים את CLAUDE_CODE_PROJECT_DIR_NAME לצד CLAUDE_CONFIG_DIR, קלוד קוד משתמש בשם זה כתיקיית <project> תחת <config dir>/projects/, בלי קשר למאגר שבו הופעל. כך פרויקטים שרצים עם תיקיית ההגדרות הזו חולקים תיקיית זיכרון אוטומטי אחת. נדרשת גרסה v2.1.234 ומעלה.

כדי לאחסן את הזיכרון האוטומטי במיקום אחר, הגדירו את autoMemoryDirectory בקובץ settings.json. ההגדרה נקראת מכל רמת הגדרות (משתמש, פרויקט, מקומי, מדיניות או --settings):

{
  "autoMemoryDirectory": "~/my-custom-memory-dir"
}

הערך חייב להיות נתיב מוחלט או להתחיל ב-~/.

כאשר מגדירים ערך זה ב-.claude/settings.json או ב-.claude/settings.local.json של הפרויקט, קלוד קוד מכבד אותו תחת אותו כלל אמון של סביבת העבודה (workspace trust) שחל על hooks בקובצי הגדרות. כאשר permissions.blockReadsOutsideWorkingDirectories מופעל, קלוד קוד אינו טוען זיכרון אוטומטי מתיקייה שקובץ הגדרות שמגיע מהמאגר בוחר, ואינו שומר אליה, בכל מקום שבו התיקייה יושבת.

התיקייה מכילה קובץ אינדקס MEMORY.md וקובץ נושא עבור כל רשומה:

~/.claude/projects/<project>/memory/
├── MEMORY.md           # אינדקס, שורה אחת לכל זיכרון, נטען בכל סשן
├── user_role.md        # רשומת זיכרון אחת
├── feedback_testing.md # רשומת זיכרון אחת
└── ...                 # קבצי נושא נוספים שקלוד יוצר

MEMORY.md משמש אינדקס של תיקיית הזיכרון. במהלך הסשן קלוד קורא וכותב קבצים בתיקייה, ומשתמש ב-MEMORY.md כדי לדעת מה שמור והיכן.

הזיכרון האוטומטי מקומי למחשב. כל ה-worktrees ותתי התיקיות באותו מאגר git חולקים תיקיית זיכרון אחת. הקבצים אינם משותפים בין מחשבים או סביבות ענן.

ניקוי תמלילים ישנים לפי cleanupPeriodDays מחריג את קבצי הזיכרון בתיקיית הזיכרון. MEMORY.md וקבצי הנושא נשמרים עד שאתם או קלוד עורכים או מוחקים אותם.

#איך זה עובד

200 השורות הראשונות של MEMORY.md או 25KB הראשונים (המוקדם מביניהם) נטענים בתחילת כל שיחה. תוכן מעבר לסף זה אינו נטען בשיגור. קלוד שומר על MEMORY.md תמציתי על ידי העברת פירוט לקבצי נושא נפרדים.

לאחר שקלוד כותב ל-MEMORY.md, קלוד קוד בודק את הקובץ מול מגבלות 200 השורות ו-25KB. אם הקובץ קרוב למגבלה, קלוד קוד מזכיר לקלוד לקצר אותו: שורה אחת לכל רשומה, העברת פירוט לקבצי נושא, ומיזוג או השמטה של רשומות ישנות. אם הקובץ חורג מהמגבלה, פעולת הכתיבה מצליחה, אך קלוד קוד מחזיר שגיאה המורה לקלוד לשכתב ולקצר את האינדקס, משום שכל תוכן שמעבר למגבלה יישמט בטעינה הבאה.

מגבלה זו חלה על MEMORY.md בלבד. כל קובץ CLAUDE.md שנטען בשיגור מגיע לקלוד במלואו, כל עוד גודלו עד 4 MiB. קלוד קוד מדלג על קובץ שמעל 4 MiB ואינו טוען ממנו דבר. לחוקים מוגבלי נתיב ולקבצי CLAUDE.md בתתי תיקיות יש מגבלה קטנה יותר לכל קובץ. קבצים קצרים יותר מניבים ציות טוב יותר.

קבצי נושא (כמו user_role.md או feedback_testing.md) אינם נטענים בשיגור, אלא נקראים על ידי קלוד לפי דרישה באמצעות כלי הקבצים הרגילים. זיכרון אוטומטי של השיחה הראשית אינו נטען לסוכני משנה (למעט במצב fork של השיחה, שיורש את שיחת האב ואת פרומפט המערכת). סוכן משנה יכול לנהל זיכרון משלו בתיקייה נפרדת באמצעות השדה memory.

כאשר מוצגת בממשק הודעה כמו Saved 2 memories או Recalled 2 memories, קלוד קורא או מעדכן קבצים בתיקיית הזיכרון ~/.claude/projects/<project>/memory/.

כאשר קלוד כותב קובץ זיכרון שמתחיל ב-frontmatter של YAML, קלוד קוד רושם את זמן הכתיבה בשדה modified כחותמת זמן בתקן ISO 8601. החותמת מראה עד כמה העובדה עדכנית, גם לכם וגם לקלוד כשהוא קורא את הזיכרון בחזרה.

קבצי הזיכרון האוטומטי הם Markdown רגיל שאפשר לערוך או למחוק בכל עת. הריצו /memory כדי לעיין בהם ולפתוח אותם מתוך הסשן.

#צפייה ועריכה באמצעות /memory

הפקודה /memory מציגה את מיקומי קבצי CLAUDE.md, CLAUDE.local.md וקבצי זיכרון נוספים ברמת המשתמש והפרויקט (כולל רשומות לקבצים שטרם נוצרו). הפקודה מאפשרת גם להפעיל או להשבית את הזיכרון האוטומטי ולפתוח את תיקיית הזיכרון. בחירת קובץ פותחת אותו בעורך שלכם (ואם אינו קיים, הוא נוצר תחילה). כדי לבדוק אילו קבצי CLAUDE.md וחוקים נטענו בסשן הנוכחי, הריצו /context all. במצב מסך מלא, /context לבד מקפל את הרשימה תחת Memory files.

עורכים גרפיים כמו VS Code פותחים את הקובץ בחלון נפרד ומאפשרים להמשיך בסשן במקביל. עורכי מסוף כמו Vim תופסים את המסוף עד ליציאה.

כאשר מבקשים מקלוד לזכור משהו בשיחה, למשל always use pnpm, not npm או remember that the API tests require a local Redis instance, הוא שומר זאת בזיכרון האוטומטי. כדי להוסיף הנחיות ל-CLAUDE.md, בקשו במפורש להוסיף את המידע לקובץ, או ערכו אותו ישירות דרך /memory.

#פתרון בעיות בזיכרון

#קלוד אינו פועל לפי הנחיות CLAUDE.md

תוכן CLAUDE.md נמסר כהודעת משתמש לאחר פרומפט המערכת, ולא כחלק מפרומפט המערכת עצמו. אין ערובה לציות מוחלט, בייחוד עבור הנחיות מעורפלות או סותרות.

שלבי בדיקה:

1. הריצו /context all ובדקו את הרשימה תחת Memory files כדי לוודא שקבצי CLAUDE.md ו-CLAUDE.local.md שאמורים להיטען בשיגור אכן נטענו. במצב מסך מלא, /context לבד מקפל את הרשימה הזו. אם קובץ חסר שם, קלוד אינו רואה אותו. השתמשו ב-/memory כדי לפתוח ולערוך את הקבצים.
2. אם מופיעה הודעה Instruction file not loaded, המשמעות והטיפול מתוארים בעמוד השגיאות בתיעוד הרשמי (נכון ל-2026-11-03). העמוד הזה אינו מפרט אותם.
3. קובץ CLAUDE.md בתת תיקייה של תיקיית העבודה אינו מופיע תחת Memory files, כי הוא נטען לפי דרישה ולא בשיגור. כשהוא נטען, מופיעה במסוף שורת Loaded עם הנתיב שלו. כדי לבדוק קובץ חדש, צרו אותו מה-shell ולא על ידי בקשה מקלוד לכתוב אותו, ואז בקשו מקלוד לקרוא קובץ באותה תת תיקייה.
4. ודאו שהקובץ נמצא בנתיב שנטען עבור הסשן שלכם.
5. נסחו הנחיות ספציפיות יותר (למשל Use 2-space indentation במקום format code nicely).
6. בדקו אם קיימות הנחיות סותרות בין קבצים שונים. אם שני קבצים נותנים הנחיה שונה לאותה התנהגות, קלוד עלול לבחור אחת מהן באופן שרירותי.
7. בדקו אם ההנחיה מתחרה בהנחיה שקלוד קוד מוסיף בעצמו. אם CLAUDE.md קובע כללי commit או pull request, כבו את ההנחיות המובנות עם includeGitInstructions והגדירו את טקסט הייחוס עם attribution.

אם הנחיה חייבת לרוץ בנקודת זמן קבועה (לפני commit או אחרי עריכת קובץ), הגדירו אותה כ-hook. hooks רצים כפקודות shell באירועי מחזור חיים קבועים, בלי תלות בהחלטה של קלוד.

עבור הנחיות ברמת פרומפט המערכת, השתמשו בדגל --append-system-prompt. מעבירים אותו בשיגור, ולכן הוא מתאים יותר לתסריטים ולאוטומציה מאשר לשימוש אינטראקטיבי. ההתנהגות כשממשיכים שיחה מתוארת בתיעוד הרשמי תחת דגלי system prompt בשיחות שהמשיכו.

[!TIP] השתמשו ב-hook מסוג InstructionsLoaded כדי לתעד אילו קבצי CLAUDE.md וחוקים נטענו, מתי הם נטענו ומדוע. הדבר יעיל לאיתור תקלות בחוקים מוגבלי נתיב ובטעינה מושהית מתתי תיקיות.

#קובץ AGENTS.md אינו נטען

אם קיים AGENTS.md וקלוד אינו מודע לתוכנו, לרוב הסיבה היא קובץ CLAUDE.md שנמצא בנתיב הפרויקט. כברירת מחדל קלוד קורא את AGENTS.md רק כשאין שום קובץ CLAUDE.md או CLAUDE.local.md בתיקיית העבודה או מעליה. בדקו לפי הסדר:

1. חפשו קבצי CLAUDE.md, .claude/CLAUDE.md או CLAUDE.local.md בתיקיית העבודה או מעליה (למעט ~/.claude/CLAUDE.md). אם קיים קובץ כזה, קלוד קורא אותו במקום את AGENTS.md, אלא אם תשנו את Project instructions לערך claude-md-and-agents-md.
2. הריצו claude --version וודאו גרסה v2.1.277 ומעלה. לפני גרסה v2.1.281, סשנים מסוימים, כמו עבודה ב-Amazon Bedrock או כשטלמטריה מושבתת, גם לא יכלו לטעון את AGENTS.md. בגרסאות אלה שדרגו ל-v2.1.281 ומעלה.
3. הקישו /config וודאו ש-Project instructions אינו מוגדר ל-claude-md או managed-only. אם ההגדרה אינה מופיעה בלוח בכלל, הסשן הוא סשן שאינו יכול לטעון את AGENTS.md.

כדי לוודא שקלוד קרא את AGENTS.md, הריצו /memory וחפשו את הנתיב שלו ברשימה.

לפני גרסה v2.1.280, /memory ו-/context לא הציגו AGENTS.md שקלוד קרא ישירות. בגרסאות אלה שאלו את קלוד מה אומרות הוראות הפרויקט.

אם אתם רוצים לשמור על קובץ ה-CLAUDE.md שמצאתם, או שהסשן אינו יכול לטעון את AGENTS.md, הוסיפו ליד AGENTS.md קובץ CLAUDE.md שמייבא אותו.

#תוכן הזיכרון האוטומטי אינו ברור

הריצו /memory ובחרו בתיקיית הזיכרון האוטומטי כדי לעיין בקבצים שנשמרו. כל הקבצים הם קבצי Markdown רגילים שניתן לקרוא, לערוך או למחוק.

#קובץ CLAUDE.md גדול מדי

קבצים מעל 200 שורות צורכים יותר הקשר ועלולים להפחית את רמת הציות. קלוד קוד מדלג על קובץ שגודלו מעל 4 MiB. השתמשו בחוקים מוגבלי נתיב כדי לטעון הוראות רק לפי צורך, או צמצמו תוכן שאינו נחוץ בכל שיחה. פיצול לייבוא @path עוזר לארגון, אך אינו מקטין את ההקשר, כי הקבצים המיובאים נטענים יחד עם קובץ ה-CLAUDE.md שמייבא אותם.

אם קובץ חורג מהאורך המומלץ, תוצג אזהרה בשיגור הסשן ובהרצת /status. אזהרה תוצג גם כאשר מספר קבצים שכל אחד מהם תקין מצטברים יחד מעבר למגבלה המשולבת בתחילת הסשן (כל קובץ CLAUDE.md, כל קובץ חוקים וכל ייבוא @path נספרים כקובץ נפרד).

בדיקת /doctor מציעה קיצוצים עבור קובץ CLAUDE.md שנשמר בבקרת גרסאות: היא מזהה ומציעה להסיר מידע שקלוד יכול להסיק מהקוד (מבנה תיקיות, רשימת תלויות וסקירות ארכיטקטורה), ומשאירה מלכודות, נימוקים ומוסכמות ששונות מברירות המחדל של הכלים.

[!NOTE] שמרו כל קובץ חוקים מוגבל נתיב בתוך מגבלת הגודל שלו לקובץ, כי קלוד מקבל רק את תחילת קובץ שחורג ממנה.

#קלוד מתעלם מסוף קובץ CLAUDE.md בתת תיקייה

כשקובץ CLAUDE.md בתת תיקייה, או קובץ חוקים שנטען לפי דרישה, חורג ממגבלת גודל לקובץ, קלוד מקבל רק את תחילתו. החלק הזה מסתיים בהערה שמורה לקלוד לקרוא את השאר עם הכלי Read. עד שקלוד בוחר לעשות זאת, ההנחיות המאוחרות אינן בהקשר שלו.

בדקו אם הקובץ חורג מהמגבלה, וצמצמו אותו אם כן:

1. ודאו שהמגבלה חלה על הקובץ. היא חלה על קבצים שנטענים לפי דרישה:
   • CLAUDE.md ו-CLAUDE.local.md בתת תיקייה של התיקייה שבה הפעלתם את קלוד קוד, והקבצים שהם מייבאים עם @path
   • קבצי חוקים ב-.claude/rules/ של תת תיקייה
   • חוקים מוגבלי נתיב ב-.claude/rules/ של הפרויקט או ב-~/.claude/rules/
2. מצאו את המגבלה לפי חלון ההקשר של הסשן:
   • חלון של 200K: 40,000 תווים
   • חלון של 1M: 200,000 תווים ב-Claude Opus 4.6 וב-Claude Sonnet 4.6, ו-150,000 תווים במודלים מאוחרים יותר
3. ב-Bash או ב-Zsh הריצו wc -m path/to/CLAUDE.md כדי להדפיס את מספר התווים בקובץ.
4. השוו את המספר למגבלה:
   • מעל המגבלה: צמצמו את הקובץ, או העבירו חלק ממנו לקובץ חוקים אחד או יותר. כל קובץ כזה נספר מול המגבלה בפני עצמו
   • מתחת למגבלה: חפשו סיבה אחרת בסעיף קלוד אינו פועל לפי הנחיות CLAUDE.md

לפני גרסה v2.1.309 קלוד קוד לא החיל את המגבלה הזו על קבצים שנטענים לפי דרישה.

#הנחיות נעלמו לאחר /compact

קובץ CLAUDE.md בשורש הפרויקט שורד דחיסה (/compact): קלוד קורא אותו מחדש מהדיסק ומזריק אותו שוב לסשן. קבצים מקוננים בתתי תיקיות וחוקים עם שדה paths: נטענים מחדש כאשר קלוד קורא קבצים שחלים עליהם.

אם הנחיה נעלמה לאחר דחיסה, הסיבה היא שהיא ניתנה בצ'אט בלבד, ישבה בקובץ מקונן שטרם נטען מחדש, או שייכת לחוק מוגבל נתיב שטרם הופעל שוב. הוסיפו הנחיות שניתנו רק בשיחה אל CLAUDE.md כדי שישרדו. פירוט מלא של מה ששורד דחיסה נמצא בעמוד חלון ההקשר בתיעוד הרשמי. לגודל, למבנה ולספציפיות ראו את הסעיף כתיבת הנחיות יעילות.

#התנגשות עם הנחיות Git מובנות

כאשר הנחיה ב-CLAUDE.md על commits או על pull requests מתנגשת עם הנחיה שקלוד קוד מוסיף בעצמו, כבו את ההנחיות המובנות עם includeGitInstructions והגדירו את טקסט הייחוס עם attribution. זו אותה בדיקה שמופיעה בשלבי האיתור שלמעלה, לצד חיפוש הוראות סותרות בקבצי ההנחיות שלכם.

#נתונים שקלוד קוד כותב תחת ~/.claude

מעבר לקבצים שאתם עורכים, ~/.claude מחזיק נתונים שקלוד קוד כותב במהלך סשנים: תמלילים, היסטוריית פרומפטים, צילומי קבצים, מטמונים ולוגים. הקבצים הם טקסט גלוי ואינם מוצפנים במנוחה. כל מה שעובר דרך כלי נכתב לתמליל על הדיסק: תוכן קבצים, פלט פקודות וטקסט שהודבק. התמליל יכול להחזיק גם את מה שקלוד קוד שולח למודל יחד עם ההודעות: הנחיית המערכת, הגדרות הכלים, פרמטרים של הבקשה, וקבצי ההוראות שנטענו, למשל CLAUDE.md. הרשאות הקבצים של מערכת ההפעלה הן ההגנה היחידה. אם כלי קורא קובץ .env או שפקודה מדפיסה סוד, הערך נכתב אל projects/<project>/<session>.jsonl.

כדי לצמצם חשיפה:

• הורידו את cleanupPeriodDays כדי לקצר את משך שמירת התמלילים.
• הגדירו desktopSessionCleanupPeriodDays כדי לתת מגבלת גיל גם לתמלילים של Claude Desktop ושל Cowork.
• הגדירו את CLAUDE_CODE_SKIP_PROMPT_HISTORY כדי לא לכתוב תמלילים והיסטוריית פרומפטים, בכל מצב. במצב לא אינטראקטיבי אפשר במקום זאת להעביר --no-session-persistence לצד -p, או להגדיר persistSession: false ב-TypeScript Agent SDK. ל-Python SDK אין אפשרות מקבילה.
• השתמשו בכללי permissions כדי לחסום קריאה של קבצי סודות.

#ניקוי לפי גיל

קלוד קוד מוחק קבצים בנתיבים שמתחת לסף הגיל של cleanupPeriodDays, כל עוד הוא יכול לקבוע בבטחה את תקופת השמירה. ברירת המחדל היא 30 יום, והמינימום הוא 1. ערך 0 נכשל בשגיאת אימות. אותו סף גיל חל גם על הסרה אוטומטית של worktrees יתומים.

בין הנתיבים שתחת ~/.claude/ שנכנסים לניקוי: תמלילי שיחה projects/<project>/<session>.jsonl (הודעות, קריאות כלים ותוצאות, וגם הנחיית המערכת, הגדרות הכלים והפרמטרים של הבקשות שקלוד קוד שלח למודל), עותק קודם שהושם בצד ואינו מופיע בבורר הסשנים (projects/<project>/<session>.orphaned-<timestamp>-<suffix>.jsonl או projects/<project>/<session>.jsonl.superseded-<timestamp>), תמלילי סוכני משנה ב-projects/<project>/<session>/subagents/, באותו פורמט כמו תמליל הסשן (נמחקים עם תמליל הסשן האב), פלט כלים גדול ועותקים בגודל מלא של תמונות שמחזירים כלי MCP ב-projects/<project>/<session>/tool-results/, projects/<project>/<session>/mcp-tasks/ (מה שסשן שהמשיך צריך כדי לעקוב שוב אחרי משימות MCP שרצות, ותוצאות של משימות שהסתיימו שקלוד עוד לא קרא), file-history/<session>/, plans/ (קבצי תוכנית ממצב plan), debug/ (לוגים לכל סשן כשרישום debug פעיל, למשל בהפעלה עם --debug או בהרצת /debug), paste-cache/, uploads/<session>/, dev-mods/<session>/, session-env/, tasks/, shell-snapshots/, backups/, feedback-bundles/, feedback/drafts/, usage-data/, skills/.trash/ ו-plugins/.trash/, וגם עותקים מתוארכים לפני שכתוב של installed_plugins.json: plugins/installed_plugins.set-aside.<date>.<hash>.json ו-plugins/installed_plugins.unreadable.<date>.<hash>.kept. תיקיות ישנות todos/, statsig/ ו-logs/ כבר אינן נכתבות. הניקוי מסיר את תוכנן ואז את התיקייה הריקה.

shell-snapshots/ מוסר ביציאה נקייה. הניקוי לפי גיל מנקה שאריות שנשארו אחרי קריסה.

uploads/<session>/ מחזיק קבצים שמצרפים מאפליקציית הווב או מהנייד, ותמונות מהנייד, כששולחים הודעה לסשן Remote Control. צירוף לסשן ענן נשמר בסביבת הענן של אותו סשן, לא על המחשב. dev-mods/<session>/ הם מודים שקלוד כתב במהלך הסשן. feedback-bundles/ הם ארכיוני תמליל מעובים ש-/feedback כותב אצל ספקים חיצוניים, או כשאין הרשאות Anthropic, כדי לשלוח לצוות החשבון ב-Anthropic.

skills/.trash/ ו-plugins/.trash/ מחזיקים skills ותוספים שהסנכרון מ-claude.ai הסיר, למשל אחרי כיבוי ב-claude.ai או הפסקת סנכרון, עד שהניקוי מוחק אותם.

ב-file-history נשמרים צילומים ל-100 נקודות השחזור האחרונות. קובץ צילום שאף נקודה שמורה אינה מפנה אליו נמחק, חוץ מהצילום הראשון של כל קובץ. ב-backups/ נשמרים חמשת העותקים החדשים ביותר של ~/.claude.json, וגם עותק של גרסה שלא היה אפשר לפענח. אחרי סף הגיל נמחק גם העותק האחרון שמחזיק את התצורה. אם הקובץ הנוכחי ניתן לפענוח, מחזיק את התצורה, וגודלו מתחת ל-8 MiB, נשאר עותק חדש שלו. ב-feedback/drafts/ הניקוי הוא אחרי cleanupPeriodDays או 30 יום, המוקדם מביניהם. כשהתור מגיע ל-10 טיוטות, נמחקת הטיוטה הישנה ביותר כדי לפנות מקום.

usage-data/ מחזיק את report.html ועותקים מתוארכים ש-/insights כותב, וגם נתוני ניתוח לכל סשן שבמטמון ששימשו לבנות אותם.

חריגים שכדאי לזכור:

• sessions/: קובץ קטן לכל סשן רץ, לזיהוי סשנים מקבילים וקריסות. אינו חלק מניקוי לפי גיל. הקובץ מוסר ביציאת הסשן, ושאריות קריסה מתנקות בהפעלה הבאה.
• זיכרון אוטומטי: קבצי projects/<project>/memory/ אינם נמחקים בניקוי. התיקייה מוסרת רק אם הייתה ריקה בכל תקופת השמירה. לפני גרסה v2.1.228 הניקוי התייחס לתיקיות בתוך תיקיית הזיכרון כנתוני סשן.
• תמלילי Claude Desktop ו-Cowork: תמליל של סשן שהתחלתם או שהמשכתם לאחרונה ב-Claude Desktop או ב-Cowork נשמר בכל גיל. כדי להגביל גיל, הגדירו desktopSessionCleanupPeriodDays. נדרשת גרסה v2.1.248 ומעלה. בגרסאות קודמות הם נמחקים אחרי cleanupPeriodDays. קלוד קוד מוחק אותם אחרי cleanupPeriodDays גם כשהגדרות מנוהלות קובעות את cleanupPeriodDays, או כשתצורת HIPAA חלה על הסשנים.
• image-cache/<session>/: תמונות שהודבקו או צורפו בגרסה v2.1.274 ומטה. בגרסאות מאוחרות יותר התמונות נשמרות מחוץ ל-~/.claude, בתיקיית images/ לכל סשן תחת תיקיית temp ש-CLAUDE_CODE_TMPDIR שולט בה. הניקוי מסיר כאן תיקיות שאריות של סשנים אחרים, בכל גיל.
• מצב bare: בהרצת claude -p עם --bare, קלוד קוד אינו מריץ את הניקוי באותו סשן.
• ניקוי מושהה: אם אי אפשר לקבוע בבטחה את תקופת השמירה, הניקוי מושהה. אירוע retention_sweep מפרט כל תצורה שמשהה אותו. כשהסיבה היא קובץ הגדרות שאי אפשר לקרוא או לפענח, או שגיאות הגדרה כש-cleanupPeriodDays או desktopSessionCleanupPeriodDays מוגדרים במפורש, מוצגת אזהרה ב-/status עד לתיקון. כשהגדרות מנוהלות מספקות cleanupPeriodDays, הניקוי רץ לפי הערך המנוהל גם במקרים האלה.

כדי לבדוק שהמכונות בארגון מריצות את הניקוי לפי תקופת השמירה שהוגדרה, התיעוד הרשמי מרכז זאת תחת Check the retention sweep.

נשמרים עד שתמחקו אותם, בין השאר: history.jsonl (כל פרומפט שהקלדתם, עם חותמת זמן ונתיב פרויקט. משמש לשליפה בחץ למעלה, לחיפוש Ctrl+R ולהשלמת פקודות shell עם !. כשתצורת HIPAA חלה על הסשנים, כל סריקת ניקוי מוחקת רשומות ישנות מ-cleanupPeriodDays), stats-cache.json (סיכומי טוקנים ועלות מצטברים שמוצגים ב-/usage), remote-settings.json (עותק מטמון של הגדרות מנוהלות מהשרת, או {} כשאין כאלה. קיים רק כשהסשן מושך אותן. קלוד קוד בודק עדכונים בשיגור ובכל שעה במהלך סשן. נמחק בהתנתקות), cache/changelog.md (עותק מטמון של יומן השינויים, מוצג ב-/release-notes, מתרענן ברקע), ו-policy-limits.json יחד עם policy-limits.json.stamp.json (הקובץ stamp רושם לאיזה חשבון או מפתח API המטמון שייך. קיימים רק בחלק מסוגי החשבון, מתרעננים אוטומטית, ונמחקים שניהם בהתנתקות). מטמונים וקבצי נעילה שאינם מופיעים בטבלאות האלה בטוחים למחיקה. שמרו את .credentials.json (פרטי ההתחברות), את agent-memory/ (זיכרון סוכני משנה), ואת jobs/ ו-daemon/ (מצב של סשני רקע). אל תמחקו את ~/.claude.json, את ~/.claude/settings.json או את ~/.claude/plugins/: שם יושבים האימות, ההעדפות והתוספים המותקנים.

#טיוטה זמנית של הסשן (scratchpad)

ה-scratchpad הוא תיקייה לכל סשן לקבצים זמניים: תוצאות ביניים, תסריטי עזר וטיוטות שאינן שייכות לפרויקט. כשקלוד אומר ששמר משהו "to the scratchpad", הקובץ שם. קלוד משתמש בה במקום /tmp, ויכול ליצור, לערוך ולקרוא בה בלי בקשת הרשאה.

התיקייה יושבת תחת תיקיית temp של קלוד קוד, לא תחת ~/.claude:

• macOS: /private/tmp/claude-<uid>/<project>/<session-id>/scratchpad/
• Linux: /tmp/claude-<uid>/<project>/<session-id>/scratchpad/, או אותה צורה תחת $TMPDIR כשהמערכת מגדירה אחד
• Windows: %TEMP%\claude\<project>\<session-id>\scratchpad\

<project> הוא נתיב תיקיית העבודה, ובו כל תו שאינו אות או ספרה מוחלף ב--, למשל -Users-you-my-project. אם מגדירים CLAUDE_CODE_TMPDIR, העץ עובר תחת התיקייה הזו. hooks מקבלים את הנתיב של הסשן הנוכחי בשדה scratchpad_dir.

הקבצים חיים כל עוד תמליל הסשן חי: ניקוי השמירה מוחק את התיקייה כשהוא מוחק את התמליל. claude purge אינו נוגע בתיקיית temp. כי התיקייה תחת temp של המערכת, מערכת ההפעלה יכולה לנקות אותה, למשל בהפעלה מחדש. כדי לשמור משהו שקלוד כתב שם, בקשו ממנו להעביר את הקובץ אל הפרויקט.

לסשן יש scratchpad רק כשכל אלה מתקיימים:

• אתם מחוברים עם חשבון claude.ai, לא עם מפתח API.
• הסשן משתמש ב-API של Anthropic, לא ב-Amazon Bedrock, לא ב-Agent Platform של Google Cloud, ולא ב-Microsoft Foundry.
• enableArtifact אינו false.

#מחיקת מצב של פרויקט עם claude purge

claude purge מוחק את המצב שקלוד קוד מחזיק עבור פרויקט אחד:

• תמלילים וזיכרון אוטומטי תחת projects/.
• רשומות tasks/, debug/ ו-file-history/ של הסשנים.
• שורות פרומפט תואמות ב-history.jsonl.
• רשומת הפרויקט ב-~/.claude.json.

תמונות שהודבקו או צורפו בסשנים של הפרויקט, ו-scratchpad של כל סשן, יושבים בתיקיית temp ולא ב-~/.claude, ולכן ה-purge אינו מוחק אותם. ניקוי השמירה עדיין מוחק את התמונות אחרי cleanupPeriodDays. ה-scratchpad של סשן שנמחק ב-purge נשאר עד שתמחקו אותו, או עד שמערכת ההפעלה מנקה את temp.

הפקודה מדפיסה את תוכנית המחיקה המלאה ומבקשת אישור לפני שהיא מוחקת. לפני גרסה v2.1.288 הפקודה הייתה claude project purge.

הדוגמאות משתמשות ב-~/work/my-repo כמציין מקום. החליפו בנתיב הפרויקט. אם אין מצב שתואם לנתיב, הפקודה מדפיסה שגיאה ויוצאת עם קוד 1.

1. תצוגה מקדימה, בלי מחיקה:

claude purge ~/work/my-repo --dry-run

התוכנית מפרטת כל פריט תואם ואת הסיבה. בדוגמה של ~/work/my-repo:

Purge plan for /home/user/work/my-repo:

  dir:    /home/user/.claude/projects/-home-user-work-my-repo
           project transcripts (.jsonl) and memory/
  config: projects["/home/user/work/my-repo"]
           project entry in ~/.claude.json (trust, history, MCP servers)
  filter: /home/user/.claude/history.jsonl
           12 prompt(s) typed in this project

shell-snapshots/ are not project-scoped and will not be touched
backups/ may still contain this project entry in old .claude.json snapshots (/home/user/.claude/backups); at most 5 are kept and they rotate out automatically
Dry run: 3 item(s) would be deleted.

2. מחיקה עם אישור אחד:

claude purge ~/work/my-repo

הפקודה מדפיסה את אותה תוכנית, ואז שואלת למשל Delete 3 item(s) for /home/user/work/my-repo? This cannot be undone. [y/N]. המחיקה מתבצעת רק אם עונים y.

3. בלי נתיב, הפקודה מציגה רשימה אינטראקטיבית לבחירת פרויקט.
4. בסקריפט, דלגו על האישור:

claude purge ~/work/my-repo --yes

5. --all במקום נתיב מוחק מצב של כל הפרויקטים בבת אחת, ומוחק את history.jsonl כולו במקום לסנן אותו.
6. -i עובר על תוכנית המחיקה פריט אחר פריט.

הפקודה משאירה את shell-snapshots/ ואת backups/ כי הם אינם לפי פרויקט, ומזהירה עליהם בפלט התוכנית. אם מישהו הריץ /heapdump על המכונה, מחקו גם את קבצי .heapsnapshot שהוא כתב. צילום heap מכיל את השיחה המלאה וכל אישור שהתהליך החזיק. לא ניקוי השמירה ולא claude purge נוגעים בו.

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

אל תמחקו את ~/.claude.json, את ~/.claude/settings.json או את ~/.claude/plugins/: שם יושבים האימות, ההעדפות והתוספים המותקנים.

הגדרות Claude Code.