📘 תיעוד 129

קבצי הגדרות וסדר עדיפות

שנו הגדרות של Claude Code, בחרו את ההיקף שמפתח שייך אליו, אמתו את השינוי, ולמדו באיזה ערך Claude Code משתמש כשמפתח מוגדר בכמה מקומות.

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

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

Claude Code קורא הגדרות מקבצי הגדרות JSON כמו ~/.claude/settings.json. הוא מחפש אותם בכמה מיקומים, והקובץ שממנו הוא קורא הגדרה קובע למי ההגדרה חלה. העמוד הזה מכסה את הקבצים האלה: באיזה מהם לשים הגדרה, איך לשנות הגדרה ולאשר שהיא חלה, ובאיזה ערך Claude Code משתמש כשאותו מפתח מוגדר ביותר מקובץ אחד. הגדרת הרשאות מכסה מה Claude Code יכול להריץ בלי לשאול ואיך לכתוב כללי allow, ask ו-deny.

הערה: העמוד הזה מכסה את Claude Code כשהוא רץ על המחשב שלכם: הטרמינל, התוספים של VS Code ו-JetBrains, ואפליקציית שולחן העבודה, שכולם קוראים את אותם קבצי הגדרות. הפעלה בענן רצה על מחשב אחר וקוראת רק חלק מהם. ראו הגדרות בהפעלות בענן.

#קבצי הגדרות ולמי הם משפיעים

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

בעמודת הקובץ, ~/.claude היא תיקיית .claude בתיקיית הבית שלכם, ו-.claude בלי נתיב היא תיקיית .claude בתוך הפרויקט שלכם.

#השוואת ההיקף של כל קובץ הגדרות

נניח שיש לכם שלושה פרויקטים במחשב, website/, api/ ו-acme-app/, לחבר צוות יש עותק משלו של acme-app/, ואתם מתחילים הפעלה בענן על acme-app/.

האיור למטה מראה באילו מהתיקיות האלה הגדרה חלה כשאתם מפעילים את Claude Code מהן. לחצו על קובץ הגדרות כדי לראות את התיקיות שהוא מגיע אליהן.

קובץ הגדרות

המחשב שלכם

המחשב של חבר צוות

הפעלה בענן

• ~/.claude/settings.json: כל פרויקט במחשב שלכם, ושום דבר במחשב של חבר הצוות או בהפעלה בענן
• acme-app/.claude/settings.json: ה-acme-app/ שלכם. הוא מגיע לעותק של חבר הצוות ולהפעלה בענן רק אם ביצעתם commit לקובץ בבקרת גרסאות. עד שתעשו זאת, זה קובץ על הדיסק שלכם כמו כל קובץ אחר, ולאף אחד אחר אין אותו
• acme-app/.claude/settings.local.json: רק ה-acme-app/ שלכם. Claude Code מוסיף אותו ל-git excludes הגלובליים שלכם בפעם הראשונה שהוא כותב את הקובץ, כך שהוא נשאר מחוץ ל-commits שלכם. אם יצרתם את הקובץ ידנית, הוסיפו אותו ל-.gitignore בעצמכם
• הגדרות מנוהלות, בין אם קובץ managed-settings.json, מדיניות MDM, או הגדרות שמנוהלות בשרת מקונסולת claude.ai: כל פרויקט בכל מחשב שהארגון שלכם פורס אליו, או שאתם נכנסים אליו עם חשבון הארגון שלכם. רק הגדרות שמנוהלות בשרת מגיעות להפעלה בענן

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

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

• מנוהל: הארגון שלכם פורס אותו. אתם לא יוצרים או עורכים אותו.
• פרויקט משותף: פרויקט שכבר משתמש ב-Claude Code עשוי להכיל קובץ כזה ב-commit. אם לא, צרו אותו ב-.claude/settings.json בתיקיית הפרויקט.
• משתמש ומקומי לפרויקט: צרו אותם בעצמכם, או תנו ל-Claude Code ליצור אותם. הוא כותב את ~/.claude/settings.json בפעם הראשונה שאתם משנים אפשרות בתפריט /config שהוא שומר בהגדרות משתמש, כמו ערכת הנושא, ואת .claude/settings.local.json בפעם הראשונה שאתם נותנים אישור קבוע בהנחיית הרשאה, כמו "Yes, and don't ask again" לפקודת Bash. כמה אפשרויות של /config, כולל Show tips, נשמרות ב-.claude/settings.local.json במקום בקובץ המשתמש.

