📘 תיעוד 5

סקירת תיקיית claude.

המקום שבו Claude Code קורא את CLAUDE.md, את settings.json, hooks, skills, commands, תתי סוכנים (subagents), תהליכי עבודה (workflows), כללים (rules) וזיכרון אוטומטי (auto memory). סיירו בתיקיית claude. בפרויקט שלכם וב-claude./~ בתיקיית הבית שלכם.

Claude Code קורא הוראות, הגדרות, skills, תתי סוכנים וזיכרון מתיקיית הפרויקט שלכם ומ-~/.claude בתיקיית הבית שלכם. בצעו commit לקובצי הפרויקט ב-git כדי לשתף אותם עם הצוות שלכם. קבצים ב-~/.claude הם הגדרות אישיות שחלות על כל הפרויקטים שלכם.

ב-Windows, הנתיב ~/.claude מתורגם ל-%USERPROFILE%\.claude. אם תגדירו את משתנה הסביבה CLAUDE_CONFIG_DIR, כל נתיב של ~/.claude בדף זה יימצא תחת אותה תיקייה במקום זאת.

רוב המשתמשים עורכים רק את CLAUDE.md ואת settings.json. שאר התיקייה היא רשות: הוסיפו skills, כללים או תתי סוכנים לפי הצורך שלכם.

#סייר בתיקייה

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

#קובצי פרויקט (your-project/)

כל מה ש-Claude Code קורא שספציפי לפרויקט זה. אם אתם משתמשים ב-git, בצעו commit לרוב הקבצים כאן כדי שהצוות שלכם ישתף אותם. קבצים בודדים, כמו settings.local.json, נוספים ל-gitignore כאשר Claude Code שומר בהם הגדרות.

#CLAUDE.md

• נתיב: your-project/CLAUDE.md
• סטטוס: נכלל ב-commit
• תפקיד בקצרה: הוראות פרויקט ש-Claude קורא בכל הפעלה.
• מתי הוא נטען: נטען להקשר (context) בתחילת כל הפעלה.
• תיאור: הוראות ספציפיות לפרויקט שמעצבות את אופן הפעולה של Claude במאגר זה. מקמו כאן את המוסכמות שלכם, פקודות נפוצות והקשר ארכיטקטוני, כדי ש-Claude יפעל תחת אותן הנחות יסוד כמו הצוות שלכם.
• טיפים:
  • כוונו לפחות מ-200 שורות. קבצים ארוכים יותר עדיין נטענים במלואם, אך עשויים להפחית את רמת הציות.
  • CLAUDE.md נטען לכל הפעלה. אם משהו רלוונטי רק למשימות מסוימות, העבירו אותו ל-skill או ל-כלל מוגבל נתיב (rule) כדי שייטען רק לפי הצורך.
  • רשמו את הפקודות שאתם מריצים הכי הרבה, כמו build, test ו-format, כדי ש-Claude יכיר אותן מבלי שתפרטו אותן בכל פעם.
  • הריצו /memory כדי לפתוח ולערוך את CLAUDE.md מתוך הפעלה קיימת.
  • עובד גם בנתיב .claude/CLAUDE.md אם אתם מעדיפים לשמור על שורש הפרויקט נקי.
• דוגמה: דוגמה זו מיועדת לפרויקט TypeScript ו-React. היא מפרטת את פקודות ה-build וה-test, מוסכמות הפריימוורק שעל Claude לפעול לפיהן, וכללים ספציפיים לפרויקט כמו סגנון export ומבנה קבצים.

# 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

תיעוד מלא: זיכרון

#.mcp.json

• נתיב: your-project/.mcp.json
• סטטוס: נכלל ב-commit
• תפקיד בקצרה: שרתי MCP ברמת הפרויקט, משותפים עם הצוות שלכם.
• מתי הוא נטען: שרתים מתחברים עם תחילת ההפעלה. סכמות הכלים מושהות כברירת מחדל ונטענות לפי דרישה דרך חיפוש כלים ב-MCP.
• תיאור: מגדיר שרתי Model Context Protocol (MCP) שמעניקים ל-Claude גישה לכלים חיצוניים: מסדי נתונים, ממשקי API, דפדפנים ועוד. קובץ זה מכיל את השרתים ברמת הפרויקט שכל הצוות שלכם משתמש בהם. שרתים אישיים שברצונכם לשמור לעצמכם נשמרים ב-~/.claude.json במקום זאת.
• טיפים:
  • השתמשו בהפניות למשתני סביבה עבור סודות: ${NOTION_TOKEN}
  • נמצא בשורש הפרויקט, לא בתוך .claude/.
  • עבור שרתים שרק אתם צריכים, הריצו claude mcp add --scope user. פקודה זו כותבת ל-~/.claude.json במקום ל-.mcp.json.
• דוגמה: דוגמה זו מגדירה את שרת ה-MCP של Notion כדי ש-Claude יוכל לקרוא ולעדכן דפים בסביבת העבודה שלכם. ההפניה ${NOTION_TOKEN} נקראת מסביבת ה-shell שלכם כאשר Claude Code מפעיל את השרת, כך שהטוקן לעולם אינו נשמר בקובץ.

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@notionhq/notion-mcp-server"],
      "env": {
        "NOTION_TOKEN": "${NOTION_TOKEN}"
      }
    }
  }
}

תיעוד מלא: MCP

#.worktreeinclude

