המפה הגדולה: שלוש שכבות של קבצים
Claude Code עובד עם שלוש שכבות קבצים. להבין איזו שכבה קובץ שייך אליה היא 80% מהמדריך:
| שכבה | איפה | למה היא משמשת | משותפת ב-git? |
|---|---|---|---|
| פרויקט | שורש ה-repo ו-.claude/ בתוכו | הוראות, הגדרות והרחבות שהצוות חולק | רוב הקבצים - כן committed מעט יוצאי דופן מסומנים |
| אישית-גלובלית | ~/.claude/ ו-~/.claude.json | ההעדפות האישיות שלך בכל הפרויקטים | לא. אף פעם לא עולה ל-repo local only |
| נתוני אפליקציה | בתוך ~/.claude/ (ובתיקיית temp) | מה ש-Claude Code כותב תוך כדי עבודה: transcripts, זיכרון אוטומטי, cache | לא Claude writes |
מעל כולן יושבת שכבה רביעית: הגדרות ארגוניות (managed settings) ש-IT מפיץ למחשבים - היא גוברת כמעט על כל דבר שאתם כותבים. נרחיב עליה בפרק ההגדרות.
כך נראה העץ המלא. כל פריט בו מקבל פרק משלו בהמשך:
your-project/ ← שכבת הפרויקט
├── CLAUDE.md הוראות שהצוות חולק, נטען בכל סשן
├── CLAUDE.local.md הוראות אישיות לפרויקט, ב-gitignore
├── AGENTS.md חלופה תקנית ל-CLAUDE.md (או לצדו)
├── .mcp.json שרתי MCP משותפים לצוות
├── .worktreeinclude קבצים מ-gitignore להעתיק ל-worktrees
└── .claude/
├── CLAUDE.md חלופה ל-CLAUDE.md בשורש
├── settings.json הרשאות, hooks, env - משותף לצוות
├── settings.local.json דריסות אישיות, מחוץ ל-git
├── rules/ הוראות נושאיות, אופציונלי: לפי נתיב קובץ
├── skills/<name>/SKILL.md פרומפטים לשימוש חוזר, /name
├── commands/*.md פרומפטים חד-קובציים (מנגנון זהה ל-skills)
├── agents/*.md subagents עם קונטקסט וכלים משלהם
├── output-styles/*.md סגנונות תגובה משותפים לצוות
├── workflows/*.js סקריפטים שמתזמרים subagents
└── agent-memory/ זיכרון מתמשך של subagents
~/ ← שכבה אישית-גלובלית
├── .claude.json מצב אפליקציה, OAuth, שרתי MCP אישיים
└── .claude/
├── CLAUDE.md העדפות אישיות בכל פרויקט
├── settings.json הגדרות ברירת מחדל לכל פרויקט
├── keybindings.json קיצורי מקלדת
├── themes/*.json ערכות צבעים
├── rules/ skills/ commands/ output-styles/ agents/ workflows/
│ אותם פורמטים, בהיקף "כל הפרויקטים שלי"
├── agent-memory/ זיכרון subagents חוצה-פרויקטים
├── plugins/ plugins מותקנים ו-marketplaces
└── ... ונתוני אפליקציה: transcripts, זיכרון אוטומטי, cache
(פרק "נתוני סשן ואפליקציה" למטה)
CLAUDE.md וקבצי ההוראות
קבצי CLAUDE.md הם קבצי Markdown שאתם כותבים, ו-Claude קורא אותם בתחילת כל סשן. הם הנחיה, לא אכיפה: Claude קורא אותם כהקשר, אבל אין מנגנון שמבטיח שהוא יציית. להתנהגות מובטחת משתמשים ב-hooks או ב-permissions (פרק ההגדרות).
ארבע הרמות של CLAUDE.md
| רמה | מיקום | למי זה מיועד | מה שמים שם |
|---|---|---|---|
| מדיניות ארגונית | macOS: /Library/Application Support/ClaudeCode/CLAUDE.md · Linux/WSL: /etc/claude-code/CLAUDE.md · Windows: C:\Program Files\ClaudeCode\CLAUDE.md | כל המשתמשים בארגון (IT/DevOps) | סטנדרטים, מדיניות אבטחה, דרישות compliance |
| משתמש | ~/.claude/CLAUDE.md | רק אתם, בכל הפרויקטים | סגנון תגובה, פורמט commits, קיצורים אישיים |
| פרויקט | ./CLAUDE.md או ./.claude/CLAUDE.md | הצוות, דרך source control | ארכיטקטורה, פקודות build/test, קונבנציות |
| לוקאלי | ./CLAUDE.local.md | רק אתם, בפרויקט הזה (להוסיף ל-.gitignore) | URLs של sandbox, דאטה לבדיקות |
איך הטעינה עובדת בפועל
- בהפעלה נטענים
CLAUDE.mdו-CLAUDE.local.mdמתיקיית העבודה וכל התיקיות מעליה. הרצה מתוך foo/bar/טוענת גם את foo/CLAUDE.md. - הקבצים מחוברים זה לזה (concatenated), לא דורסים זה את זה. בסדר: משורש מערכת הקבצים ועד תיקיית העבודה; בתוך אותה תיקייה,
CLAUDE.local.mdנקרא אחרון. - קבצי
CLAUDE.mdבתתי-תיקיות נטענים רק כש-Claude קורא קבצים שם - לא בהפעלה. - כשהוראות מתנגשות, הוראת פרויקט גוברת על הוראה גלובלית.
- הערות HTML ברמת בלוק (
<!-- ... -->) מוסרות לפני ההזרקה לקונטקסט - אפשר לכתוב הערות למתחזקים אנושיים בלי לבזבז tokens.
ייבוא קבצים עם @
בתוך CLAUDE.md אפשר לייבא קבצים נוספים עם @path/to/file. יחסי לקובץ שבו כתוב הייבוא, רקורסיבי עד עומק 4. ייבוא חיצוני (נתיב מחוץ לתיקיית העבודה, למשל @~/.claude/my-instructions.md) מציג דיאלוג אישור בפעם הראשונה בפרויקט. כדי לציין נתיב בלי לייבא, עטפו ב-backticks.
כללי עבודה מומלצים
- עד 200 שורות לקובץ. קבצים ארוכים נטענים במלואם אבל פוגעים בדיוק הביצוע. גדל מעבר? מפצלים ל-rules (מיד).
/initמייצר CLAUDE.md התחלתי מהקוד./memoryפותח את הקובץ לעריכה מתוך סשן./contextמראה אילו קבצי זיכרון באמת נטענו.- כותבים את מה שהייתם מסבירים שוב ושוב: פקודות build/test/lint, קונבנציות, מבנה. מה שרלוונטי רק למשימות מסוימות - עובר ל-skill או ל-rule.
AGENTS.md
אם ב-repo כבר יש AGENTS.md (התקן המשותף לסוכני קוד), Claude Code יכול לטעון אותו לבדו או לצד CLAUDE.md. פרטים בדף memory.
.claude/rules/ - הוראות נושאיות, אופציונלית לפי נתיב
תיקיית .claude/rules/ (וגם ~/.claude/rules/) מחזיקה הוראות מפוצלות לפי נושא. rule בלי paths: ב-frontmatter נטען בכל הפעלת סשן כמו CLAUDE.md; rule עם paths: נטען רק כש-Claude קורא קובץ שמתאים ל-glob. זו הדרך להחזיק קונבנציות של frontend ו-backend באותו repo בלי לנפח את הקונטקסט של שתיהן.
---
paths:
- "**/*.test.ts"
- "**/*.test.tsx"
---
# Testing Rules
- Use descriptive test names
- Mock external dependencies, not internal modules
- תתי-תיקיות מתגלות אוטומטית:
.claude/rules/frontend/react.mdעובד. - חוק ברמת משתמש (
~/.claude/rules/) חל על כל הפרויקטים. - במונו-repo רועש:
claudeMdExcludesמדלג על קבצי CLAUDE.md של צוותים אחרים.
Auto memory - הזיכרון שקלוד כותב לעצמו
בנפרד מ-CLAUDE.md (שאתם כותבים), Claude Code שומר לעצמו פתקים בין סשנים: פקודות build שגילה, תובנות debugging, העדפות שתיקנתם אותו עליהן. זה דיפולט - מופעל אוטומטית.
| CLAUDE.md | Auto memory | |
|---|---|---|
| מי כותב | אתם | Claude, תוך כדי עבודה |
| איפה | בתוך הפרויקט / ~/.claude/ | ~/.claude/projects/<project>/memory/ - מחוץ ל-repo |
| משותף לצוות | כן, דרך git | לא. מקומי למכונה בלבד |
| מה טוב לו | הנחיות יציבות שאתם שולטים בהן | למידה מתיקונים בלי מאמץ |
- המבנה:
MEMORY.mdהוא האינדקס - 200 השורות הראשונות (עד 25KB) נטענות בכל הפעלה. קבצי נושא כמו debugging.mdנקראים on-demand כשמשימה רלוונטית עולה. כל קובץ נושא נושאtypeב-frontmatter (למשל reference). - התיקייה נגזרת מה-repo: כל ה-worktrees ותתי-התיקיות של אותו repo חולקים זיכרון אחד.
- שליטה: כיבוי/הדלקה ב-
/memory(שומר autoMemoryEnabledב-settings), לפרויקט בודד ב-.claude/settings.json, או CLAUDE_CODE_DISABLE_AUTO_MEMORY=1. מיקום אחר: autoMemoryDirectoryב-settings. - עריכה ידנית מותרת: זה Markdown פשוט. אפשר לקרוא, לערוך ולמחוק - אבל Claude ימשיך לעדכן. דרך
/memoryמדפדפים במה שנשמר. - "תזכור שתמיד משתמשים ב-pnpm" - נשמר ב-auto memory. "תוסיף ל-CLAUDE.md" - נכתב ב-CLAUDE.md. ההבדל משנה למי שמשתף עם צוות.
קבצי ההגדרות: settings.json וחבריו
בניגוד ל-CLAUDE.md, קבצי settings נאכפים: הרשאות, hooks ומשתני סביבה פועלים בין אם Claude "מסכים" ובין אם לא.
ארבע רמות + סדר קדימויות
| היקף | קובץ | על מי חל | ב-git? |
|---|---|---|---|
| User | ~/.claude/settings.json | אתם, בכל פרויקט במכונה | לא |
| Shared project | .claude/settings.json | כל מי שעובד בתיקייה | כן - כך הצוות מקבל אותו committed |
| Project local | .claude/settings.local.json | אתם, בפרויקט הזה בלבד | לא - Claude Code דואג ל-gitignore כשהוא שומר אליו gitignored |
| Managed | managed-settings.json (מיקום תלוי OS), מדיניות MDM, או הגדרות מ-console של claude.ai | כל מי שהארגון מפיץ לו | - |
קדימויות, מהגבוה לנמוך: Managed → ארגומנטים בשורת הפקודה (--settings, --permission-mode) → settings.local.json → .claude/settings.json → ~/.claude/settings.json. מפתח ברמה גבוהה דורס את אותו מפתח למטה. משתני סביבה הם לא רמה בסדר - לכל צד משתנה/מפתח כלל משלו (ראו env vars reference). הגדרה ארגונית גוברת כמעט תמיד - גם על --settings; היוצא דופן המרכזי: model ארגוני קובע את ברירת המחדל אבל עדיין אפשר להחליף ב-/model, והנעילה האמיתית היא availableModels.
- הרשאות שאתם מאשרים בתוך סשן ("allow always") נשמרות ב-
.claude/settings.local.json. - מערכים כמו
permissions.allowמתאחדים בין הרמות; סקלרים כמו modelנלקחים מהרמה הספציפית ביותר. - מה שמכניסים:
permissions(allow/deny/ask), hooks, env, model, statusLine, outputStyleועוד.
~/.claude.json local only
מצב אפליקציה, לא הגדרות: theme, סשן OAuth, החלטות trust לכל פרויקט (מפתח projects), טוגלים של IDE (autoConnectIde), ושרתי ה-MCP האישיים שלכם. בדרך כלל מנהלים דרך /config ולא עורכים ידנית. גיבויים אוטומטיים של הקובץ נשמרים ב-~/.claude/backups/ (חמשת האחרונים).
~/.claude/keybindings.json local only
קיצורי מקלדת מותאמים ל-CLI. /keybindings פותח את הקובץ עם schema. נטען בהפעלה ומתרענן חם בעריכה. Ctrl+C, Ctrl+D, Ctrl+M ו-Caps Lock שמורים ולא ניתנים לשיבוץ מחדש.
~/.claude/themes/*.json local only
ערכת צבעים לכל קובץ: base מתוך הערכות המובנות + overrides של טוקני צבע. יוצרים אינטראקטיבית עם /theme או כותבים JSON ידנית.
MCP: .mcp.json ושרתים חיצוניים
| קובץ | היקף | למי |
|---|---|---|
.mcp.json בשורש הפרויקט committed | Project | הצוות כולו - שרתים משותפים |
~/.claude.json (מפתח mcpServers) | User / local | שרתים אישיים; claude mcp add --scope user כותב לכאן |
-
.mcp.jsonגר בשורש הפרויקט, לא בתוך .claude/. - סודות לא כותבים בקובץ: הפניה למשתנה סביבה
"${NOTION_TOKEN}"נקראת מה-shell בזמן ההפעלה. - schemas של כלים נטענים עצלנית (tool search) כברירת מחדל, כדי לא לנפח את הקונטקסט.
{
"mcpServers": {
"notion": {
"command": "npx",
"args": ["-y", "@notionhq/notion-mcp-server"],
"env": { "NOTION_TOKEN": "${NOTION_TOKEN}" }
}
}
}
ההרחבות: skills, commands, agents, output-styles, workflows
כל ההרחבות קיימות בשתי רמות: .claude/ בפרויקט (משותף לצוות) ו-~/.claude/ (אישי, בכל הפרויקטים). פורמט זהה, היקף שונה.
skills/<name>/SKILL.md committed בפרויקט
פרומפט לשימוש חוזר שמופעל ב-/skill-name או אוטומטית כש-Claude מזהה התאמה. כל skill הוא תיקייה: SKILL.md ולצדו קבצי עזר (templates, checklists, סקריפטים) ש-Claude קורא on-demand - נתיב תיקיית ה-skill זמין לו, ובסקריפטים משתמשים ב-${CLAUDE_SKILL_DIR}.
שליטה ב-frontmatter: disable-model-invocation: true (רק אתם מפעילים), user-invocable: false (מוסתר מהתפריט אבל Claude יכול). ארגומנטים: $ARGUMENTS, $0, $1. שורת !`command` מריצה פקודת shell ומזריקה את הפלט לפרומפט לפני שהמודל רואה אותו.
commands/*.md committed בפרויקט
פרומפטים חד-קובציים שמופעלים ב-/name. אותו מנגנון בדיוק כמו skills - commands/deploy.md יוצר את /deploy בדיוק כמו skills/deploy/SKILL.md, ושניהם יכולים לעלות אוטומטית. ההבדל: skill הוא תיקייה ולכן יכול לאגוד קבצי עזר. אם קיימים skill ו-command באותו שם - ה-skill מנצח. לדברים חדשים: כותבים skills; commands נשאר נתמך.
agents/*.md committed בפרויקט
כל קובץ מגדיר subagent: system prompt משלו, גישת כלים משלו (tools:), ואופציונלית מודל משלו. רץ בחלון קונטקסט נפרד, כך שהשיחה הראשית נשארת נקייה. ה-description קובע מתי Claude מעביר אליו משימות אוטומטית; אפשר גם להקיש @ ולבחור אותו. דוגמה קלאסית: reviewer עם tools: Read, Grep, Glob - יכול לבדוק אבל אף פעם לא לערוך.
output-styles/*.md בדרך כלל אישי
סט הוראות שמשנה איך Claude עובד - ובברירת מחדל גם מחליף את הוראות הנדסת-התוכנה המובנות (keep-coding-instructions: true משאיר אותן). בוחרים עם /output-style או מפתח outputStyle ב-settings. בדרך כלל אישי (~/.claude/output-styles/); שמים בפרויקט רק סגנון שהצוות חולק. סגנון פרויקט באותו שם גובר על אישי.
workflows/*.js
סקריפטים של dynamic workflows שמתזמרים הרבה subagents - נכתבים על ידי Claude ונשמרים מתוך /workflows (מקש s), לא נכתבים מאפס. כל קובץ הופך לפקודת /name. workflow של פרויקט גובר על אישי באותו שם.
agent-memory/<agent-name>/MEMORY.md Claude writes
זיכרון מתמשך ל-subagents - נפרד מה-auto memory של הסשן הראשי. נוצר רק לסוכנים עם memory: ב-frontmatter: memory: project כותב ל-.claude/agent-memory/ (משותף ב-git), memory: local ל-.claude/agent-memory-local/ (מחוץ ל-git), ו-memory: user ל-~/.claude/agent-memory/ (חוצה פרויקטים). הסוכן כותב ומתחזק את הקובץ בעצמו; 200 השורות הראשונות (עד 25KB) נטענות ל-system prompt שלו בכל ריצה.
~/.claude/plugins/
Plugins מותקנים, marketplaces משובטים, רישום ההתקנות installed_plugins.json ונתוני plugin - מנוהל על ידי פקודות claude plugin. Plugins שמסונכרנים מחשבון claude.ai יורדים ל-plugins/synced/. אל תערכו ידנית.
שני קבצי פרויקט נוספים בשורש
.worktreeinclude committed
רשימת קבצים מ-gitignore (בתחביר .gitignore) ש-Claude Code מעתיק לכל worktree חדש שהוא יוצר (--worktree, subagent עם isolation: worktree). בלעדיו, worktree הוא checkout נקי - בלי .env, בלי סודות מקומיים. רק קבצים שגם מתאימים לתבנית וגם מ-gitignored מועתקים.
נתוני סשן ואפליקציה: מה Claude Code כותב תוך כדי עבודה
מעבר לקבצים שאתם כותבים, ~/.claude/ מחזיק את מה שהכלי עצמו כותב. כל אלה טקסט גלוי, לא מוצפן - הרשאות הקבצים של מערכת ההפעלה הן ההגנה היחידה. כל דבר שעובר דרך כלי - תוכן קובץ, פלט פקודה, טקסט שהודבק - נכתב ל-transcript על הדיסק.
Transcripts - projects/<project>/<session>.jsonl
כל סשן נשמר רציף כ-JSONL: כל הודעה, כל קריאת כלי, כל תוצאה. <project> הוא נתיב תיקיית העבודה עם תווים לא-אלפאנומריים שהוחלפו ב-- (שם ארוך מדי נחתך ל-200 תווים + hash). זה מה שמאפשר claude --continue, --resume והבורר /resume.
- מה אפשר לעשות איתם: להמשיך סשן אחרי יציאה (
claude -c), לענף סשן (/branchמעתיק את ה-transcript), לייצא (/exportלקריאה אנושית), לקרוא את transcript_pathבתוך hook או status line, ולארכב ב-SessionEndhook. -
subagents/תחת תיקיית הסשן: transcripts של subagents; tool-results/: פלטים גדולים שהופנו לקבצים נפרדים ותמונות מ-MCP. - קבצי
.orphaned-*.jsonlו-.superseded-*: גרסאות קודמות שהכלי שם בצד במקום לדרוס; לא מופיעים בבורר הסשנים. - שליטה בשם תיקיית הפרויקט:
CLAUDE_CODE_PROJECT_DIR_NAME(יחד עם CLAUDE_CONFIG_DIR, דורש v2.1.234+).
מה מנוקה אוטומטית
Claude Code מוחק את הנתיבים הבאים כשהם מבוגרים מ-cleanupPeriodDays - ברירת מחדל 30 יום, מינימום 1 (ערך 0 נכשל בולידציה):
| נתיב תחת ~/.claude/ | תוכן |
|---|---|
projects/<project>/<session>.jsonl | Transcript מלא: כל הודעה, קריאת כלי ותוצאה |
projects/.../<session>/subagents/ · tool-results/ | Transcripts של subagents; פלטי כלים גדולים ותמונות MCP |
file-history/<session>/ | סנאפשוטים של קבצים לפני עריכה - הבסיס ל-checkpoint restore (100 checkpoints אחרונים) |
plans/ | תוכניות מ-plan mode |
debug/ | לוגים לכל סשן כש-debug פעיל (--debug או /debug) |
paste-cache/ | תוכן של הדבקות גדולות |
image-cache/<session>/ | תמונות מצורפות ב-v2.1.274 ומטה; גרסאות חדשות שומרות תמונות מחוץ ל-~/.claude, בתיקיית ה-temp |
uploads/<session>/ | קבצים שצורפו מה-web/מובייל לסשן Remote Control |
session-env/ | מטא-דאטה סביבתי לכל סשן |
tasks/ | רשימות משימות של כלי ה-tasks, תיקייה לכל רשימה |
shell-snapshots/ | Aliases ופונקציות shell מההפעלה, לכלי Bash. מנוקה ביציאה נקייה; ה-sweep מפנה שאריות של קריסה |
backups/ | גרסאות קודמות של ~/.claude.json - חמש אחרונות + כל גרסה שהכלי לא הצליח לפרסר |
feedback-bundles/ · feedback/drafts/ | ארכיוני feedback מצונזרים וטיוטות ממתינות ל-/feedback |
usage-data/ | דוחות /insights (report.html ועותקים מתוארכים) + cache של הניתוח |
skills/.trash/ · plugins/.trash/ | Skills ו-plugins שסנכרון claude.ai הסיר - סיכוי שחזור עד שה-sweep מוחק |
todos/ · statsig/ · logs/ | תיקיות legacy מגרסאות ישנות; כבר לא נכתבות וה-sweep מסיר אותן |
כללים מיוחדים: sessions/ (קובץ קטן לכל סשן פעיל, לזיהוי סשנים מקבילים וקריסות) אינו חלק מה-sweep - נמחק ביציאת הסשן. Auto memory לא נמחק ב-sweep - רק אם תיקיית הזיכרון ריקה כל תקופת השמירה. Transcripts של Claude Desktop ו-Cowork נשמרים ללא הגבלת גיל אלא אם מגדירים desktopSessionCleanupPeriodDays (v2.1.248+). ה-sweep מושהה ב---bare וכשאי אפשר לקבוע בטוח את תקופת השמירה.
מה נשמר עד שתמחקו
| נתיב | תוכן |
|---|---|
history.jsonl | כל פרומפט שהקלדתם, עם timestamp ונתיב פרויקט - מאחורי חץ-למעלה, Ctrl+R והשלמת ! |
stats-cache.json | סיכומי tokens ועלות ש-/usage מציג |
remote-settings.json | Cache של הגדרות ארגוניות מהשרת; נמחק ב-logout |
cache/changelog.md | ה-changelog ש-/release-notes מציג, מתרענן ברקע |
policy-limits.json | מדיניות פיצ'רים ארגונית (בחלק מסוגי החשבון); נמחק ב-logout |
.credentials.json | פרטי ההתחברות. לא למחוק |
agent-memory/ · jobs/ · daemon/ | זיכרון subagents ומצב סשנים ברקע. לשמור |
תיקיית ה-scratchpad
לכל סשן יש תיקיית עבודה זמנית משלו (קבצי ביניים, סקריפטים, טיוטות) - כש-Claude אומר "שמרתי ב-scratchpad", זה שם. נמצאת תחת תיקיית temp, לא תחת ~/.claude: לינוקס /tmp/claude-<uid>/<project>/<session-id>/scratchpad/ (או תחת $TMPDIR/CLAUDE_CODE_TMPDIR), macOS /private/tmp/claude-<uid>/..., ו-Windows %TEMP%\claude\.... Hooks מקבלים את הנתיב כ-scratchpad_dir. היא נמחקת עם ה-transcript של הסשן, ומערכת ההפעלה עלולה לפנות temp מוקדם יותר - דבר שצריך להישאר? בקשו מ-Claude להעביר לפרויקט.
אזהרת אבטחה: הכל טקסט גלוי
אם כלי קרא קובץ .env או פקודה הדפיסה סוד - הערך נכתב ל-
projects/<project>/<session>.jsonl. להקטנת החשיפה: להוריד את cleanupPeriodDays, להגדיר CLAUDE_CODE_SKIP_PROMPT_HISTORYלדילוג על כתיבת transcripts והיסטוריה (במצב לא-אינטראקטיבי: --no-session-persistenceלצד -p), ולהשתמש ב-permission rules כדי לחסום קריאת קבצי credentials.
ניקוי ומחיקה: claude project purge
הפקודה claude project purge מוחקת את כל מה שהכלי שומר על פרויקט אחד:
- Transcripts ו-auto memory תחת
projects/ - רשומות
tasks/, debug/ו-file-history/של הסשנים - שורות הפרויקט ב-
history.jsonl - רשומת הפרויקט ב-
~/.claude.json
היא לא נוגעת ב-shell-snapshots/, backups/, ובתמונות/scratchpad שבתיקיית temp. הפקודה מדפיסה תוכנית מחיקה מלאה ומבקשת אישור לפני שמוחקת כלום:
# תצוגה מקדימה בלי מחיקה
claude project purge ~/work/my-repo --dry-run
# מחיקה עם אישור
claude project purge ~/work/my-repo
# בלי אישור (לסקריפטים) · כל הפרויקטים · שלב אחד בכל פעם
claude project purge ~/work/my-repo --yes
claude project purge --all
claude project purge ~/work/my-repo -i
מה מפסידים במחיקה ידנית
אפשר למחוק ידנית כל נתיב מנתוני האפליקציה (מלבד קבצי המצב שצוינו לשמירה). סשנים חדשים לא מושפעים - רק ההיסטוריה:
| מוחקים | מפסידים |
|---|---|
~/.claude/projects/ | Resume/continue/rewind של סשנים ישנים, ו-auto memory של כל הפרויקטים |
~/.claude/history.jsonl | חץ-למעלה, חיפוש Ctrl+R והשלמת ! |
~/.claude/file-history/ | Checkpoint restore של סשנים ישנים |
~/.claude/stats-cache.json | סיכומים היסטוריים ב-/usage |
~/.claude/usage-data/ | דוחות /insights ישנים |
~/.claude/remote-settings.json, cache/changelog.md, policy-limits.json | כלום - מתחדש אוטומטית |
~/.claude/debug/, plans/, session-env/, shell-snapshots/, backups/ | כלום גלוי למשתמש |
~/.claude/todos/, statsig/, logs/, image-cache/ | כלום - תיקיות legacy שלא נכתבות בגרסאות נוכחיות |
לא למחוק: ~/.claude.json, ~/.claude/settings.json ו-~/.claude/plugins/ - שם האימות, ההעדפות וה-plugins.
איזה קובץ מתאים למה: טבלת החלטה
| רוצים ל... | עורכים | היקף |
|---|---|---|
| לתת ל-Claude קונטקסט וקונבנציות של הפרויקט | CLAUDE.md | פרויקט או גלובלי |
| לאפשר/לחסום קריאות כלי ספציפיות | permissions או hooks ב-settings.json | פרויקט או גלובלי |
| להריץ סקריפט לפני/אחרי קריאת כלי | hooks ב-settings.json | פרויקט או גלובלי |
| משתני סביבה לסשן | env ב-settings.json | פרויקט או גלובלי |
| דריסות אישיות מחוץ ל-git | settings.local.json | פרויקט בלבד |
| פרומפט/יכולת שמופעלים ב-/name | skills/<name>/SKILL.md | פרויקט או גלובלי |
| Subagent מומחה עם כלים משלו | agents/*.md | פרויקט או גלובלי |
| תזמור הרבה subagents מסקריפט | workflows/*.js | פרויקט או גלובלי |
| חיבור כלים חיצוניים (MCP) | .mcp.json | פרויקט בלבד (אישי: ~/.claude.json) |
| שינוי פורמט התגובות | output-styles/*.md | פרויקט או גלובלי |
שדות frontmatter לפי סוג קובץ
Skills, commands, subagents, output styles ו-rules קוראים את ההגדרות שלהם מ-YAML frontmatter בראש הקובץ. לכל סוג שדות משלו:
| קובץ | שדות |
|---|---|
skills/<name>/SKILL.md | name, description, when_to_use, argument-hint, arguments, disable-model-invocation, user-invocable, allowed-tools, disallowed-tools, model, effort, context, agent, background, hooks, paths, shell, metadata, license, compatibility |
commands/*.md | שדות ה-skill חוץ מ-name ו-paths |
agents/*.md | name, description, tools, disallowedTools, model, permissionMode, maxTurns, skills, mcpServers, hooks, memory, background, effort, isolation, color, initialPrompt, omitClaudeMd, experimental |
output-styles/*.md | name, description, keep-coding-instructions, force-for-plugin |
rules/*.md | paths |
מקורות
המדריך נסמך על התיעוד הרשמי של Claude Code, כפי שנקרא ב-27.9.2026:
- Explore the .claude directory - עץ הקבצים המלא, נתוני אפליקציה, כללי ניקוי ו-claude project purge
- How Claude remembers your project - רמות CLAUDE.md, ייבוא, rules, auto memory
- Claude Code settings - ארבע הרמות וסדר הקדימויות
- Manage sessions - אחסון transcripts ו-resume
- Extend Claude with skills - skills ו-commands
- Create custom subagents - agents וזיכרון מתמשך
- Connect Claude Code to tools via MCP - .mcp.json והיקפים
- Dynamic workflows · Output styles · Worktrees
מה שלא אומת: המדריך לא נבדק מול התקנה חיה של Claude Code במכונה הזו - כל התוכן מבוסס תיעוד רשמי בלבד, כולל דוגמאות ה-JSON. מספרי גרסאות שצוטטו (v2.1.234, v2.1.274, v2.1.248) הם כפי שמופיעים בתיעוד. פריטים שהתיעוד מסמן כמחייבי גרסה עדכנית עשויים לא להתקיים בגרסה מותקנת ישנה יותר.