הערה: ב-Windows, ~/.claude פירושו %USERPROFILE%\.claude. כדי לשמור את קבצי תיקיית הבית במקום אחר, הגדירו את CLAUDE_CONFIG_DIR. אז Claude Code שומר שם את ההגדרות, היסטוריית ההפעלות וה-plugins שלכם במקום זאת.

Claude Code גם שומר קובץ חמישי, ~/.claude.json, שהוא כותב לעצמו. אין צורך לערוך אותו. הוא מחזיק את פרטי החשבון שלכם, הגדרות של שרת MCP, מצב לפי פרויקט כמו החלטות אמון, ואת מפתחות התצורה הגלובליים ש-/config כותב עבורכם.

#שיתוף הגדרות עם הצוות

בצעו commit ל-.claude/settings.json כדי שכל מי שמשכפל את המאגר יקבל את אותן הרשאות, hooks ו-plugins. כל חבר צוות עדיין יכול לעקוף אותו לעצמו בקובץ .claude/settings.local.json שלו, כך שחריגים אישיים לא דורשים commit. לקובץ צוות מלא, ראו ההגדרות המשותפות של צוות.

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

#השארת הגדרות אישיות מחוץ למאגר

כדי לשנות הגדרה לעצמכם בפרויקט אחד בלי לשנות אותה לחברי הצוות, שמרו אותה ב-.claude/settings.local.json בתוך הפרויקט. Claude Code מחיל את הקובץ הזה מעל .claude/settings.json שנמצא ב-commit, כך שאם קובץ הצוות מגדיר "model": "claude-sonnet-5" ואתם רוצים Opus, שימו "model": "claude-opus-5-5" בקובץ המקומי שלכם ורק ההפעלות שלכם משתנות.

Claude Code גם כותב לקובץ הזה, שומר אותו מחוץ ל-commits שלכם, ומחיל את כללי ה-allow שלו בלי שלב האמון:

• גם Claude Code כותב אותו. כש-Claude מבקש הרשאה להריץ פקודת Bash ואתם בוחרים "Yes, and don't ask again", Claude Code שומר את אישור ההרשאה כאן ככלל allow.
• אין צורך להוסיף אותו ל-gitignore בעצמכם, אלא אם יצרתם אותו ידנית. בפעם הראשונה ש-Claude Code כותב את הקובץ במאגר git שעדיין לא מתעלם ממנו, הוא מוסיף את **/.claude/settings.local.json לקובץ ה-git excludes הגלובלי שלכם, כך שהקובץ נשאר מחוץ ל-commits שלכם בכל מאגר. הקובץ הזה הוא core.excludesFile כשתצורת git הגלובלית שלכם מגדירה אותו לנתיב מוחלט או לנתיב עם קידומת ~. אחרת זה $XDG_CONFIG_HOME/git/ignore, או ~/.config/git/ignore כש-XDG_CONFIG_HOME לא מוגדר. אם יצרתם את הקובץ ידנית ו-Claude Code עדיין לא כתב אליו, הוסיפו אותו ל-.gitignore בעצמכם.
• כללי ה-allow שלו לא ממתינים לאמון כל עוד הקובץ נשאר לא במעקב. מכיוון שהקובץ שלכם ולא של המאגר, Claude Code מחיל את כללי ה-allow שלו בלי שלב אמון בסביבת העבודה שהוא דורש עבור הקובץ שנמצא ב-commit. אם הקובץ במעקב של git, שלב האמון חל גם עליו. ראו מתי קובץ ההגדרות המקומי שלכם צריך אמון.

#איפה Claude Code שומר את הקובץ המקומי במאגר git

כש-Claude מבקש הרשאה להריץ פקודת Bash ואתם בוחרים "Yes, and don't ask again", Claude Code שומר את האישור הזה ככלל allow ב-.claude/settings.local.json. אם אתם מפעילים את Claude Code בתת-תיקייה של מאגר git, הוא קורא וכותב את הקובץ הזה בשורש המאגר ומחיל את האישור על כל המאגר. ב-worktree, הוא משתמש בקובץ שבשורש ה-checkout הראשי.

שני כללים מסייגים את מיקום השורש:

• כשהקובץ נשאר יחד עם .claude/settings.json במקום זאת: מחוץ למאגר git, כששורש המאגר הוא תיקיית הבית שלכם, ב-Windows, או כששורש המאגר או רשומת .git או .claude שלו אינם בבעלות המשתמש שלכם.
• נתיבים בקובץ לא מעוגנים בשורש המאגר: כלל הרשאה שמתחיל ב-/ או בנתיב sandbox יחסי מעוגן בתיקיית העבודה הראשית של ההפעלה במקום זאת.