• נתיב: your-project/.worktreeinclude
• סטטוס: נכלל ב-commit
• תפקיד בקצרה: קבצים ב-gitignored להעתקה לתוך worktrees חדשים.
• מתי הוא נטען: נקרא כאשר Claude יוצר git worktree באמצעות --worktree, הכלי EnterWorktree, או תת סוכן עם isolation: worktree.
• תיאור: מפרט קבצים שנמצאים ב-gitignored שיש להעתיק מהמאגר הראשי שלכם לכל worktree חדש. עצי עבודה (worktrees) הם עותקים נקיים (checkouts), ולכן קבצים שאינם במעקב כמו .env חסרים כברירת מחדל. תבניות כאן משתמשות בתחביר של .gitignore. רק קבצים שתואמים לתבנית והם גם ב-gitignored מועתקים, כך שקבצים שבמעקב לעולם אינם משוכפלים.
• טיפים:
  • נמצא בשורש הפרויקט, לא בתוך .claude/.
  • מיועד ל-Git בלבד: אם תגדירו WorktreeCreate hook עבור מערכת בקרת גרסאות (VCS) אחרת, קובץ זה לא ייקרא. העתיקו קבצים בתוך סקריפט ה-hook שלכם במקום זאת.
  • חל גם על הפעלות מקבילות ב-אפליקציית שולחן העבודה.
• דוגמה: דוגמה זו מעתיקה את קובצי הסביבה המקומית שלכם והגדרות סודות לכל worktree ש-Claude יוצר. הערות מתחילות ב-

#ושורות ריקות זוכות להתעלמות, בדיוק כמו ב-gitignore.

# Local environment
.env
.env.local

# API credentials
config/secrets.json

תיעוד מלא: Worktrees

#תיקיית .claude/

• נתיב: your-project/.claude/
• תפקיד בקצרה: הגדרות ברמת הפרויקט, כללים והרחבות.
• תיאור: כל מה ש-Claude Code קורא שספציפי לפרויקט זה. אם אתם משתמשים ב-git, בצעו commit לרוב הקבצים כאן כדי שהצוות שלכם ישתף אותם. קבצים בודדים, כמו settings.local.json, נוספים ל-gitignore כאשר Claude Code שומר בהם הגדרות.

#settings.json

• נתיב: your-project/.claude/settings.json
• סטטוס: נכלל ב-commit
• תפקיד בקצרה: הרשאות, hooks והגדרות תצורה.
• מתי הוא נטען: דורס את settings.json הגלובלי מ-~/.claude/settings.json. הגדרות מקומיות, דגלי CLI והגדרות מנוהלות דורסים קובץ זה.
• תיאור: הגדרות ש-Claude Code מחיל ישירות. הרשאות קובעות באילו פקודות וכלים Claude רשאי להשתמש. hooks מריצים סקריפטים שלכם בנקודות מסוימות במהלך הפעלה. בניגוד ל-CLAUDE.md, ש-Claude קורא כהנחיה, הגדרות אלו נאכפות בין אם Claude עוקב אחריהן ובין אם לא.
• מפתחות נפוצים:
  • permissions: התרה (allow), חסימה (deny) או בקשת אישור לפני ש-Claude משתמש בכלים או פקודות מסוימים (ראו Permissions).
  • hooks: הרצת סקריפטים שלכם באירועים שונים, כמו לפני קריאה לכלי או לאחר עריכת קובץ (ראו Hooks).
  • statusLine: התאמה אישית של השורה המוצגת בתחתית בזמן ש-Claude עובד (ראו Status line).
  • model: בחירת מודל ברירת מחדל עבור פרויקט זה (ראו Settings reference: available settings).
  • env: משתני סביבה שמוגדרים בכל הפעלה (ראו Settings reference: environment variables).
  • outputStyle: בחירת סגנון פלט מותאם אישית מתוך output-styles/ (ראו Output styles).
• טיפים:
  • תבניות הרשאה של Bash תומכות בתווים כלליים: Bash(npm test *) תואם לכל פקודה שמתחילה ב-npm test.
  • הגדרות מסוג מערך כמו permissions.allow משתלבות בין כל הטווחים (scopes). הגדרות סקלריות כמו model משתמשות בערך הספציפי ביותר.
• דוגמה: דוגמה זו מתירה פקודות npm test ו-npm run ללא בקשת אישור, חוסמת את rm -rf, ומריצה את Prettier על קבצים לאחר ש-Claude עורך או כותב אותם.

{
  "permissions": {
    "allow": [
      "Bash(npm test *)",
      "Bash(npm run *)"
    ],
    "deny": [
      "Bash(rm -rf *)"
    ]
  },
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
      }]
    }]
  }
}

תיעוד מלא: הגדרות

#settings.local.json

• נתיב: your-project/.claude/settings.local.json
• סטטוס: מופיע ב-gitignore
• תפקיד בקצרה: דריסת הגדרות אישית שלכם עבור פרויקט זה.
• מתי הוא נטען: הקובץ בעל הקדימות הגבוהה ביותר מבין קובצי ההגדרות הניתנים לעריכה על ידי המשתמש. דגלי CLI והגדרות מנוהלות עדיין קודמים לו.
• תיאור: הגדרות אישיות שמקבלות קדימות על פני ברירות המחדל של הפרויקט. אותו מבנה JSON כמו settings.json, נוסף ל-gitignore כאשר Claude Code שומר בו הגדרה. השתמשו בו כאשר אתם זקוקים להרשאות או לברירות מחדל שונות מתצורת הצוות.
• טיפים:
  • אותה סכמה כמו settings.json. הגדרות מערך כמו permissions.allow משתלבות בין טווחים. הגדרות סקלריות כמו model משתמשות בערך המקומי.
  • כאשר Claude Code שומר הגדרה לקובץ זה במאגר שעדיין אינו מתעלם ממנו, הוא מוסיף את **/.claude/settings.local.json לקובץ ה-excludes הגלובלי של git: הערך core.excludesFile מהגדרות ה-git הגלובליות שלכם כאשר הוא מוגדר לנתיב מוחלט או לנתיב עם קידומת ~, אחרת ל-$XDG_CONFIG_HOME/git/ignore, או ל-~/.config/git/ignore. כדי לשתף את כלל ההתעלמות עם הצוות שלכם, הוסיפו אותו גם לקובץ ה-.gitignore של הפרויקט.
