📝 פרק 6

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

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

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

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

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

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

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

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

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

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

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

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

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

#קובץ CLAUDE.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• גודל הקובץ: כוונו לפחות מ-200 שורות לכל קובץ CLAUDE.md. קבצים ארוכים צורכים יותר הקשר ועלולים להפחית את רמת הציות. אם ההנחיות מתרחבות, השתמשו בחוקים מוגבלי נתיב ב-.claude/rules/ כדי שהוראות ייטענו רק כשקלוד עובד עם קבצים תואמים. ניתן גם לפצל תוכן לייבוא עם @ לצורך ארגון, אך קבצים מיובאים עדיין נטענים ונכנסים לחלון ההקשר בשיגור. קלוד קוד טוען קובץ CLAUDE.md עד גודל של 4 MiB במלואו, אך מדלג לחלוטין על קובץ שגודלו עולה על 4 MiB.
• מבנה: השתמשו בכותרות 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/ כדי להסיר הנחיות ישנות או סותרות. ב-monorepo השתמשו בהגדרה claudeMdExcludes כדי לדלג על קבצים של צוותים אחרים שאינם רלוונטיים לעבודתכם.

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

# 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. הקבצים המיובאים נפרסים ונטענים להקשר בשיגור לצד הקובץ שמפנה אליהם.

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

מנתח הייבוא מדלג על קטעי קוד בתוך 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 מבצעת זאת אוטומטית.

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

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

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

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

בסשני 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.md ו-CLAUDE.local.md בתתי תיקיות תחת תיקיית העבודה הנוכחית. במקום לטעון אותם בעת השיגור, הם נכללים כאשר קלוד קורא קבצים באותן תתי תיקיות.

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

הערות 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

הגדרה זו טוענת את הקבצים 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           
# Main project instructions
│   └── rules/
│       ├── code-style.md   
# Code style guidelines
│       ├── testing.md      
# Testing conventions
│       └── security.md     
# Security requirements

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

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

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

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

---
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 נטענים ללא תנאי וחלים על כל הקבצים. חוקים מוגבלי נתיב מופעלים כאשר קלוד קורא קבצים התואמים לתבנית, ולא בכל קריאת כלי. החל מגרסה v2.1.198, ההתאמה פועלת גם כאשר קלוד מגיע לקובץ דרך נתיב של קישור סימבולי לתיקיית הפרויקט.

השתמשו בתבניות 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. תבניות ללא סוגריים מסולסלים אינן נספרות כנגד התקציב.

קלוד קוד משתמש בכל תבנית שחורגת מהתקציב כפי שהיא ללא הרחבה, והסוגריים המסולסלים המילוליים לא יתאימו לאף קובץ. לפני גרסה v2.1.217, ערך paths עם קבוצות סוגריים מסולסלים רבות תקע או הפיל את ה-CLI בעת ההפעלה.

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

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

תיקיית .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/rules/
├── preferences.md    
# Your personal coding preferences
└── workflows.md      
# Your preferred workflows

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

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

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

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

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

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 מאפשר למקם תוכן CLAUDE.md מנוהל ישירות בתוך managed-settings.json במקום לפרוס קובץ נפרד:

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

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

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

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

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

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

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

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

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

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

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

לא ניתן להחריג קבצי CLAUDE.md של מדיניות מנוהלת. הוראות כלל ארגוניות יחולו תמיד ללא תלות בהגדרות אישיות.

#קובץ AGENTS.md

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

כדי לשנות את ברירת המחדל, למשל כדי שקלוד יקרא תמיד את שני הקבצים, יש לשנות את ההגדרה Project instructions.

[!NOTE] קריאה ישירה של AGENTS.md דורשת את קלוד קוד גרסה v2.1.277 ומעלה. בסשנים מסוימים, כגון סשנים ב-Amazon Bedrock או כאשר טלמטריה מושבתת, קלוד אינו יכול לקרוא את AGENTS.md ישירות, ובמקרים אלה יש לייבא אותו מתוך CLAUDE.md.

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

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

• קבצים שנספרים וגורמים לקלוד לקרוא אותם במקום את AGENTS.md: קובץ CLAUDE.md, .claude/CLAUDE.md או CLAUDE.local.md בתיקיית העבודה שלכם או בכל תיקייה מעליה.
• קבצים שאינם נספרים וממשיכים להיטען לצד AGENTS.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 משלה.
• בתוך כל AGENTS.md: ייבוא עם @path נפרס כרגיל, כללי claudeMdExcludes חלים, וסוכני משנה שמדלגים על הוראות פרויקט מדלגים גם על קבצים אלו.
• אינם נקראים: קבצי AGENTS.local.md, AGENTS.override.md, או כל קובץ תחת תיקיית .agents/.

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

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

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

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

דוגמה להגדרת קריאת שני הקבצים:

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

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

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

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