לפני v2.1.211, Claude Code שמר את הקובץ בתיקיית ההתחלה. הוא עדיין קורא קובץ שגרסה קודמת השאירה שם לצד קובץ השורש. כששניהם מגדירים את אותו מפתח, הערך של השורש חל, וכללי הרשאה משני הקבצים חלים. העזר resolveSettings() של Agent SDK תמיד קורא את הקובץ מתיקיית ההתחלה.

Claude Code קורא את .claude/settings.json המשותף מתיקיית העבודה הראשית של ההפעלה, כך כדי להשתמש בקובץ שנמצא ב-commit בשורש המאגר, הפעילו את Claude Code שם. אחרי שמעבירים את ההפעלה עם /cd, Claude Code קורא את שני קבצי הפרויקט מהתיקייה החדשה במקום זאת, וממקם את הקובץ המקומי לפי אותם כללים. קריאה שלהם מהתיקייה שאליה עברתם דורשת Claude Code v2.1.246 או חדש יותר. להפעלת worktree שמתחילים מאפליקציית שולחן העבודה, ראו מה worktrees חולקים עם ה-checkout הראשי.

#בדיקה מה הארגון שלכם אוכף

אם הארגון שלכם מנהל את Claude Code, חלק מההגדרות נקבעות עבורכם ושום דבר שתשימו בקבצים שלכם לא משנה אותן. כדי לראות אילו, הריצו את /status: שורת Setting sources מציינת את המקור המנוהל שחל עליכם. הגדרות מנוהלות חלות בכל מקום שבו Claude Code רץ במחשב הזה. מה מפתח יכול לשנות מכסה זכויות ניהול מקומיות וכלים שאינם Claude Code.

הגדרות מנוהלות מגיעות אליכם דרך מנגנוני המסירה בעמוד ההגדרות המנוהלות, לרוב:

• הגדרות שמנוהלות בשרת, ש-Claude Code מביא מקונסולת הניהול של claude.ai או מ-Claude apps gateway באירוח עצמי
• מדיניות MDM או ברמת מערכת ההפעלה, וקבצי managed-settings.json בתיקיית מערכת
• מארח הטמעה כמו Claude Desktop, דרך אפשרות ה-SDK managedSettings. ראו שליטה במדיניות ממארח הטמעה

בהפעלת Cowork שרצה על המחשב שלכם באפליקציית Claude Desktop, Claude Code לא מביא הגדרות שמנוהלות בשרת מקונסולת הניהול של claude.ai, והוא קורא מדיניות שנפרסה למכשיר שלכם אלא אם תצורת Claude Desktop של הארגון מגדירה את requireCoworkFullVmSandbox. איפה ומתי מדיניות חלה מכסה את Cowork והפעלות בענן.

אם אתם המנהלים, הגדרת Claude Code לארגון שלכם מלווה את הבחירה מה לאכוף, ופריסת הגדרות מנוהלות מכסה מסירה ואיך לאשר שמדיניות בתוקף. לאזהרה שעורך ההגדרות המנוהלות בקונסולת הניהול של claude.ai יכול להציג, ראו הגדרת הגדרות שמנוהלות בשרת.

#שינוי הגדרה

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

ה-system prompt של Claude Code לא מפורסם. כדי לתת ל-Claude הוראות קבועות, השתמשו בקבצי CLAUDE.md או בדגל --append-system-prompt.

#שימוש בתפריט /config

הריצו /config בתוך Claude Code ופתחו את הלשונית Config. היא מציגה קבוצה קצרה של אפשרויות אישיות כמו ערכת נושא, מצב עורך ופלט מפורט, לא כל מפתח הגדרות. בחרו אפשרות כדי לשנות אותה. Claude Code שומר אותה בשבילכם:

• רוב האפשרויות: ~/.claude/settings.json
• כמה אפשרויות, כמו Show tips: .claude/settings.local.json
• אפשרויות התצורה הגלובלית: ~/.claude.json

כדי להגדיר אפשרות אחת בלי התפריט, העבירו key=value, למשל /config verbose=true.

[!NOTE]

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

#עריכת קובץ הגדרות

פתחו בעורך את קובץ ההגדרות של ההיקף הרצוי והוסיפו או שנו מפתח. קבצי ההגדרות הם JSON קפדני: הערת // או פסיק בסוף הם שגיאת תחביר, ו-Claude Code מדווח על הקובץ כ-Settings Error בהפעלה הבאה. לדוגמה, כדי לאפשר ל-Claude Code להריץ את פקודות ה-lint והבדיקות בלי לשאול ולמנוע ממנו קריאה של קבצי .env, הוסיפו את זה ל-~/.claude/settings.json:

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)"
    ]
  }
}