• דוגמה: דוגמה זו מוסיפה הרשאות Docker מעבר למה ש-settings.json של הצוות מתיר.

{
  "permissions": {
    "allow": [
      "Bash(docker *)"
    ]
  }
}

תיעוד מלא: הגדרות

#תיקיית rules/

• נתיב: your-project/.claude/rules/
• תפקיד בקצרה: הוראות לפי נושא, עם אפשרות לסינון מותנה לפי נתיבי קבצים.
• מתי הוא נטען: כללים ללא paths: נטענים בתחילת ההפעלה. כללים עם paths: נטענים כאשר קובץ תואם נכנס להקשר.
• תיאור: הוראות פרויקט שמפוצלות לקובצי נושא שיכולים להיטען באופן מותנה על סמך נתיבי קבצים. כלל ללא frontmatter של paths: נטען בתחילת ההפעלה כמו CLAUDE.md. כלל עם paths: נטען רק כאשר Claude קורא קובץ תואם. כמו CLAUDE.md, כללים הם הנחיות ש-Claude קורא, ולא הגדרות תצורה ש-Claude Code אוכף. לקבלת התנהגות מובטחת השתמשו ב-hooks או ב-הרשאות.
• טיפים:
  • השתמשו ב-frontmatter של paths: עם globs כדי להגביל כללים לתיקיות או לסוגי קבצים מסוימים.
  • תתי תיקיות נתמכות: הנתיב .claude/rules/frontend/react.md מזוהה באופן אוטומטי.
  • כאשר CLAUDE.md מתקרב ל-200 שורות, מומלץ להתחיל לפצל אותו לכללים.

תיעוד מלא: ארגון כללים

דוגמאות לקבצים בתוך rules/:

• testing.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: מוסכמות בדיקה מוגבלות לקובצי בדיקות.
  • מתי נטען: נטען כאשר Claude קורא קובץ שתואם ל-globs של paths: להלן.
  • תיאור: כלל לדוגמה שנטען רק כאשר Claude עובד על קובצי בדיקות. תבניות ה-globs ב-paths: מגדירות אילו קבצים מפעילים אותו, כאן כל קובץ שמסתיים ב-.test.ts או ב-.test.tsx. עבור קבצים אחרים, כלל זה אינו נטען להקשר.

---
paths:
  - "**/*.test.ts"
  - "**/*.test.tsx"
---

# Testing Rules

- Use descriptive test names: "should [expected] when [condition]"
- Mock external dependencies, not internal modules
- Clean up side effects in afterEach

• api-design.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: מוסכמות API מוגבלות לקוד צד שרת.
  • מתי נטען: נטען כאשר Claude קורא קובץ שתואם ל-glob של paths: להלן.
  • תיאור: דוגמה שנייה המציגה כלל המוגבל לקוד צד שרת (backend). תבנית ה-glob מתאימה לקבצים תחת src/api/, ולכן מוסכמות אלו נטענות רק כאשר Claude עורך נתיבי API.

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

# API Design Rules

- All endpoints must validate input with Zod schemas
- Return shape: { data: T } | { error: string }
- Rate limit all public endpoints

#תיקיית skills/

• נתיב: your-project/.claude/skills/
• תפקיד בקצרה: פרומפטים לשימוש חוזר שאתם או Claude מפעילים לפי שם.
• מתי הוא נטען: מופעל באמצעות skill-name/ או כאשר Claude מתאים את המשימה ל-skill.
• תיאור: כל skill הוא תיקייה המכילה קובץ SKILL.md ובנוסף קובצי עזר שנחוצים לו. כברירת מחדל, הן אתם והן Claude יכולים להפעיל skill. השתמשו ב-frontmatter כדי לשלוט בכך: disable-model-invocation: true עבור תהליכי עבודה המיועדים למשתמש בלבד כמו /deploy, או user-invocable: false כדי להסתיר מתפריט ה-/ בעוד ש-Claude עדיין יכול להפעיל אותו.
• טיפים:
  • מיומנויות (skills) מקבלות ארגומנטים: /deploy staging מעביר את "staging" כ-$ARGUMENTS. השתמשו ב-$0, $1 וכן הלאה לגישה לפי מיקום.
  • השדה description ב-frontmatter קובע מתי Claude יפעיל את ה-skill באופן אוטומטי.
  • אגדו מסמכי עזר לצד SKILL.md. Claude מכיר את נתיב תיקיית ה-skill ויכול לקרוא קובצי עזר כאשר אתם מזכירים אותם.

תיעוד מלא: Skills

דוגמה ל-skill מאוגד בתוך skills/security-review/:

• SKILL.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: נקודת כניסה: טריגר, יכולת הפעלה והוראות.
  • מתי נטען: המשתמש מקליד security-review <target>/. Claude אינו יכול להפעיל skill זה באופן אוטומטי.
  • תיאור: skill זה משתמש ב-disable-model-invocation: true כך שרק אתם יכולים להפעיל אותו, ו-Claude לעולם אינו מפעיל אותו בעצמו. השורה עם !... מריצה פקודת shell ומזריקה את הפלט שלה לתוך הפרומפט. $ARGUMENTS מקבל את מה שהקלדתם לאחר שם ה-skill. Claude רואה את נתיב תיקיית ה-skill, ולכן אזכור קובץ מאוגד כמו checklist.md מאפשר ל-Claude לקרוא אותו.

---
description: Reviews code changes for security vulnerabilities, authentication gaps, and injection risks
disable-model-invocation: true
argument-hint: <branch-or-path>
---

## Diff to review

!`git diff $ARGUMENTS`

Audit the changes above for:

1. Injection vulnerabilities (SQL, XSS, command)
2. Authentication and authorization gaps
3. Hardcoded secrets or credentials

Use checklist.md in this skill directory for the full review checklist.

Report findings with severity ratings and remediation steps.

• checklist.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: קובץ עזר המאוגד יחד עם ה-skill.
  • מתי נטען: Claude קורא אותו לפי דרישה במהלך הרצת ה-skill.
  • תיאור: מיומנויות יכולות לאגד כל קובץ עזר: מסמכי עיון, תבניות, סקריפטים. נתיב תיקיית ה-skill מתווסף לתחילת SKILL.md, כך ש-Claude יכול לקרוא קבצים מאוגדים לפי שמם. עבור סקריפטים בפקודות הזרקת bash, השתמשו במציין המיקום ${CLAUDE_SKILL_DIR}.

# Security Review Checklist

## Input Validation
- [ ] All user input sanitized before DB queries
- [ ] File upload MIME types validated
- [ ] Path traversal prevented on file operations

## Authentication
- [ ] JWT tokens expire after 24 hours
- [ ] API keys stored in environment variables
- [ ] Passwords hashed with bcrypt or argon2

#תיקיית commands/

• נתיב: your-project/.claude/commands/
• תפקיד בקצרה: פרומפטים בקובץ בודד המופעלים באמצעות name/.
• הערה: פקודות (commands) ו-skills הם כעת אותו מנגנון. עבור תהליכי עבודה חדשים, השתמשו ב-skills/ במקום זאת: אותה הפעלה באמצעות name/, ובנוסף תוכלו לאגד קובצי עזר.
• מתי הוא נטען: המשתמש מקליד command-name/.
• תיאור: קובץ בנתיב commands/deploy.md יוצר את הפקודה /deploy באותו אופן שבו skill בנתיב skills/deploy/SKILL.md יוצר אותה, ושניהם ניתנים להפעלה אוטומטית על ידי Claude. מיומנויות (skills) משתמשות בתיקייה עם SKILL.md, מה שמאפשר לכם לאגד מסמכי עיון, תבניות או סקריפטים לצד הפרומפט.
• טיפים:
  • השתמשו ב-$ARGUMENTS בקובץ כדי לקבל פרמטרים: /fix-issue 123
  • אם ל-skill ולפקודה יש אותו שם, ה-skill מקבל קדימות.
  • פקודות חדשות צריכות בדרך כלל להיות skills במקום זאת. פקודות ממשיכות להיתמך.

תיעוד מלא: Skills

דוגמה לקובץ בתוך commands/:

• fix-issue.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: מופעל כ-fix-issue <number>/.
  • תיאור: פקודה לדוגמה לתיקון issue ב-GitHub. הקלידו /fix-issue 123 והשורה עם !... תריץ gh issue view 123 ב-shell שלכם, ותזריק את הפלט לפרומפט לפני ש-Claude רואה אותו. $ARGUMENTS מחליף את מה שהקלדתם אחרי שם הפקודה. לגישה לפי מיקום, השתמשו ב-$0, $1 וכן הלאה.

---
argument-hint: <issue-number>
---

!`gh issue view $ARGUMENTS`

Investigate and fix the issue above.

1. Trace the bug to its root cause
2. Implement the fix
3. Write or update tests
4. Summarize what you changed and why

#תיקיית output-styles/

• נתיב: your-project/.claude/output-styles/
• תפקיד בקצרה: סגנונות פלט ברמת הפרויקט, אם הצוות שלכם משתף כאלה.
• מתי הוא נטען: קבצים נקראים בהפעלה. הסגנון שתבחרו באמצעות outputStyle חל על כל תשובה.
• תיאור: סגנונות פלט הם בדרך כלל אישיים, ולכן רובם נמצאים ב-~/.claude/output-styles/. שימו סגנון כאן אם הצוות שלכם משתף סגנון, כמו מצב סקירה שכולם משתמשים בו. ראו את החלק הגלובלי להסבר המלא ולדוגמה.

תיעוד מלא: סגנונות פלט

#תיקיית agents/

• נתיב: your-project/.claude/agents/
• תפקיד בקצרה: תתי סוכנים ייעודיים עם חלון הקשר משלהם.
• מתי הוא נטען: רץ בחלון הקשר משלו כאשר אתם או Claude מפעילים אותו.
• תיאור: כל קובץ markdown מגדיר תת סוכן עם system prompt משלו, גישה לכלים, ולפי בחירה גם מודל משלו. תתי סוכנים רצים בחלון הקשר נקי וחדש, מה ששומר על השיחה הראשית נקייה. שימושי לעבודה מקבילה או למשימות מבודדות.
• טיפים:
  • כל סוכן מקבל חלון הקשר נקי, נפרד מההפעלה הראשית שלכם.
  • הגבילו את הגישה לכלים לכל סוכן באמצעות השדה tools: ב-frontmatter.
  • הקלידו @ ובחרו סוכן מההשלמה האוטומטית כדי להאציל אליו סמכויות ישירות.