• אתם משתמשים בגרסה ישנה יותר מ-v2.1.277 של קלוד קוד.
• הסשן אינו מושך feature flags מ-Anthropic, למשל בעת שימוש ב-Amazon Bedrock, בספק צד שלישי אחר, או כאשר טלמטריה מושבתת.
• זהו הסשן הראשון לאחר התקנה או שדרוג לגרסה התומכת ב-AGENTS.md. קלוד יקרא את הקובץ החל מהסשן הבא.
• הוגדרה האפשרות disableAllHooks או allowManagedHooksOnly, או שהתוסף המובנה agents-md הושבת דרך /plugin.

בסשנים אלה, כדי לספק לקלוד את ההנחיות מתוך AGENTS.md, ייבאו אותו מתוך קובץ CLAUDE.md.

#היכן AGENTS.md שונה מ-CLAUDE.md

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

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

אם הגדרתם בעבר מעקפים לקריאת AGENTS.md לפני שהתמיכה נוספה רשמית:

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

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

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

@AGENTS.md

## Claude Code

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

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

ln -s AGENTS.md CLAUDE.md

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

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

בשתי הגישות, הריצו /context בסשן הבא וודאו ש-CLAUDE.md מופיע תחת Memory files.

#הגירת הנחיות מכלים אחרים

הרצת הפקודה /init קוראת קבצי הנחיות של כלים אחרים ומשלבת את החלקים הרלוונטיים בתוך קובץ ה-CLAUDE.md שנוצר:

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

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

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

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

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

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

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

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

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

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

{
  "autoMemoryEnabled": false
}

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

CLAUDE_CODE_DISABLE_AUTO_MEMORY=1

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

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

אם מגדירים את CLAUDE_CODE_PROJECT_DIR_NAME לצד CLAUDE_CONFIG_DIR, קלוד קוד משתמש בשם זה כתיקיית הפרויקט תחת תיקיית התצורה, כך שפרויקטים המופעלים עם אותה תיקיית תצורה חולקים תיקיית זיכרון אחת (דורש גרסה v2.1.234 ומעלה).

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

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

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

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

תיקיית הזיכרון כוללת אינדקס ראשי וקבצי נושא נפרדים:

~/.claude/projects/<project>/memory/
├── MEMORY.md           
# Index, one line per memory, loaded into every session
├── user_role.md        
# One memory
├── feedback_testing.md 
# One memory
└── ...                 
# Any other topic files Claude creates

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

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

#כיצד הזיכרון פועל

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

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

מגבלה זו חלה רק על MEMORY.md. קלוד קוד טוען קובץ CLAUDE.md עד 4 MiB במלואו, ומדלג על קובץ גדול מכך.

קלוד קוד אינו טוען קבצי נושא כגון user_role.md או feedback_testing.md בעת ההפעלה. קלוד קורא אותם לפי דרישה באמצעות כלי הקבצים הרגילים כאשר הוא זקוק למידע.

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

כאשר מופיעות בממשק הודעות כגון Saved 2 memories או Recalled 2 memories, קלוד מעדכן או קורא באופן פעיל מתוך תיקיית הזיכרון.

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

#בדיקה ועריכה של הזיכרון

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

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

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

עורכים בעלי ממשק גרפי (כגון VS Code) פותחים את הקובץ בחלון נפרד, וניתן להמשיך להשתמש בסשן בזמן שהקובץ פתוח (לפני גרסה v2.1.216, הפקודה /memory המתינה לסגירת הקובץ). עורכי טרמינל (כגון Vim) תופסים את הטרמינל עד ליציאה מהם.

כאשר אתם מבקשים מקלוד לזכור משהו (למשל "תמיד תשתמש ב-pnpm ולא ב-npm"), קלוד שומר זאת בזיכרון האוטומטי. כדי להוסיף הנחיות ל-CLAUDE.md, בקשו זאת במפורש (למשל "הוסף זאת ל-CLAUDE.md") או ערכו את הקובץ בעצמכם דרך /memory.

#נתוני אפליקציה וניקוי בתיקיית ~/.claude

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

#קבצים שנמחקים אוטומטית

קלוד קוד מוחק את הקבצים בנתיבים שלהלן כאשר גילם עולה על תקופת השמירה שנקבעה בהגדרה cleanupPeriodDays, כל עוד ניתן לקבוע את התקופה בצורה בטוחה. ברירת המחדל היא 30 יום והמינימום הוא יום אחד (הגדרה של 0 נכשלת בשגיאת אימות). אותה מגבלת גיל חלה על מחיקה אוטומטית של worktrees יתומים של Git.

כללי שמירה מיוחדים עבור קבצים נוספים:

• sessions/: מכיל קובץ קטן עבור כל סשן פעיל לזיהוי קריסות והפעלות במקביל. אינו נמחק לפי גיל: הקובץ מוסר ביציאה תקינה, ושאריות מקריסה מנוקות בהפעלה הבאה.
• זיכרון אוטומטי: סבב הניקוי אינו מוחק קבצים בתיקיית הזיכרון של הפרויקט projects/<project>/memory/. התיקייה תוסר רק אם הייתה ריקה לאורך כל תקופת השמירה. (לפני גרסה v2.1.228, סבב הניקוי עלול היה למחוק קבצים ישנים בתיקיית הזיכרון).
• תמלילי Claude Desktop ו-Cowork: נשמרים ללא הגבלת גיל כברירת מחדל. כדי להגדיר להם מגבלת גיל, הגדירו את desktopSessionCleanupPeriodDays (דורש גרסה v2.1.248 ומעלה). כאשר הגדרות מנוהלות מגדירות cleanupPeriodDays, תמלילים אלה יימחקו לפי אותה תקופה.

מקרים שבהם סבב הניקוי מדולג:

• מצב Bare: בהרצת claude -p עם הדגל --bare, סבב הניקוי אינו מופעל באותו סשן.
• סבב ניקוי מושהה: כאשר קלוד קוד אינו יכול לקבוע בבטחה את תקופת השמירה (למשל עקב קובץ הגדרות שלא ניתן לקריאה או שגיאות בהגדרת תקופות השמירה), סבב הניקוי מושהה ומוצגת אזהרה בפקודת /status. אם מוגדר ערך מנוהל של cleanupPeriodDays, הניקוי יפעל לפיו.

#קבצים שנשמרים עד למחיקה ידנית

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

קבצי מצב שיש לשמור:

• .credentials.json: פרטי ההתחברות שלכם.
• agent-memory/: זיכרון סוכני משנה.
• jobs/ ו-daemon/: מצב סשנים ברקע.

#אחסון בטקסט רגיל ואבטחה

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

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

#מחיקת נתונים מקומיים עם claude project purge

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

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

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

הצגת תוכנית המחיקה ללא ביצוע שינויים בפועל:

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

הפעלת מחיקה עם שאלת אישור אחת:

claude project purge ~/work/my-repo

דילוג על שאלת האישור לשימוש בתסריטים אוטומטיים:

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

השמטת הנתיב מאפשרת לבחור פרויקט מתוך רשימה אינטראקטיבית. העברת הדגל --all במקום נתיב מוחקת את כל המצב עבור כל הפרויקטים בבת אחת (ומוחקת את history.jsonl כולו). העברת הדגל -i מאפשרת לעבור על פריטי תוכנית המחיקה אחד אחד.

הפקודה אינה נוגעת בתיקיות shell-snapshots/ ו-backups/ מכיוון שהן אינן מוגבלות לפרויקט בודד.

אם מוחקים נתיבים ידנית מתוך ~/.claude:

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

#פתרון בעיות (Troubleshooting)

אלו הבעיות הנפוצות ביותר בעבודה עם CLAUDE.md, עם AGENTS.md ועם זיכרון אוטומטי, יחד עם הצעדים לפתרונן.

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

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

שלבי בדיקה:

• הריצו /context ובדקו את הרשימה תחת Memory files כדי לוודא שקבצי ה-CLAUDE.md ו-CLAUDE.local.md אכן נטענו. אם קובץ חסר שם, קלוד אינו רואה אותו. קובץ AGENTS.md מופיע ברשימה זו רק כאשר קובץ CLAUDE.md מייבא אותו, ולא כאשר קלוד קורא אותו ישירות. השתמשו ב-/memory כדי לפתוח ולערוך את הקבצים.
• ודאו שקובץ ה-CLAUDE.md הרלוונטי נמצא במיקום שנטען עבור הסשן שלכם.
• נסחו הנחיות ספציפיות יותר. הוראה כמו Use 2-space indentation עובדת טוב יותר מאשר format code nicely.
• חפשו הנחיות סותרות בין קבצי CLAUDE.md שונים. אם שני קבצים מספקים הנחיות שונות לאותה התנהגות, קלוד עלול לבחור ביניהן באופן שרירותי.

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

להנחיות שחייבות להופיע ברמת פרומפט המערכת, השתמשו בדגל --append-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 ומעלה.
3. בדקו אם הסשן שלכם שייך למקרים שאינם יכולים לטעון את AGENTS.md, כגון סשן דרך ספק צד שלישי או כאשר טלמטריה מושבתת.
4. הקלידו /config בסשן כדי לפתוח את לוח ההגדרות, וודאו שההגדרה Project instructions אינה מוגדרת ל-claude-md או ל-managed-only. אם ההגדרה אינה מופיעה שם כלל, הסשן אינו יכול לטעון את AGENTS.md.

קובץ AGENTS.md אינו מופיע ב-/memory או ב-/context כאשר קלוד קורא אותו ישירות, לכן חפשו את שורת הדיווח על טעינת הקובץ בתחילת השיחה או שאלו את קלוד מה כוללות הנחיות הפרויקט שלו.

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

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

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

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

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

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

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

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

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