כל רשומה תחת permissions היא כלל שנותן שם לכלי ולמה שהוא רשאי לעשות. Configure permissions מסביר את התחביר. שורת $schema מצביעה על סכמת ה-JSON המפורסמת להגדרות Claude Code, שמספקת השלמה אוטומטית ואימות בשורה ב-VS Code, ב-Cursor ובכל עורך אחר שתומך בסכמת JSON. הסכמה יכולה לפגר אחרי מהדורות ה-CLI החדשות ביותר, ולכן אזהרת אימות על מפתח שתועד לאחרונה לא אומרת שהתצורה שלכם לא תקינה.

אחרי השמירה, הריצו /status בתוך Claude Code כדי לאשר שהקובץ נטען. אישור מה נטען מסביר מה שורת Setting sources מציגה ואיך מדווחים על קובץ שבור.

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

#שינוי הגדרה להפעלה אחת

כדי לנסות ערך בלי לשמור אותו, הגדירו אותו כשאתם מפעילים את Claude Code. הערך חל על אותה הפעלה וקבצי ההגדרות נשארים כפי שהיו. יש שלוש דרכים לעשות זאת:

• --settings: העבירו מפתח כ-JSON, בשורה או כנתיב לקובץ. Claude Code מחיל אותו מעל קבצי המשתמש, הפרויקט והמקומי ומתחת להגדרות מנוהלות. הוא יכול להגדיר כל מפתח שקובץ הגדרות המשתמש יכול להגדיר. הוא לא יכול להגדיר מפתחות Managed או Global config.
• דגל לאותו מפתח: לחלק מהמפתחות יש דגל משלהם, כמו --model עבור model ו---effort עבור effortLevel ו-modelSettings.
• משתנה סביבה: ייצאו את המשתנה המשויך למפתח לפני שמריצים claude, כמו ANTHROPIC_MODEL עבור model.

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

פקודות שמריצים בתוך הפעלה בדרך כלל שומרות את הבחירה: כשמשנים הגדרה ב-/config, Claude Code כותב אותה לקבצי ההגדרות, ו-/model שומר את הערך כברירת המחדל להפעלות חדשות.

אם לוחצים על s בבורר /model, Claude Code מחליף את המודל בלי לשמור אותו כברירת המחדל של המשתמש. התאמת רמת המאמץ מציין אילו בחירות /effort Claude Code שומר כברירת המחדל למודל שבשימוש ואילו חלות רק על ההפעלה הנוכחית.

לדוגמה, כדי להתחיל הפעלה אחת על Opus בלי לשנות את ברירת המחדל:

claude --settings '{"model": "claude-opus-5-5"}'

#מתי עריכות נכנסות לתוקף

Claude Code עוקב אחרי קבצי ההגדרות וטוען אותם מחדש כשהם משתנים, ולכן הוא מחיל את רוב העריכות על ההפעלה הרצה בלי הפעלה מחדש, כולל עריכות ל-permissions, ל-hooks ולעוזרי credentials כמו apiKeyHelper. Claude Code גם טוען קובץ הגדרות שיוצרים באמצע הפעלה אם התיקייה שלו הייתה קיימת כשההפעלה התחילה. עבור תיקיית .claude/ של הפרויקט, הוא טוען את הקובץ גם כשיוצרים את התיקייה באותה הפעלה.

הטעינה מחדש מכסה הגדרות משתמש, פרויקט, מקומיות ומנוהלות, ו-Claude Code מריץ את ה-hook ConfigChange עבור כל שינוי בקובץ הגדרות שהוא מזהה, לא עבור הגדרות מנוהלות שמגיעות מ-MDM או מקונסולת claude.ai. הגדרות מנוהלות שמגיעות דרך MDM או מקונסולת claude.ai מגיעות להפעלה רצה לפי לוח זמנים ולא בשמירה. טבלת המסירה מפרטת זאת לפי מקור.

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

• model: השתמשו ב-/model כדי להחליף באמצע הפעלה. לכל מודל יש מטמון prompt משלו, ולכן הבקשה הראשונה אחרי החלפה קוראת מחדש את כל השיחה בלי מטמון. ראו החלפת מודלים
• effortLevel ו-modelSettings: השתמשו ב-/effort כדי לשנות את המאמץ באמצע הפעלה

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

#אישור מה נטען

הריצו /status בתוך Claude Code כדי לראות אילו מקורות הגדרות פעילים. לשונית Status כוללת שורת Setting sources שמפרטת כל קובץ הגדרות ש-Claude Code טען להפעלה הנוכחית, כמו User settings או Project local settings. כשהגדרות מנוהלות בתוקף, רשומת ההגדרות המנוהלות מציגה בסוגריים איך הן הגיעו למכונה.