תיעוד מלא: תתי סוכנים

דוגמה לסוכן בתוך agents/:

• code-reviewer.md:
  • סטטוס: נכלל ב-commit
  • תפקיד: תת סוכן לסקירת קוד מבודדת.
  • מתי נטען: Claude מפעיל אותו למשימות סקירה, או שאתם מאזכרים אותו באמצעות @ מההשלמה האוטומטית.
  • תיאור: תת סוכן לדוגמה שמוגבל לכלים לקריאה בלבד. השדה description ב-frontmatter מודיע ל-Claude מתי להאציל אליו סמכויות באופן אוטומטי. השדה tools: מגביל אותו ל-Read, Grep ו-Glob כך שהוא יכול לבדוק קוד אך לעולם לא לערוך. גוף הקובץ הופך ל-system prompt של תת הסוכן.

---
name: code-reviewer
description: Reviews code for correctness, security, and maintainability
tools: Read, Grep, Glob
---

You are a senior code reviewer. Review for:

1. Correctness: logic errors, edge cases, null handling
2. Security: injection, auth bypass, data exposure
3. Maintainability: naming, complexity, duplication

Every finding must include a concrete fix.

#תיקיית workflows/

• נתיב: your-project/.claude/workflows/
• תפקיד בקצרה: סקריפטים דינמיים של תהליכי עבודה שמתזמרים תתי סוכנים רבים.
• מתי הוא נטען: נטען בהפעלה. כל קובץ הופך לפקודת name/<name>.
• תיאור: כל קובץ .js הוא תהליך עבודה דינמי (dynamic workflow): סקריפט שסביבת הריצה מבצעת כדי ליצור ולתאם תתי סוכנים רבים. תהליכי עבודה נכתבים על ידי Claude ונשמרים לכאן מתוך /workflows במקום להיכתב ידנית מאפס.
• טיפים:
  • שמרו ריצה מתוך /workflows באמצעות המקש s כדי ליצור קובץ כזה.
  • תהליך עבודה של הפרויקט מקבל קדימות על פני תהליך עבודה אישי ב-~/.claude/workflows/ בעל אותו שם.

תיעוד מלא: תהליכי עבודה דינמיים

#תיקיית agent-memory/

• נתיב: your-project/.claude/agent-memory/
• סטטוס: נכלל ב-commit, נוצר אוטומטית על ידי Claude
• תפקיד בקצרה: זיכרון מתמיד של תת הסוכן, נפרד מהזיכרון האוטומטי של ההפעלה הראשית שלכם.
• מתי הוא נטען: 200 השורות הראשונות (מוגבל ל-25KB) של MEMORY.md נטענות ל-system prompt של תת הסוכן כשהוא רץ.
• תיאור: תתי סוכנים עם memory: project ב-frontmatter שלהם מקבלים כאן תיקיית זיכרון ייעודית. זה נפרד מ-הזיכרון האוטומטי של ההפעלה הראשית ב-~/.claude/projects/: כל תת סוכן קורא וכותב ל-MEMORY.md משלו, לא לשלכם.
• טיפים:
  • נוצר רק עבור תתי סוכנים שמגדירים את השדה memory: ב-frontmatter.
  • תיקייה זו מכילה זיכרון של תת סוכן ברמת הפרויקט, שנועד לשיתוף עם הצוות שלכם. כדי לשמור זיכרון מחוץ לבקרת גרסאות השתמשו ב-memory: local, שכותב ל-.claude/agent-memory-local/ במקום זאת. עבור זיכרון חוצה פרויקטים השתמשו ב-memory: user, שכותב ל-~/.claude/agent-memory/.
  • הזיכרון האוטומטי של ההפעלה הראשית הוא תכונה שונה: ראו ~/.claude/projects/ בחלק הגלובלי.

תיעוד מלא: הפעלת זיכרון מתמיד

מבנה בתוך agent-memory/<agent-name>/:

• MEMORY.md:
  • סטטוס: נכלל ב-commit, נוצר אוטומטית על ידי Claude
  • תפקיד: תת הסוכן כותב ומתחזק קובץ זה באופן אוטומטי.
  • מתי נטען: נטען ל-system prompt של תת הסוכן כאשר תת הסוכן מופעל.
  • תיאור: פועל באותו אופן כמו הזיכרון האוטומטי הראשי שלכם: תת הסוכן יוצר ומעדכן קובץ זה בעצמו. אינכם כותבים אותו. תת הסוכן קורא אותו בתחילת כל משימה ורושם בו את מה שהוא לומד.

# code-reviewer memory

## Patterns seen
- Project uses custom Result<T, E> type, not exceptions
- Auth middleware expects Bearer token in Authorization header
- Tests use factory functions in test/factories/