השורה מאשרת אילו קבצים Claude Code קרא. היא לא מציגה איזה קובץ סיפק כל מפתח. כדי לרשום רשומות ש-Claude Code דחה, הריצו claude doctor. עבור מודל שהגדרות פרויקט או הגדרות מנוהלות קבעו, כותרת ההפעלה מציינת את הקובץ שקבע אותו. /status ו-/config פותחים את אותה תיבת דו-שיח בלשוניות שונות, ולשונית Config אינה תצוגה של תוכן settings.json.

#תיקון קובץ הגדרות שבור

אם מקלידים JSON בשגיאה או מגדירים מפתח לערך ש-Claude Code לא מקבל, Claude Code מודיע על כך בתחילת הפעלה אינטראקטיבית. מה שמוצג תלוי בכמה מהקובץ מושפע:

• Settings Error: לקובץ משתמש, פרויקט או מקומי יש JSON לא תקין או ערך שהסכמה דוחה. בתחילת הפעלה אינטראקטיבית Claude Code מציג תיבת דו-שיח שמאפשרת לתקן את הקובץ בעזרת Claude, לצאת, או להמשיך בלי ההגדרות השבורות.
• Settings Warning: רק רשומות בודדות נכשלות, כמו כלל הרשאה פגום או שם אירוע hook לא מוכר. Claude Code מדלג על הערכים האלה ומשאיר את שאר הקובץ בתוקף.
• Managed settings: Claude Code ממשיך לאכוף את שאר הקובץ. רשומות לא תקינות בהגדרות מנוהלות מציין מה הוא משמיט ואילו מפתחות חוזרים לערך מחמיר יותר עד שמתקנים אותם. למסמך הגדרות מנוהלות שהוא לא JSON תקין, ראו לא ניתן לנתח את מסמך ההגדרות המנוהלות.
• Configuration error: לא ניתן לנתח את ~/.claude.json. הרצת claude -p יוצאת, והקובץ נשאר ללא שינוי. ראו שגיאת תצורה ב-~/.claude.json כדי לשחזר עותק קודם. Claude Code מעתיק את הקובץ השבור אל ~/.claude/backups/.claude.json.corrupted.<timestamp>, ובהפעלה אינטראקטיבית שואל אם לצאת ולתקן אותו או לאפס לתצורת ברירת המחדל. כשהקובץ ריק ואין גיבוי לשחזור, Claude Code מתחיל עם הגדרות ברירת מחדל.

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

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

#קדימות ההגדרות

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

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

לפי הסדר, קדימות גבוהה תחילה:

1. הגדרות מנוהלות: הגדרות שהארגון שלך פורס, באמצעות קובץ managed-settings.json, מדיניות MDM, או הגדרות מנוהלות בשרת מקונסולת claude.ai. שום דבר בקבצי ההגדרות שלך או ב---settings לא דורס מפתח מנוהל, ודגל כמו --model בוחר רק מבין המודלים שהארגון שלך מתיר. model מנוהל הוא ברירת מחדל התחלתית, לא נעילה. הנעילות הן availableModels ו-deniedModels. כשהארגון שלך מספק יותר ממקור מנוהל אחד, הכללים של קדימות בתוך השכבה המנוהלת אומרים מה Claude Code קורא מכל מקור.
2. שורת פקודה: JSON שאתה מעביר עם --settings <file-or-json> כשאתה מפעיל את claude, לאותה הפעלה בלבד. ראה שינוי הגדרה להפעלה אחת. מפתח שאתה קובע שם דורס את אותו מפתח בקבצי ההגדרות של הפרויקט ושל המשתמש, ומפתח שאתה משמיט שומר את הערך שלו מאותם קבצים. דגלים אחרים, כמו --model, קובעים דבר אחד להפעלה ואינם חלק מהמחסנית הזו. הרשומה של מפתח ב-מדריך ההגדרות אומרת אילו דגלים דורסים אותו.
3. הגדרות מקומיות לפרויקט (.claude/settings.local.json): ההגדרות האישיות שלך לפרויקט הזה.
4. הגדרות פרויקט משותפות (.claude/settings.json): הגדרות שהצוות שלך מכניס לבקרת המקור.
5. הגדרות משתמש (~/.claude/settings.json): ההגדרות האישיות שלך לכל פרויקט.

משתני סביבה אינם רמה במחסנית הזו. כשלתנהגות יש גם משתנה מעטפת וגם מפתח הגדרות, מה חל נקבע לכל זוג בנפרד, לא לפי רמה: ANTHROPIC_MODEL שמיוצא במעטפת שלך חל מעל מפתח model מכל קובץ, בעוד ANTHROPIC_DEFAULT_MODEL חל רק כשאף קובץ לא קובע את model. מדריך משתני הסביבה אומר לאילו מפתחות יש זוג, ובאיזה מהם Claude Code קורא תחילה. בלוק env בתוך קובץ הגדרות הוא מפתח רגיל ועוקב אחרי הרמות למעלה.

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

#רשימות מתמזגות במקום לדרוס

כשאתה קובע את אותו מפתח רשימה, כמו permissions.allow, ביותר מקובץ אחד, Claude Code משלב את הרשימות במקום לבחור אחת, כך שכל קובץ יכול להוסיף רשומות בלי להסיר את אלה של קובץ אחר. ארבעה מפתחות שמחזיקים רשימות מודלים או רשומות לפי מודל פועלים לפי כללים משלהם:

• fallbackModel הוא שרשרת מסודרת שבה למיקום יש משמעות, ולכן Claude Code לוקח את כל הערך מהקובץ בעל הקדימות הגבוהה ביותר שמגדיר אותו.
• modelPicker מחזיק רשימה מסודרת אחת של שורות ועוד דגל החלפה, ולכן Claude Code אף פעם לא ממזג שורות משני מקורות. הוא לוקח את כל הערך מהגבוה ביותר מבין הגדרות מנוהלות, --settings, והגדרות משתמש שמגדיר אותו, ומתעלם מהמפתח בהגדרות פרויקט ומקומיות. נדרש Claude Code גרסה v2.1.242 או מאוחרת יותר.
• availableModels: כשההגדרות המנוהלות ש-Claude Code מחיל מגדירות אותו, Claude Code מחיל את הרשימה הזו כפי שהיא ומתעלם מרשומות שאתה מוסיף בהגדרות משתמש, פרויקט או מקומיות, אלא אם אפליקציה שמטמיעה את Claude Code מספקת רשימת מודלים משלה. ראה חריגים לקדימות של הגדרות מנוהלות. בין מקורות מנוהלים הרשימה גם אף פעם לא מתמזגת. איך Claude Code משלב מקורות מנוהלים אומר איזו רשימה של איזה מקור חלה. בין היקפים לא מנוהלים Claude Code ממזג את המערכים כרגיל.
• modelSettings: Claude Code פותר אותו מודל אחד בכל פעם, יחד עם effortLevel. הרשומה של modelSettings מציינת איזה ערך של איזה קובץ חל על מודל.

#דוגמאות לקדימות

בזמן ש-Claude עובד, Claude Code מציג טיפ של שורה אחת מתחת לספינר, כמו "Use /config to change your default permission mode (including Plan Mode)". נניח שאתה רוצה את הטיפים האלה כבויים, אז אתה קובע את spinnerTipsEnabled ל-false ב-~/.claude/settings.json. כל תרחיש למטה הוא משהו שיכול להדליק אותם בחזרה, ומה אפשר לעשות בקשר לזה.

#הגדרות צוות דורסות הגדרות אישיות

הקובץ .claude/settings.json של הצוות שלך קובע אותו ל-true. Claude Code משתמש בערך של הפרויקט כי פרויקט משותף יושב מעל משתמש, אז אתה רואה טיפים בפרויקט הזה ובשום מקום אחר.

אפשר להחזיר את הערך שלך: הוסף "spinnerTipsEnabled": false ל-.claude/settings.local.json באותו פרויקט. מקומי לפרויקט יושב מעל פרויקט משותף, אז ההפעלות שלך שם מפסיקות להציג טיפים וההפעלות של חברי הצוות לא משתנות.

#הגדרות ארגון דורסות הכל

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

אי אפשר להחזיר את הערך שלך. הרץ /status כדי לראות איזה מקור מנוהל חל, ושאל את המנהל אם המדיניות צריכה להשתנות.

#שורת הפקודה דורסת את הקבצים שלך להפעלה אחת

התחלת את ההפעלה עם claude --settings '{"spinnerTipsEnabled": true}'. שורת פקודה יושבת מעל כל קובץ חוץ ממנוהל, אז ההפעלה הזו מציגה טיפים אף על פי שהקבצים שלך אומרים false.

אתה מקבל את הערך שלך בחזרה בהפעלה הבאה. --settings נמשך הפעלה אחת ולא כותב לאף קובץ.

#דגל או משתנה סביבה קובע את אותו דבר