## Recurring issues
- Missing null checks on API responses (src/api/*)
- Unhandled promise rejections in background jobs

#הגדרות גלובליות (~/)

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

#.claude.json

• נתיב: ~/.claude.json
• סטטוס: מקומי בלבד
• תפקיד בקצרה: מצב האפליקציה והעדפות ממשק משתמש.
• מתי הוא נטען: נקרא בתחילת הפעלה עבור ההעדפות ושרתי ה-MCP שלכם. Claude Code כותב אליו בחזרה כאשר אתם משנים הגדרות ב-/config או מאשרים הודעות אמון (trust prompts).
• תיאור: מחזיק מצב שאינו שייך ל-settings.json: ערכת נושא, הפעלת OAuth, החלטות אמון לפי פרויקט, שרתי ה-MCP האישיים שלכם ומתגי ממשק משתמש. מנוהל ברובו דרך /config ולא באמצעות עריכה ישירה.
• טיפים:
  • מתגי IDE כמו autoConnectIde ו-externalEditorContext נמצאים כאן, לא ב-settings.json.
  • המפתח projects עוקב אחר מצב לכל פרויקט, כמו קבלת תיבת האמון ומדדי הפעלה אחרונה. כללי הרשאה שאתם מאשרים במהלך הפעלה נשמרים ב-.claude/settings.local.json במקום זאת.
  • שרתי MCP כאן הם שלכם בלבד: טווח משתמש (user) חל על כל הפרויקטים, טווח מקומי (local) הוא לכל פרויקט אך אינו נכלל ב-commit. שרתים משותפים לצוות נשמרים ב-.mcp.json בשורש הפרויקט במקום זאת.
• דוגמה:

{
  "autoConnectIde": true,
  "externalEditorContext": true,
  "mcpServers": {
    "my-tools": {
      "command": "npx",
      "args": ["-y", "@example/mcp-server"]
    }
  }
}

תיעוד מלא: הגדרות תצורה גלובליות

#תיקיית ~/.claude/

ההגדרות האישיות שלכם בכל הפרויקטים.

#CLAUDE.md (גלובלי)

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

# Global preferences

- Keep explanations concise
- Use conventional commit format
- Show the terminal command to verify changes
- Prefer composition over inheritance

תיעוד מלא: זיכרון

#settings.json (גלובלי)

• נתיב: ~/.claude/settings.json
• סטטוס: מקומי בלבד
• תפקיד בקצרה: הגדרות ברירת מחדל לכל הפרויקטים.
• מתי הוא נטען: ברירות המחדל שלכם. settings.json של הפרויקט ושל ההגדרות המקומיות דורסים כל מפתח שאתם מגדירים גם שם.
• תיאור: אותם מפתחות כמו ב-settings.json של הפרויקט: הרשאות, hooks, מודל, משתני סביבה וכל השאר. הגדירו כאן הגדרות שאתם רוצים בכל פרויקט, כמו הרשאות שאתם תמיד מתירים, מודל מועדף, או hook התראות שרץ בלי קשר לפרויקט שבו אתם נמצאים. הגדרות פועלות לפי סדר קדימות: settings.json של הפרויקט דורס כל מפתח תואם שהגדרתם כאן. זה שונה מ-CLAUDE.md, שבו קבצים גלובליים וקבצי פרויקט נטענים שניהם להקשר במקום להתמזג מפתח אחר מפתח.
• דוגמה:

{
  "permissions": {
    "allow": [
      "Bash(git log *)",
      "Bash(git diff *)"
    ]
  }
}

תיעוד מלא: הגדרות

#keybindings.json

• נתיב: ~/.claude/keybindings.json
• סטטוס: מקומי בלבד
• תפקיד בקצרה: קיצורי מקשים מותאמים אישית.
• מתי הוא נטען: נקרא בתחילת ההפעלה ונטען מחדש בזמן אמת (hot-reloaded) כאשר עורכים את הקובץ.
• תיאור: הגדרה מחדש של קיצורי מקשים ב-CLI האינטראקטיבי. הריצו /keybindings כדי ליצור או לפתוח קובץ זה עם הפניה לסכמה. המקשים Ctrl+C, Ctrl+D, Ctrl+M ו-Caps Lock שמורים ולא ניתן להגדיר אותם מחדש.
• דוגמה: דוגמה זו מגדירה את Ctrl+E לפתיחת העורך החיצוני שלכם ומבטלת את ההגדרה של Ctrl+U על ידי קביעתו ל-null. השדה context מגביל את הקיצורים לחלק מסוים ב-CLI, כאן קלט הצ'אט הראשי.

{
  "$schema": "https://www.schemastore.org/claude-code-keybindings.json",
  "$docs": "https://code.claude.com/docs/en/keybindings",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+e": "chat:externalEditor",
        "ctrl+u": null
      }
    }
  ]
}

תיעוד מלא: קיצורי מקשים

#תיקיית themes/

• נתיב: ~/.claude/themes/
• תפקיד בקצרה: ערכות נושא מותאמות אישית של צבעים.
• מתי הוא נטען: נקרא בתחילת ההפעלה ונטען מחדש בזמן אמת כאשר קבצים משתנים. מופיע ברשימה ב-/theme.
• תיאור: כל קובץ .json מגדיר ערכת צבעים מותאמת אישית: תבנית base מובנית בתוספת מפת overrides של טוקני צבע. צרו אחת באופן אינטראקטיבי באמצעות /theme או כתבו את ה-JSON ידנית. בחירה בערכת נושא מותאמת אישית שומרת את custom:<slug> כהעדפת ערכת הנושא שלכם.
• דוגמה:

{
  "name": "Dracula",
  "base": "dark",
  "overrides": {
    "claude": "#bd93f9",
    "error": "#ff5555",
    "success": "#50fa7b"
  }
}

תיעוד מלא: יצירת ערכת נושא מותאמת אישית

#תיקיית projects/

• נתיב: ~/.claude/projects/
• סטטוס: נוצר אוטומטית על ידי Claude
• תפקיד בקצרה: זיכרון אוטומטי: הערות של Claude לעצמו, לכל פרויקט.
• מתי הוא נטען: MEMORY.md נטען בתחילת ההפעלה. קובצי נושאים נקראים לפי דרישה.
• תיאור: זיכרון אוטומטי מאפשר ל-Claude לצבור ידע לאורך הפעלות שונות מבלי שתכתבו דבר. Claude שומר הערות תוך כדי עבודה: פקודות build, תובנות ניפוי שגיאות, הערות ארכיטקטורה. כל פרויקט מקבל תיקיית זיכרון משלו המזוהה לפי נתיב המאגר.
• טיפים:
  • פועל כברירת מחדל. הפעילו או כבו באמצעות /memory או autoMemoryEnabled בהגדרות.
  • MEMORY.md הוא האינדקס שנטען בכל הפעלה. 200 השורות הראשונות, או 25KB, המוקדם מביניהם, נקראות.
  • קובצי נושאים כמו debugging.md נקראים לפי דרישה, לא בעת ההפעלה.
  • אלה קובצי markdown רגילים. ערכו או מחקו אותם בכל עת.

תיעוד מלא: זיכרון אוטומטי

מבנה בתוך projects/<project>/memory/:

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

# Memory Index

## Project
- [build-and-test.md](build-and-test.md): npm run build (~45s), Vitest, dev server on 3001
- [architecture.md](architecture.md): API client singleton, refresh-token auth

## Reference
- [debugging.md](debugging.md): auth token rotation and DB connection troubleshooting

• debugging.md:
  • סטטוס: מקומי בלבד, נוצר אוטומטית על ידי Claude
  • תפקיד: הערות נושא ש-Claude כותב כאשר MEMORY.md נהיה ארוך.
  • מתי נטען: Claude קורא קובץ זה כאשר עולה משימה קשורה.
  • תיאור: דוגמה לקובץ נושא ש-Claude יוצר כאשר MEMORY.md גדל מדי. Claude בוחר את שם הקובץ על סמך מה שהוא מפצל: debugging.md, architecture.md, build-commands.md, וכדומה. לעולם אינכם יוצרים קבצים אלו בעצמכם. Claude קורא קובץ נושא בחזרה רק כאשר המשימה הנוכחית קשורה אליו.

---
name: Debugging patterns
description: Auth token rotation and database connection troubleshooting for this project
type: reference
---

## Auth Token Issues
- Refresh token rotation: old token invalidated immediately
- If 401 after refresh: check clock skew between client and server

## Database Connection Drops
- Connection pool: max 10 in dev, 50 in prod
- Always check `docker compose ps` first

#תיקיית rules/ (גלובלית)

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

תיעוד מלא: ארגון כללים

#תיקיית skills/ (גלובלית)

• נתיב: ~/.claude/skills/
• תפקיד בקצרה: מיומנויות אישיות הזמינות בכל פרויקט.
• מתי הוא נטען: מופעל באמצעות skill-name/ בכל פרויקט.
• תיאור: מיומנויות שבניתם לעצמכם ועובדות בכל מקום. אותו מבנה כמו מיומנויות פרויקט: כל אחת מהן היא תיקייה עם SKILL.md, המוגבלת לחשבון המשתמש שלכם במקום לפרויקט בודד.

תיעוד מלא: Skills

#תיקיית commands/ (גלובלית)

• נתיב: ~/.claude/commands/
• תפקיד בקצרה: פקודות אישיות בקובץ בודד הזמינות בכל פרויקט.
• הערה: פקודות ו-skills הם כעת אותו מנגנון. עבור תהליכי עבודה חדשים, השתמשו ב-skills/ במקום זאת: אותה הפעלה באמצעות name/, ובנוסף תוכלו לאגד קובצי עזר.
• מתי הוא נטען: המשתמש מקליד command-name/ בכל פרויקט.
• תיאור: זהה ל-commands/ של הפרויקט, אך מוגבל לחשבון המשתמש שלכם. כל קובץ markdown הופך לפקודה הזמינה בכל מקום.

תיעוד מלא: Skills

#תיקיית output-styles/ (גלובלית)

• נתיב: ~/.claude/output-styles/
• תפקיד בקצרה: ערכות הוראות מותאמות אישית שמתאימות את אופן הפעולה של Claude.
• מתי הוא נטען: קבצים נקראים בהפעלה. הסגנון שתבחרו באמצעות outputStyle חל על כל תשובה.
• תיאור: כל קובץ markdown מגדיר סגנון פלט: ערכת הוראות עבור Claude שכברירת מחדל גם מחליפה את הוראות המשימה המובנות להנדסת תוכנה. השתמשו בזה כדי להתאים את Claude Code לשימושים מעבר לתכנות, או כדי להוסיף מצבי לימוד או סקירה. בחרו סגנון מובנה או מותאם אישית באמצעות /config או באמצעות המפתח outputStyle בהגדרות. סגנונות כאן זמינים בכל פרויקט. סגנונות ברמת הפרויקט בעלי אותו שם מקבלים קדימות.
• טיפים:
  • סגנונות מובנים Default, Proactive, Concise, Explanatory ו-Learning כלולים ב-Claude Code. סגנונות מותאמים אישית נשמרים כאן.
  • הגדירו keep-coding-instructions: true ב-frontmatter כדי לשמור על הוראות ברירת המחדל של המשימה לצד התוספות שלכם.
  • החלפת סגנונות באמצע הפעלה חלה מההודעה הבאה שלכם. בטרמינל, קובץ סגנון שאתם יוצרים או עורכים באמצע הפעלה נקלט לאחר הפעלה מחדש.

תיעוד מלא: סגנונות פלט

דוגמה בתוך output-styles/:

• teaching.md:
  • סטטוס: מקומי בלבד
  • תפקיד: סגנון לדוגמה שמוסיף הסברים ומשאיר שינויים קטנים עבורכם.
  • מתי נטען: פעיל כאשר outputStyle בהגדרות מוגדר ל-teaching.
  • תיאור: בסגנון זה, Claude מוסיף הערת "מדוע נבחרה גישה זו" לאחר כל משימה, ומשאיר סימוני TODO(human) עבור שינויים של פחות מ-10 שורות במקום לכתוב אותם בעצמו. בחרו בו על ידי הגדרת outputStyle לשם הקובץ ללא סיומת md., או לשדה name אם הגדרתם כזה ב-frontmatter.

---
description: Explains reasoning and asks you to implement small pieces
keep-coding-instructions: true
---

After completing each task, add a brief "Why this approach" note
explaining the key design decision.

When a change is under 10 lines, ask the user to implement it
themselves by leaving a TODO(human) marker instead of writing it.

#תיקיית agents/ (גלובלית)

• נתיב: ~/.claude/agents/
• תפקיד בקצרה: תתי סוכנים אישיים הזמינים בכל פרויקט.
• מתי הוא נטען: Claude מאציל סמכויות או שאתם מאזכרים באמצעות @ בכל פרויקט.
• תיאור: תתי סוכנים המוגדרים כאן זמינים בכל הפרויקטים שלכם. אותו מבנה כמו סוכני פרויקט.

תיעוד מלא: תתי סוכנים

#תיקיית workflows/ (גלובלית)

• נתיב: ~/.claude/workflows/
• תפקיד בקצרה: תהליכי עבודה דינמיים אישיים הזמינים בכל פרויקט.
• מתי הוא נטען: נטען בהפעלה. כל קובץ הופך לפקודת name/<name>.
• תיאור: סקריפטים של תהליכי עבודה שנשמרו כאן זמינים בכל הפרויקטים שלכם. תהליך עבודה של פרויקט עם אותו שם ב-.claude/workflows/ מקבל קדימות.

תיעוד מלא: תהליכי עבודה דינמיים

#תיקיית agent-memory/ (גלובלית)

• נתיב: ~/.claude/agent-memory/
• סטטוס: נוצר אוטומטית על ידי Claude
• תפקיד בקצרה: זיכרון מתמיד עבור תתי סוכנים עם memory: user.
• מתי הוא נטען: נטען ל-system prompt של תת הסוכן כאשר תת הסוכן מופעל.
• תיאור: תתי סוכנים עם memory: user ב-frontmatter שלהם שומרים כאן ידע שנשמר בכל הפרויקטים. עבור זיכרון של תת סוכן ברמת הפרויקט, ראו .claude/agent-memory/ במקום זאת.

תיעוד מלא: הפעלת זיכרון מתמיד

#מה לא מוצג בסייר

הסייר מכסה קבצים שאתם יוצרים ועורכים. מספר קבצים קשורים נמצאים במקומות אחרים:

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

#בחירת הקובץ המתאים

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

#מדריך קבצים

טבלה זו מפרטת כל קובץ שהסייר מכסה. קבצים ברמת הפרויקט נמצאים במאגר שלכם תחת .claude/ (או בשורש המאגר עבור CLAUDE.md, .mcp.json ו-.worktreeinclude). קבצים ברמת הטווח הגלובלי נמצאים ב-~/.claude/ וחלים על כל הפרויקטים.

הערה:

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

• הגדרות מנוהלות שנפרסו על ידי הארגון שלכם מקבלות קדימות על פני הכל, למעט החריגים תחת קדימות הגדרות.
• דגלי CLI כמו --permission-mode או --settings דורסים את settings.json עבור אותה הפעלה.
• משתני סביבה מסוימים מקבלים קדימות על פני ההגדרה המקבילה להם, אך הדבר משתנה: בדקו ב-מדריך משתני הסביבה עבור כל אחד מהם.

ראו קדימות הגדרות לסדר הקדימות המלא.

#פתרון בעיות בהגדרות תצורה

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

#נתוני אפליקציה

מעבר להגדרות התצורה שאתם יוצרים, הנתיב ~/.claude מחזיק נתונים ש-Claude Code כותב במהלך הפעלות. קבצים אלה הם טקסט פשוט (plaintext). כל מה שעובר דרך כלי נכתב לתמליל בדיסק: תוכן קבצים, פלט פקודות, טקסט מודבק.

#מנוקה באופן אוטומטי

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

קובצי הפעלה ב-sessions/, זיכרון אוטומטי, ותמלילי Claude Desktop ו-Cowork פועלים כל אחד לפי כלל שימור משלו:

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

Claude Code מדלג על סריקת הניקוי מבוססת הגיל במקרים הבאים:

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

#נשמרים עד שתמחקו אותם

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

קבצים אחרים מופיעים בהתאם לתכונות שבהן אתם משתמשים. קובצי מטמון וקובצי נעילה (lock files) בטוחים למחיקה. שמרו את קובצי המצב הבאים:

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

#אחסון בטקסט פשוט (Plaintext)

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

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

#מחיקת נתונים מקומיים

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

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

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

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

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

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

התוכנית מפרטת כל פריט תואם ומדוע הוא נכלל:

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.

מחיקה עם בקשת אישור בודדת:

claude project purge ~/work/my-repo

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

השמיטו את הנתיב כדי לבחור פרויקט מתוך רשימה אינטראקטיבית.

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

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

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

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

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

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

#משאבים קשורים

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