לחלק מהמפתחות יש דגל שורת פקודה או משתנה סביבה שדורס את ערך ההגדרות בלי קשר לאיזה קובץ קבע אותו: ANTHROPIC_MODEL דורס את הגדרת model, ו---model דורס את שניהם להפעלה.

אם אפשר להחזיר את הערך שלך תלוי במפתח: בטל את המשתנה או הסר את הדגל, ובדוק את הרשומה של המפתח ב-מדריך ההגדרות ואת השורה של המשתנה ב-מדריך משתני הסביבה כדי לדעת באיזה מהם Claude Code משתמש.

#איתור תקלות בהגדרה שלא חלה

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

#ערך שקבעת מתעלמים ממנו

משהו אחר קובע את אותו מפתח, הקובץ לא יכול לקבוע את הערך הזה, או שהקובץ לא נטען:

• רמה גבוהה יותר קובעת אותו. קובץ הגדרות אחר, דגל --settings, או מקור מנוהל קובע את המפתח מעל שלך. ה-מחסנית אומרת איזו. דגל או משתנה סביבה יכולים גם לדרוס את המפתח בעצמם, מפתח אחר מפתח. הרשומה של המפתח ב-מדריך ההגדרות אומרת באיזה מהם Claude Code משתמש, וה-רשומת env מכסה ערך env מנוהל מול ייצוא מעטפת.

• מפתח אבטחה שומר את הערך המחמיר שלו. לכמה מפתחות Claude Code מכבד את הערך המגביל מכל קובץ, אז true של פרויקט עבור disableClaudeAiConnectors נשאר פעיל. ראה חריגים לקדימות של הגדרות מנוהלות.

• הקובץ לא יכול לקבוע את הערך הזה. הערכים auto ו-bypassPermissions של permissions.defaultMode לא נכנסים לתוקף מהגדרות פרויקט או מקומיות. קבע אותם בהגדרות משתמש או מנוהלות במקום, או העבר --permission-mode להפעלה אחת. לפני v2.1.257, bypassPermissions נכנס לתוקף מכל קובץ.

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

• הקובץ שבור. JSON לא תקין או ערך שנדחה גורמים ל-Claude Code לדלג על הקובץ או על הרשומה. ראה תיקון קובץ הגדרות שבור.

#שינוי שעשית ב-Claude Code אובד בהפעלות חדשות

כשאתה שומר בחירה להפעלות חדשות מתוך Claude Code, כמו מודל ברירת מחדל עם /model, Claude Code כותב אותה לקובץ הגדרות המשתמש שלך, ~/.claude/settings.json. אם אי אפשר לכתוב לקובץ הזה, למשל כי כלי אחר מייצר אותו או מקשר אותו לעותק לקריאה בלבד, השינוי חל על ההפעלה הנוכחית ונעלם בהפעלה הבאה. קבע את המפתח בכלי שמייצר את הקובץ, או החלף את הקובץ בקובץ שאפשר לכתוב אליו.

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

#שינוי מנוהל עדיין לא הגיע אליך

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

#מפתח שהוגש לא מגיע לחברי הצוות

שני דברים מונעים ממפתח ב-.claude/settings.json לחול על כל מי שמשכפל אותו:

• Claude Code מתעלם מהמפתח בקובץ מאגר. חפש User, local, or managed, User or managed, User, Managed, או Global config בעמודת Scope ב-אינדקס ההגדרות. המפתחות האלה אף פעם לא חלים מהקובץ המשותף, חוץ מכמה שקובץ מאגר עדיין יכול לכבות. כל אחת מהרשומות האלה אומרת זאת בשורת ה-Scope שלה. מפתחות Global config חלים רק מ-~/.claude.json.

  בתוך מפתח env, משתני ייצוא הטלמטריה גם אף פעם לא חלים מהקובץ המשותף, חוץ מכמה ערכי כיבוי. ראה משתנים ש-Claude Code מתעלם מהם ב-env.

• המפתח ממתין לאמון. כללי permissions.allow, permissions.additionalDirectories, extraKnownMarketplaces, ורוב ערכי env חלים רק אחרי שכל חבר צוות נותן אמון בתיקייה. עד אז הם עדיין רואים הנחיות ולא מקבלים תוספים משוק שהקובץ מצהיר עליו. כללי deny ו-ask חלים מיד.

#כללי הרשאות משולבים אחרת ממה שציפית

• בחרת "Yes, and don't ask again" בהנחיית הרשאה אבל עדיין מקבל הנחיה לאותו כלי. הבחירה הזו שמרה כלל allow לקובץ המקומי שלך, וכלל allow שם לא גובר על כלל ask מקובץ פרויקט או מנוהל. איך כללי הרשאות משולבים מסביר את הסדר. בהרחבת VS Code כרטיס האישור מאפשר לך לבחור את קובץ היעד, כולל הקובץ המשותף של הפרויקט, מה שמשנה את הכלל לכולם. ב-CLI, Claude Code כותב רק לקובץ המקומי שלך.
• כללי ה-allow של הארגון שלך עדיין חלים לצד שלך. זה צפוי: Claude Code ממזג את permissions.allow בין היקפים, אלא אם הארגון שלך קובע את allowManagedPermissionRulesOnly.

#חריגים לקדימות של הגדרות מנוהלות

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

אפליקציה שמריצה את Claude Code בתוכה וקובעת את CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST היא גם חריג. Claude Code לוקח את תצורת המודל של האפליקציה הזו מעל המפתחות model, fallbackModel, modelPicker, ו-modelOverrides מכל מקור מנוהל, ומעל משתני בחירת המודל בבלוק env מנוהל, כמו ANTHROPIC_MODEL ומשפחת ANTHROPIC_DEFAULT_*_MODEL. Claude Code שומר רשימת היתר availableModels מנוהלת בתוקף, אלא אם האפליקציה מספקת רשימה משלה.

#הגדרות בסשנים בענן

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

• שרשורי ענן בפרויקט: בשרשור ענן בפרויקט, אף אחד מכללי ההרשאות, מ-hooks או מ-env בקובץ .claude/settings.json של מאגר אינו חל, כמה מאגרים שלא יהיו לפרויקט. מה שהשרשורים קולטים מהמאגרים שלך מפרט במה להשתמש במקום זה.
• הגדרות פרויקט משותפות (.claude/settings.json): נקראות בסשן עם מאגר אחד מחוץ לשרשורים של פרויקט, כי הקובץ הוא חלק מהשכפול והסשן מתחיל בתוכו. בצע commit להגדרה שם כדי להחיל אותה בסשנים האלה.
• הגדרות פרויקט משותפות עם כמה מאגרים: בסביבה באירוח של Anthropic, סשן עם כמה מאגרים מתחיל מעל השכפולים וקורא רק את המפתחות enabledPlugins ו-extraKnownMarketplaces מקובץ .claude/settings.json של כל מאגר, לא כללי הרשאות, hooks, env או מפתחות אחרים. ה-marketplaces וה-plugins ששני המפתחות האלה מצהירים עליהם עדיין לא נטענים בסשן ענן. עבור סביבה באירוח עצמי, ראה אילו הגדרות של איזה מאגר חלות.
• הגדרות מקומיות של משתמש ושל פרויקט (~/.claude/settings.json ו-.claude/settings.local.json): לא נקראות. שתיהן נשארות על המחשב שלך, והקובץ המקומי אינו בשכפול.
• הגדרות מנוהלות: קובץ managed-settings.json או פרופיל MDM במכשיר שלך אינו מגיע לסשן ענן. ההגדרות שמנוהלות בשרת של הארגון שלך כן מגיעות. כיסוי משטחים מפרט אילו סשני ענן מקבלים אותן. סביבה באירוח עצמי גם קוראת את קובץ ההגדרות המנוהלות בתמונת ה-runner שלה. איך Claude Code משלב מקורות מנוהלים אומר מתי הקובץ הזה חל.
• /config: בדפדפן שלך בכתובת claude.ai/code, פותח את דף ההגדרות Code או Claude Code של claude.ai במקום שינוי ערך. כדי לשנות הגדרה עבור סשן ענן, הגדר משתנה סביבה על הסביבה. בסשן עם מאגר אחד מחוץ לשרשורים של פרויקט, אפשר במקום זה לבצע commit של המפתח בקובץ .claude/settings.json של המאגר הזה.

מה עובר מההגדרה שלך מפרט את השאר: CLAUDE.md, skills, שרתי MCP, plugins ו-credentials.

#מה הלאה

• כל ההגדרות: כל מפתח, עם המקום שבו מגדירים אותו ודוגמה
• קבצי הגדרות לדוגמה: קובץ אישי, קובץ צוות וקובץ מנוהל של ארגון
• הגדרת הרשאות: כללי allow, ask ו-deny, ומה Claude Code מריץ בלי לשאול
• משתני סביבה: המשתנים ש-Claude Code קורא ובלוק env
• ניפוי שגיאות בתצורה: כאשר הגדרה אינה חלה
• הפניה לתיקיית Claude: כל קובץ ש-Claude Code קורא, כולל subagents, שרתי MCP, plugins ו-CLAUDE.md