📘 תיעוד 130

כל ההגדרות

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

חזרה לאינדקס

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

#אינדקס ההגדרות

כל מפתח למטה מקשר לרשומה שלו. היקף מפרט את הקבצים שאפשר לשים אותו בהם: User הוא ~/.claude/settings.json, Project הוא .claude/settings.json, Local הוא .claude/settings.local.json, ו-Managed הוא מה שהארגון שלכם פורס. Any file פירושו כל הארבעה, ו-Global config פירושו ~/.claude.json.

#מודל ותשובות

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

#advisorModel

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

בדרך כלל לא עורכים את המפתח הזה ידנית. הרץ /advisor כדי לפתוח בורר שמציג את הבחירה הנוכחית, את המודלים שיכולים לייעץ, ואת No advisor. Claude Code שומר את הבחירה שלך למפתח הזה ב-~/.claude/settings.json. אם בוחרים מלקוח Remote Control או בסשן שמחובר ל-worker מרוחק, הבחירה חלה על הסשן הזה בלבד ולא משנה את המפתח.

אם החשבון שלך דורש את הסכמת usage-credits, אשר אותה קודם על ידי הרצת /model fable. עד שתעשה זאת, בחירת Fable ב-/advisor לא שומרת כלום ו-Claude Code אומר להריץ /model fable קודם.

• היקף: כל קובץ
• סוג: מחרוזת, אחד מהכינויים "fable", "opus", או "sonnet", שנפתרים לגרסת ברירת המחדל הנוכחית של Claude Code למשפחת המודל הזו, או מזהה מודל מלא כמו "claude-opus-5-5"
• ברירת מחדל: לא מוגדר, כך שה-advisor כבוי
• עקיפות לכל סשן: --advisor גובר על המפתח הזה לסשן אחד. CLAUDE_CODE_DISABLE_ADVISOR_TOOL מכבה את ה-advisor, והמפתח הזה לא יכול להדליק אותו בחזרה

{
  "advisorModel": "opus"
}

למפתח אין השפעה אצל ספקים שבהם ה-advisor לא זמין, כמו Amazon Bedrock ו-Claude Platform on AWS. "fable" דורש גישת Fable.

#alwaysThinkingEnabled

כבה חשיבה מורחבת לכל סשן על ידי הגדרת זה ל-false. החשיבה דולקת כברירת מחדל, כך ש-true לא משנה כלום. רוב האנשים מגדירים זאת דרך /config במקום לערוך את הקובץ.

במודלים שתמיד חושבים, כמו Opus 5.5, Sonnet 5.5, Haiku 5.5, ומודלי Fable, ל-false אין השפעה. אצל ספקי צד שלישי Claude Code משמיט את הפרמטר thinking במקום לכבות חשיבה, כך שמודלי adaptive-reasoning עשויים עדיין לחשוב. כשחשיבה כבויה ב-Anthropic API, Claude Code שולח effort high במקום רמה גבוהה יותר למודלים שהוא יודע שלא מקבלים את הצירוף הזה, כמו Opus 5.

• היקף: כל קובץ
• סוג: בוליאני
  • true: אין השפעה. החשיבה כבר דולקת
  • false: Claude Code מכבה חשיבה מורחבת לכל סשן
• ברירת מחדל: לא מוגדר, כך שחשיבה דולקת למודלים שתומכים בה
• עקיפות לכל סשן: MAX_THINKING_TOKENS גובר על המפתח הזה לסשן אחד: 0 מכבה חשיבה, תחת אותן מגבלות מודל וספק כמו false, וערך חיובי מדליק חשיבה גם כשהמפתח הזה הוא false. במודלי adaptive-reasoning המספר עצמו מתעלמים ממנו

{
  "alwaysThinkingEnabled": false
}

#availableModels

הגבל אילו מודלים אנשים יכולים לבחור לסשן הראשי, ל-subagents, ל-skills, ול-advisor. רשימה מנוהלת מגבילה את /model, את --model, ואת המפתח model בקבצים של המפתח עצמו. מודל שמחוץ לה אי אפשר לבחור. עם התאמת prefix כברירת מחדל, זה לבדו לא נוגע באפשרות Default. שלב אותו עם enforceAvailableModels לשם כך.

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

הדוגמה הזו מאפשרת לאנשים לבחור רק מודלי Sonnet ו-Haiku:

{
  "availableModels": ["sonnet", "haiku"]
}

רשומת מזהה מודל כמו "claude-opus-5" מתירה גם גרסאות מאוחרות יותר שמרחיבות אותו, כמו Opus 5.5. כדי לחסום אחת מהגרסאות האלה, השתמש ב-deniedModels. כדי שכל רשומת מזהה מודל תתיר רק את הגרסה שהיא מציינת, השתמש ב-availableModelsMatch. ראה הגבלת בחירת מודל. למזהים של ספקי צד שלישי, ראה נעיצת מודלים לפריסות צד שלישי.

#availableModelsMatch

בחר איך רשומות availableModels מתאימות למזהי מודל. כברירת מחדל רשומת מזהה מודל מתירה גם גרסאות מאוחרות יותר שמרחיבות אותו, כך ש-"claude-opus-5" מתיר את Opus 5.5. עם "exact", כל רשומת מזהה מודל מתירה רק את הגרסה שהיא מציינת, כך שגרסה חדשה יותר של המודל נשארת חסומה עד שתרשום אותה. דורש Claude Code v2.1.283 או מאוחר יותר.

• היקף: מנוהל. Claude Code מתעלם מהמפתח בהגדרות user, project ו-local וב---settings, עם אזהרה
• סוג: מחרוזת, אחת מאלה:
  • "prefix": רשומת מזהה מודל מתירה את הגרסה שלה וכל מזהה מודל שמרחיב אותה במקטע נוסף
  • "exact": רשומת מזהה מודל מתירה רק את הגרסה שהיא מציינת, כך ש-"claude-opus-5" מתיר את Opus 5 אבל לא את claude-opus-5-5. רשומה כמו "claude-opus-4-5" מתירה גם את מזהה המודל המתוארך של Anthropic claude-opus-4-5-20251101. כינוי משפחה כמו "opus" עדיין מתיר את כל המשפחה, ומרשומות best, opusplan ו-default מתעלמים
• ברירת מחדל: "prefix"

הדוגמה הזו מתירה את Opus 5 ואת Sonnet 5 ושום גרסה מאוחרת יותר של אף אחד מהם:

{
  "availableModels": ["claude-opus-5", "claude-sonnet-5"],
  "availableModelsMatch": "exact"
}

עם "exact", גם אפשרות Default מוגבלת למודלים שברשימה בכל פעם שהרשימה מציינת לפחות מודל אחד או משפחה. ראה חסימת מודלים או גרסאות ספציפיים.

#deniedModels

חסום מודלים ספציפיים, עם או בלי רשימת היתר availableModels וגם כשהרשימה הזו מתירה אותם. Claude Code מסתיר מודל חסום מבורר /model, ואי אפשר לבחור את המודל בכל מקום שבו availableModels נאכף. גם סשן על אפשרות Default לא מריץ מודל חסום, כפי ש-חסימת מודלים או גרסאות ספציפיים מתאר. דורש Claude Code v2.1.283 או מאוחר יותר.

• היקף: מנוהל. Claude Code מתעלם מהמפתח בהגדרות user, project ו-local וב---settings, עם אזהרה
• סוג: מערך של כינויי מודל או מזהים
  • כינוי משפחה כמו "opus" חוסם כל מודל במשפחה הזו
  • מזהה מודל כמו "claude-opus-5-5" חוסם את הגרסה הזו בכל איות, כולל מזהים מתוארכים ומזהים ייחודיים לספק
  • מזהה מודל בלי גרסת minor, כמו "claude-opus-5", חוסם גם גרסאות minor מאוחרות יותר כמו Opus 5.5. כתוב "claude-opus-5-0" כדי לחסום את Opus 5 לבדו
  • מרשומות best, opusplan ו-default מתעלמים
• ברירת מחדל: לא מוגדר, כך שאף מודל לא חסום

הדוגמה הזו מתירה מודלי Opus ו-Sonnet וחוסמת את Opus 5.5:

{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}

ראה חסימת מודלים או גרסאות ספציפיים.

#effortLevel

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

כשמריצים /effort low, medium, high, או xhigh בסשן אינטראקטיבי במכונה שלך, Claude Code שומר את הרמה למודל הפעיל תחת modelSettings במקום לכתוב את המפתח הזה. לפני v2.1.251, /effort כתב את המפתח הזה.

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

בסשן שמחובר ל-worker מרוחק, בהרצה עם -p, וב-Agent SDK, /effort חל על הסשן הזה בלבד. התאמת רמת effort מפרטת את הבחירות האינטראקטיביות שגם הן חלות על הסשן הזה בלבד. ההודעה ש-/effort מדפיס אומרת מה קרה.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מאלה:
  • "low": ההנמקה המעטה ביותר, למשימות קצרות, תחומות ורגישות להשהיה שאינן רגישות לאינטליגנציה
  • "medium": מפחית שימוש בטוקנים לעבודה רגישת עלות שיכולה לוותר על חלק מהאינטליגנציה
  • "high": מאזן שימוש בטוקנים ואינטליגנציה
  • "xhigh": הנמקה עמוקה יותר בהוצאת טוקנים גבוהה יותר
• ברירת מחדל: לא מוגדר
• עקיפות לכל סשן: --effort גובר על המפתח הזה לסשן אחד, ו-CLAUDE_CODE_EFFORT_LEVEL גובר על שניהם

{
  "effortLevel": "xhigh"
}

בקובץ הגדרות המשתמש שלך, ~/.claude/settings.json, המפתח הזה הוא הצורה הישנה ש-/effort כתב לפני ששמר רמות לכל מודל, והוא ממשיך לחול איפה שחל קודם, על Opus 5, Fable 5.1, ומודלים מוקדמים יותר. Opus 5.5 ומודלים שיצאו אחריו מתעלמים ממנו ומתחילים בברירת המחדל שלהם עד שתשמור להם רמה, ש-/effort כותב תחת modelSettings. בהגדרות project, local ומנוהלות, ועם --settings, המפתח הזה חל על כל מודל.

#enforceAvailableModels

לבורר /model יש אפשרות Default, ו-הגדרת מודל ברירת מחדל מתארת את המודל שאליו היא נפתרת. רשימת היתר availableModels מגבילה את המודלים שאפשר לציין בשם, אבל עם התאמת prefix כברירת מחדל היא לא ממפה מחדש את ברירת המחדל של סוג החשבון שלך, כך ש-Default עדיין יכול להיפתר למודל שמחוץ לרשימה. המפתח הזה סוגר את הפער הזה. דורש Claude Code v2.1.175 או מאוחר יותר.

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

לאופן שבו המפתח הזה חל על בדיקות המודל בהפעלה, ראה Amazon Bedrock ו-Agent Platform של Google Cloud.

• היקף: כל קובץ
• סוג: בוליאני
  • true: כש-Default היה נפתר למודל שמחוץ ל-availableModels, Claude Code פותר אותו למודל הזמין הראשון ברשימה
  • false: המפתח הזה לא משנה איך Default נפתר
• ברירת מחדל: false

הדוגמה הזו מגבילה בחירות בשם למודלי Sonnet ו-Haiku וגורמת ל-Default להיפתר לראשון מביניהם שזמין:

{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}

למפתח הזה אין השפעה כש-availableModels לא מוגדר או ריק. ראה אכיפת רשימת ההיתר למודל Default. דורש Claude Code v2.1.175 או מאוחר יותר.

#fallbackModel

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

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

• היקף: כל קובץ
• סוג: מערך של כינויי מודל או מזהים. "default" מתרחב למודל ברירת המחדל
• ברירת מחדל: לא מוגדר, כך שבקשה שנכשלה לא מנוסה שוב על מודל אחר
• עקיפות לכל סשן: --fallback-model גובר על המפתח הזה לסשן אחד

הדוגמה הזו מנסה קודם את Sonnet 5, ואז את Haiku 4.5, כשהמודל הראשי שלך נכשל:

{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

בשונה מרוב הגדרות המערך, המפתח הזה לא מתמזג בין קבצי הגדרות: הקובץ בעל העדיפות הגבוהה ביותר שמגדיר אותו מספק את כל השרשרת. אם קובץ הפרויקט שלך מגדיר ["claude-sonnet-5"] וקובץ המשתמש שלך מגדיר ["claude-haiku-4-5"], השרשרת היא ["claude-sonnet-5"] בלבד. Claude Code שומר לכל היותר שלושה מודלים מותרים נפרדים מהרשימה ומתעלם מהשאר. ראה שרשראות מודל גיבוי.

#fastMode

הפעל fast mode לסשנים שבהם הוא זמין, לעבודה אינטראקטיבית כמו איטרציה מהירה או ניפוי שגיאות חי שבו רוצים מהירות בעלות גבוהה יותר לכל טוקן. בדרך כלל לא עורכים את המפתח הזה ידנית: הרצת /fast כותבת fastMode: true ל-~/.claude/settings.json, והרצה נוספת כדי לכבות את fast mode מסירה את המפתח. fast mode רץ רק על Opus 5.5, Opus 5, ו-Opus 4.8: הפעלה ממודל אחר מעבירה אותך ל-Opus, ומעבר למודל לא נתמך מכבה אותו. ראה החלפת מודלים בזמן ש-fast mode דולק.

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מדליק את fast mode לסשנים שבהם הוא זמין
  • false: fast mode נשאר כבוי
• ברירת מחדל: לא מוגדר, כך ש-fast mode כבוי
• עקיפות לכל סשן: CLAUDE_CODE_DISABLE_FAST_MODE מכבה את fast mode לסשן אחד, והמפתח הזה לא יכול להדליק אותו בחזרה

{
  "fastMode": true
}

#fastModePerSessionOptIn

בדרך כלל, הרצת /fast שומרת את fastMode להגדרות המשתמש של אדם, כך ש-fast mode דולק בתחילת כל סשן מאוחר יותר. הגדר את המפתח הזה ל-true כדי לעצור את זה: fastMode: true שמור כבר לא מדליק את fast mode בתחילת סשן, וכל אדם צריך להריץ /fast בכל סשן שבו הוא רוצה אותו. Claude Code משאיר את מפתח fastMode בקובץ שלהם, כך שכיבוי המפתח הזה מחזיר את ההתנהגות הישנה.

בעלים בתוכניות Team או Enterprise יכולים לפרוס אותו לכל הארגון דרך הגדרות מנוהלות בשרת. כשהגדרות מנוהלות מגדירות את המפתח, /fast on נדחה מחוץ לסשני טרמינל אינטראקטיביים ומדווח שהארגון שלך השבית את fast mode. זה מכסה מצב לא אינטראקטיבי, את הרחבת VS Code, וסשני ענן.

• היקף: כל קובץ
• סוג: בוליאני
  • true: fastMode: true שמור כבר לא מדליק את fast mode בתחילת סשן, כך שכל אדם מריץ /fast בכל סשן שבו הוא רוצה אותו. fastMode: true שהועבר עם --settings עדיין נספר לסשן הזה, אלא אם הגדרות מנוהלות הגדירו את המפתח הזה
  • false: fastMode: true שמור מדליק את fast mode בתחילת כל סשן מאוחר יותר
• ברירת מחדל: false

{
  "fastModePerSessionOptIn": true
}

ראה דרישת הצטרפות לכל סשן.

#language

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

• היקף: כל קובץ
• סוג: מחרוזת, כל שם שפה, כגון "japanese", "spanish", או "french"; Claude Code לא מאמת אותו
• ברירת מחדל: לא מוגדר; כותרות הסשן תואמות אז את שפת השיחה

{
  "language": "japanese"
}

#maxEffortLevel

הגבל את רמת המאמץ שסשן יכול להשתמש בה, והשאר רמות נמוכות יותר זמינות. כל רמה גבוהה יותר רצה במגבלה במקום זאת, כולל רמה מ-/effort, מבורר /model, מ---effort, מ-CLAUDE_CODE_EFFORT_LEVEL, מ-frontmatter של effort של skill או subagent, או מברירת המחדל של המודל עצמו. Claude Code מחיל את המגבלה בעצמו לפני כל בקשה, ולכן היא נשמרת בכל ספק, כולל Amazon Bedrock, Agent Platform של Google Cloud, ו-Microsoft Foundry. נדרש Claude Code v2.1.267 או מאוחר יותר.

• היקף: כל קובץ. פרוס אותו בהגדרות מנוהלות כדי לאכוף אותו עבור ארגון. כשכמה היקפים קובעים מגבלה, הנמוכה ביותר חלה, ולכן מגבלה שנקבעה בהיקף אחד לא ניתנת להעלאה מהיקף אחר
• סוג: מחרוזת, אחת מ-"low", "medium", "high", "xhigh", או "max". ערך "max" לא קובע מגבלה
• ברירת מחדל: לא מוגדר, ולכן לא חלה מגבלה
• מגבלות לכל מודל: הוסף maxEffortLevel לרשומת modelSettings של מודל. הרשומה הזו מחליפה את המפתח הזה עבור המודל רק בתוך מקור ההגדרות שמגדיר את שניהם, כגון הגדרות המשתמש שלך או מקור מנוהל אחד. קבע שם "max" כדי לפטור את המודל מהמגבלה של אותו מקור; Claude Code עדיין מחיל מגבלות ממקורות אחרים

דוגמה זו מגבילה כל מודל ל-medium ופוטרת את Sonnet 4.6:

{
  "maxEffortLevel": "medium",
  "modelSettings": {
    "claude-sonnet-4-6": {
      "maxEffortLevel": "max"
    }
  }
}

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

#model

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

• היקף: כל קובץ
• סוג: מחרוזת, כינוי מודל או מזהה מודל מלא
• ברירת מחדל: לא מוגדר, ולכן Claude Code משתמש במודל ברירת המחדל של החשבון שלך
• עקיפות לכל סשן: --model מקבל קדימות על פני ANTHROPIC_MODEL, ושניהם מקבלים קדימות על פני המפתח הזה לסשן אחד, כולל על פני model מנוהל; רשימת availableModels עדיין חלה על הבחירה

{
  "model": "claude-sonnet-5"
}

ערך כאן גובר על ANTHROPIC_DEFAULT_MODEL, ש-Claude Code משתמש בו רק כששום דבר אחר לא בוחר מודל.

#modelOverrides

מפה מזהי מודל של Anthropic למזהי מודל ספציפיים לספק, כגון ARN של פרופיל הסקה של Amazon Bedrock. כל רשומה בבורר המודלים משתמשת אז בערך הממופה שלה בקריאה ל-API של הספק. מנהלי מערכת משתמשים בזה ב-Amazon Bedrock, Agent Platform של Google Cloud, ו-Microsoft Foundry כדי לנתב כל גרסת מודל לפרופיל הסקה, שם גרסה או פריסה ספציפיים, לצורך ממשל, הקצאת עלויות או ניתוב אזורי.

• היקף: כל קובץ
• סוג: אובייקט שממפה מזהה מודל למזהה מודל של ספק
• ברירת מחדל: לא מוגדר

דוגמה זו מנתבת כל קריאה עבור Opus 4.6 לפרופיל ההסקה הנקוב של Bedrock:

{
  "modelOverrides": {
    "claude-opus-4-6": "arn:aws:bedrock:us-east-1:123456789012:inference-profile/example"
  }
}

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

#modelPicker

פרט את המודלים שבורר /model מציע, בסדר שבו אתה כותב אותם ותחת תוויות שאתה בוחר, כדי שהבורר יציג את המודלים שהארגון שלך מריץ, אחרי המערך המובנה או במקומו. ה-model של כל שורה נלקח כלשונו, ולכן הוא מקבל כל מה ש---model מקבל: כינוי כגון opus, מזהה מודל של Anthropic, או מזהה בפורמט ספק עבור Amazon Bedrock, Agent Platform של Google Cloud, Microsoft Foundry, או שער LLM. נדרש Claude Code v2.1.242 או מאוחר יותר.

• היקף: משתמש או מנוהל. Claude Code קורא את המפתח מהגדרות מנוהלות, מ---settings ומהגדרות משתמש, ומתעלם ממנו בהגדרות פרויקט ומקומיות כדי שמאגר שאתה משכפל לא יוכל לתייג מחדש את הבורר. הגבוה מבין שלושת אלה שמגדיר את המפתח מספק את כל המערך, ו-Claude Code לעולם לא משלב מערכים משני מקורות.
• סוג: אובייקט עם מערך options של שורות וערך בוליאני אופציונלי replaceBuiltInOptions
• ברירת מחדל: לא מוגדר, ולכן הבורר מציג את המערך המובנה

דוגמה זו מוסיפה שתי פריסות Bedrock אחרי המערך המובנה, תחת שמות שהצוות שלך מזהה:

{
  "modelPicker": {
    "options": [
      { "model": "us.anthropic.claude-opus-4-8", "label": "Opus (production)" },
      {
        "model": "us.anthropic.claude-sonnet-4-6",
        "label": "Sonnet (production)",
        "description": "Day-to-day work"
      }
    ]
  }
}

#שדות עבור modelPicker

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

רשומה ב-options יכולה גם לשאת מחרוזת behavesAs אופציונלית לצד ה-model שלה, מה שדורש v2.1.257 או מאוחר יותר. קבע אותה למזהה של מודל שגרסת Claude Code שלך כבר מכירה, כגון claude-opus-4-8, ברשומה שה-model שלה חדש יותר מהגרסה שלך. Claude Code מחיל אז את היכולות וברירות המחדל של המאמץ של המודל המוכר הזה על הרשומה במקום להתייחס למודל שלה כלא מוכר. התווית של הרשומה ומזהה המודל ש-Claude Code שולח בבקשות לא משתנים.

כש-replaceBuiltInOptions פועל, Claude Code מסתיר כל שורה אחרת: המערך המובנה, השורות שהוא מוסיף עבור רשומות availableModels, המודלים ש-גילוי שער מצא, ו-ANTHROPIC_CUSTOM_MODEL_OPTION. כשהוא כבוי, Claude Code מדלג על מודל ברשימה שהמערך המובנה כבר מכסה. תווית משנה את מה שהבורר מציג, לא איזה מודל Claude Code מריץ.

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

• נשמטת: שורה ש-Claude Code לא יכול לשרת, כגון מודל שיצא משימוש או מודל שלארגון שלך אין גישה אליו
• מאפירה: שורה שעדיין אי אפשר לבחור, מוצגת עם הסיבה
• אף שורה לא שורדת: Claude Code שומר את המערך המובנה, מסונן לפי רשימת ההיתר כרגיל

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

#modelPricing

דווח על הוצאה לפי התעריפים שהארגון שלך משלם במקום מחיר המחירון. קבע אותו כשלארגון שלך יש תעריפים חוזיים, כדי שנתוני הדולרים שמפתחים רואים יתאימו לחשבון שלך. Claude Code מחיל את התעריפים ב-/usage, ב-שורת הסטטוס, ב-total_cost_usd של Agent SDK, במגבלת --max-budget-usd, ובמדד ובעצם העלות של OpenTelemetry. אתה מספק את התעריפים: Claude Code לא קורא אותם מהחוזה שלך או מ-Claude Console. נדרש Claude Code v2.1.242 או מאוחר יותר.

• היקף: מנוהל. פרוס את המפתח דרך הגדרות מנוהלות שרת, מדיניות MDM, קובץ managed-settings.json, או עוזר מדיניות. Claude Code מתעלם ממנו בהגדרות משתמש, פרויקט ומקומיות, ב---settings, וב-Windows ב-רישום HKCU שניתן לכתיבה על ידי המשתמש. עם הגדרות מנוהלות שרת, כל סשן מדווח על עלויות במחיר מחירון עד ש-שליפת ההגדרות של אותו סשן אישרה את ההגדרה. יישום מארח שמשבץ את Claude Code ומגדיר CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST יכול לספק טבלה משלו דרך אפשרות ה-SDK managedSettings, ש-Claude Code משתמש בה רק כשאף מקור מנוהל לא מגדיר את המפתח ורק ב-Claude Code v2.1.246 או מאוחר יותר.
• סוג: אובייקט עם multiplier אופציונלי ומפת overrides אופציונלית
• ברירת מחדל: לא מוגדר, ולכן Claude Code מדווח על מחיר מחירון אלא אם יישום מארח מספק טבלה

קבע multiplier לבד להנחה או לתוספת מחיר אחידה, overrides לבד לתעריפים לכל מודל, או את שניהם.

דוגמה זו קובעת תעריפים חוזיים עבור Sonnet 4.6 ואז מפחיתה כל נתון, כולל שורת Sonnet, ב-15%:

{
  "modelPricing": {
    "multiplier": 0.85,
    "overrides": {
      "claude-sonnet-4-6": {
        "input": 2.4,
        "output": 12,
        "cacheRead": 0.24,
        "cacheWrite": 3
      }
    }
  }
}

קבע multiplier מעל 1, עד 10, כדי לייקר כל נתון. תוספת מחיר דורשת Claude Code v2.1.271 או מאוחר יותר. גרסאות מוקדמות יותר מתעלמות מ-multiplier מעל 1 עם אזהרה ושומרות את שאר ההגדרה.

לשלבים, כולל איך לאשר שהתעריפים בתוקף, ראה דיווח הוצאה לפי התעריפים החוזיים שלך.

#שדות עבור modelPricing

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

#לאילו מודלים שורת modelPricing חלה

Claude Code מחליט לאילו מודלים שורה חלה לפי המפתח של השורה:

• מזהה של מודל מובנה: מפתח ש-Claude Code עצמו משתמש בו עבור מודל מובנה, בין אם המפתח הוא המזהה של המודל עצמו, כגון claude-sonnet-4-6, ובין אם מזהה Bedrock, Agent Platform או Foundry שלו. Claude Code מחיל את השורה על כל מזהה snapshot מתוארך ועל כל מזהה ספציפי לספק של המודל הזה.
• כל מפתח אחר: מפתח שאינו מזהה של מודל מובנה, כגון כינוי מודל של שער. Claude Code מחיל את השורה על המזהה האחד הזה בלבד. כשמזהה מודל תואם בדיוק לאחד מהמפתחות שלך וגם נופל תחת שורה שהמפתח שלה הוא מזהה של מודל מובנה, Claude Code משתמש בהתאמה המדויקת.
• פרופיל הסקה של יישום Bedrock: אחרי ש-Claude Code פתר את הפרופיל למודל שהוא מנתב אליו, דרך מפת modelOverrides שלך או חיפוש bedrock:GetInferenceProfile, Claude Code מחיל את השורה של המודל הזה על הפרופיל.

#modelSettings

שמור רמת מאמץ עבור כל מודל שאתה משתמש בו. נדרש Claude Code v2.1.251 או מאוחר יותר.

בסשן אינטראקטיבי במכונה שלך, כשאתה שומר low, medium, high או xhigh כברירת המחדל שלך עם /effort או עם מחוון המאמץ של בורר /model, Claude Code כותב את הרמה הזו כאן תחת המודל שאתה משתמש בו, ולכן לעתים רחוקות אתה עורך את המפתח הזה בעצמך. כשאתה בוחר אחת מהרמות האלה ב-בורר המודלים של הרחבת VS Code, Claude Code שומר אותה כאן באותו אופן. רשומת effortLevel מפרטת את הסשנים שבהם /effort חל על הסשן הזה בלבד.

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

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

כדי להגביל את המאמץ של מודל אחד במקום לקבוע את הרמה שלו, הוסף שדה maxEffortLevel לרשומה של המודל הזה. השדה דורש Claude Code v2.1.267 או מאוחר יותר.

• היקף: כל קובץ
• סוג: אובייקט שממפה שם מודל לאובייקט עם כל אחד מהשדות האלה:
  • effortLevel: אחד מ-"low", "medium", "high" או "xhigh"
  • maxEffortLevel: רמת המאמץ הגבוהה ביותר שהמודל רשאי לרוץ בה
  • autoCompactWindow: מספר טוקנים מ-100000 עד 1000000, או "auto" עבור החלון שכוונן עבור המודל. /autocompact שומר כאן. עבור המודל הזה, הערך מקבל קדימות על פני autoCompactWindow ברמה העליונה באותו קובץ הגדרות. נדרש Claude Code v2.1.288 או מאוחר יותר
• ברירת מחדל: לא מוגדר

Claude Code כותב כל רשומה תחת השם הקנוני של המודל, כגון claude-opus-5-5, ומתאים את הכינוי של המודל הזה, מזהים עם סיומת תאריך, [1m], ומזהים ספציפיים לספק מוכרים לאותה רשומה.

דוגמה זו שומרת את Opus 5.5 ב-high בעוד מודלים אחרים משתמשים ברמות השמורות או ברירות המחדל שלהם:

{
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}

הרץ /effort auto כדי לנקות את הרמה השמורה שלך עבור המודל שאתה משתמש בו. Claude Code משאיר את שאר הרשומות וכל effortLevel ברמה העליונה במקומם.

#outputStyle

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

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

• היקף: כל קובץ
• סוג: מחרוזת, השם של סגנון פלט מובנה או מותאם
• ברירת מחדל: לא מוגדר, ולכן Claude Code משתמש בסגנון ברירת המחדל

דוגמה זו בוחרת את סגנון Explanatory המובנה, שמוסיף תובנות לימודיות בין משימות:

{
  "outputStyle": "Explanatory"
}

#promptCacheTtl

בחרו כמה זמן מטמון ההנחיות מחזיק את השיחה הראשית. המפתח הזה חל על התורות האינטראקטיביות שלכם, על -p ועל תורות Agent SDK, יחד עם העוזרים ש-Claude Code מריץ בתוך השורה איתם. משך החיים של שעה שומר את המטמון חם לאורך הפסקות ארוכות יותר, וה-API מחייב כל כתיבה למטמון בתעריף גבוה יותר מאשר במשך החיים של חמש דקות. נדרש Claude Code בגרסה v2.1.242 או חדשה יותר.

• היקף: Any file
• סוג: מחרוזת, אחת מאלה:
  • "5m": המטמון נשמר לחמש דקות
  • "1h": המטמון נשמר לשעה
• ברירת מחדל: לא מוגדר, כך שכל בקשה של השיחה הראשית מקבלת את משך החיים המוגדר לה כברירת מחדל
• עקיפות לכל סשן: FORCE_PROMPT_CACHING_5M גובר על כל השאר, אחר כך CLAUDE_CODE_PROMPT_CACHE_TTL, אחר כך המפתח הזה, ואחרון ENABLE_PROMPT_CACHING_1H

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

{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}

לעלות של כל משך חיים, ראו Cache lifetime.

#showThinkingSummaries

ראו סיכומים של חשיבה מורחבת של Claude בסשנים אינטראקטיביים. הגדירו אותו אם אתם רוצים את הסיכומים המלאים כשאתם מרחיבים חשיבה עם Ctrl+O. כשהוא לא מוגדר או false, ה-API של Anthropic מעמעם בלוקי חשיבה ו-Claude Code מציג תצוגה מקופלת.

• היקף: Any file
• סוג: Boolean
  • true: אתם רואים סיכומי חשיבה מלאים כשאתם מרחיבים חשיבה עם Ctrl+O
  • false: ה-API של Anthropic מעמעם בלוקי חשיבה ו-Claude Code מציג תצוגה מקופלת
• ברירת מחדל: false

{
  "showThinkingSummaries": true
}

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

#subagentPromptCacheTtl

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

• היקף: Any file
• סוג: מחרוזת, אחת מאלה:
  • "5m": המטמון נשמר לחמש דקות
  • "1h": המטמון נשמר לשעה
• ברירת מחדל: לא מוגדר, כך שכל אחת מהבקשות האלה מקבלת את משך החיים המוגדר לה כברירת מחדל
• עקיפות לכל סשן: FORCE_PROMPT_CACHING_5M גובר על כל השאר, אחר כך CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL, אחר כך המפתח הזה, ואחר כך ENABLE_PROMPT_CACHING_1H, שמבקש את משך החיים של שעה בכל בקשה. לגבי המיקום של ערך frontmatter של סוכן משנה עצמו, ראו Choose the TTL yourself

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

{
  "subagentPromptCacheTtl": "1h"
}

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

#switchModelsOnFlag

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

• היקף: Any file. מופיע ב-/config בתור Switch models when a message is flagged, עם האפשרויות Switch automatically ו-Ask each time.
• סוג: Boolean
  • true: Claude Code עובר למודל הגיבוי וממשיך
  • false: בסשן אינטראקטיבי Claude Code עוצר כדי שתוכלו לבחור בין מעבר לעריכת ההנחיה. במקום שבו אי אפשר להציג תיבת דו שיח, כמו הרצה עם -p, הבקשה המסומנת מסתיימת כשגיאה
• ברירת מחדל: לא מוגדר. Claude Code עובר אוטומטית, אם כי הוא עשוי לשאול קודם בסשן אינטראקטיבי

{
  "switchModelsOnFlag": false
}

ראו Ask before switching.

#ultracode

התחילו סשנים עם ultracode מופעל. כשהוא מופעל, Claude מתכנן זרימת עבודה לכל משימה מהותית במקום לחכות שתבקשו. Claude מתכנן זרימות עבודה רק כשזרימות עבודה דינמיות מופעלות עבורכם והמודל שלכם תומך במאמץ xhigh. המפתח לא משנה את רמת המאמץ של הסשן: ultracode רץ בכל רמה שהסשן משתמש בה. Claude Code קורא את המפתח הזה אבל אף פעם לא כותב אותו: /effort ultracode מפעיל את ultracode לסשן הנוכחי בלבד.

• היקף: Any file
• סוג: Boolean
  • true: סשנים מתחילים עם ultracode מופעל כשזרימות עבודה דינמיות מופעלות עבורכם והמודל שלכם תומך ב-xhigh
  • false: סשנים מתחילים עם ultracode כבוי
• ברירת מחדל: לא מוגדר, כך ש-ultracode כבוי
• עקיפות לכל סשן: /effort ultracode מפעיל את ultracode לסשן אחד בלי המפתח הזה, ו-/effort ultracode off מכבה אותו לסשן אחד כשהמפתח הזה הוא true. הדגל --effort ultracode גם מפעיל אותו לסשן אחד, במאמץ xhigh

{
  "ultracode": true
}

רמת המאמץ של הסשן מגיעה מ-effortLevel, מ-modelSettings וממקורות המאמץ האחרים, ותקרת מאמץ כמו maxEffortLevel מנמיכה את הרמה הזו בלי לכבות את ultracode. זה והצורה /effort ultracode off דורשים Claude Code בגרסה v2.1.284 או חדשה יותר. לפני v2.1.284, ultracode: true הריץ את הסשן במאמץ xhigh, ותקרת מאמץ מתחת ל-xhigh השאירה את ultracode כבוי. בקשת בקרה apply_flag_settings של Agent SDK גם מקבלת את המפתח.

#הגדרות הרשאות

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

#allowManagedPermissionRulesOnly

הפכו את ההגדרות המנוהלות למקור ההגדרות היחיד של כללי הרשאה. Claude Code אז מתעלם מכללי allow, ask ו-deny בקבצי משתמש, פרויקט, מקומי ו---settings, מתעלם מ---allowedTools, מסתיר את אפשרויות האפשר-תמיד בהנחיות הרשאה, ומפסיק לשמור כללים חדשים.

כשהגדרות הורה ממארח מטמיע חלות, Claude Code מתייחס אליהן כחלק מהשכבה המנוהלת. הוא משמיט את כללי ה-allow ואת additionalDirectories שלהן, ושומר את כללי ה-deny וה-ask שלהן חוץ מכללי Read ו-Edit שהתבנית שלהם מתחילה ב-!. מארח לא יכול לחלץ נתיבים מתוך הכללים המנוהלים עם כלל !, בין שהגדרתם את המפתח הזה ובין שלא.

כללי --disallowedTools וכללי ה-deny וה-ask של הסשן הנוכחי עדיין חלים, כולל אחרי ש-Claude Code טוען מחדש הגדרות באמצע הסשן. הם רק מגבילים, כך שהם לא יכולים להרחיב את מה שהכללים המנוהלים מעניקים. לפני v2.1.257, Claude Code השמיט את כללי שורת הפקודה והסשן האלה בטעינה מחדש הראשונה של ההגדרות.

לגבי מה שתבנית ! בכלל --disallowedTools או בכלל סשן יכולה לחלץ, ראו Read and Edit rules.

כשאתם מגדירים את המפתח הזה, Claude Code בגרסה v2.1.282 או חדשה יותר גם מתעלם מ-frontmatter של allowed-tools במיומנויות ובקבצי .claude/commands/ מהמקורות האלה:

• ספריית .claude/ של מאגר
• ספריות ~/.claude/skills/ ו-~/.claude/commands/ שלכם, כולל מיומנויות שמסונכרנות מ-claude.ai
• ספריית --add-dir
• תוספים שמוצהרים עם מניפסט .claude-plugin בתוך ~/.claude/skills/ או .claude/skills/ של הפרויקט
• תוספים שנטענים לסשן אחד בלבד, שהמזהים שלהם מסתיימים ב-@inline, כשכל אלה מתקיימים:
  • הסשן הוא סשן Code או סשן Cowork, שאינו סשן ענן, שעבורו אפליקציית Claude Desktop עצמה מפעילה את Claude Code
  • ההגדרות המנוהלות שלכם מגדירות את המפתח, לא רק הגדרות הורה של מארח מטמיע
  • הסשן מריץ Claude Code בגרסה v2.1.305 או חדשה יותר

מיומנויות מהגדרות מנוהלות ומיומנויות ארוזות שומרות את ה-allowed-tools שלהן. תוספי @inline מחוץ לסשני Desktop האלה שומרים את שלהם גם, חוץ מאחד בשם anthropic-skills. ה-disallowed-tools של מיומנות עדיין חל. למה שמפתח רואה כש-Claude Code מתעלם מהשדה, ראו When only managed permission rules apply.

• היקף: Managed
• סוג: Boolean
  • true: ההגדרות המנוהלות הופכות למקור ההגדרות היחיד של כללי הרשאה
  • false: Claude Code מחיל כללי הרשאה מקבצי משתמש, פרויקט, מקומי ו---settings בנוסף למנוהלים
• ברירת מחדל: לא מוגדר, כך ש-Claude Code מחיל כללי הרשאה מהגדרות משתמש, פרויקט ומקומי ומ---settings, בנוסף למנוהלים

{
  "allowManagedPermissionRulesOnly": true
}

המפתח הזה לא נועל את רשימת ההיתר של שרתי MCP. לשם כך, הגדירו allowManagedMcpServersOnly. ראו Managed-only settings.

#autoMode

הוסיפו כללים משלכם למה שהמסווג של מצב אוטומטי חוסם ומאפשר. השתמשו בו כדי לומר למסווג אילו מאגרים, דליים ודומיינים הארגון שלכם סומך עליהם, כך שהוא מפסיק לחסום פעולות פנימיות שגרתיות. המסווג מגיע עם כללי allow ו-deny מובנים. כללו את המחרוזת המילולית "$defaults" במערך כדי לשמור את הכללים המובנים האלה במיקום הזה ולהוסיף את שלכם סביבם. השמיטו אותה כדי להחליף אותם בשלכם.

• היקף: User or managed
• סוג: אובייקט עם מערכי environment, allow, soft_deny ו-hard_deny של כללי פרוזה, ועוד ה-Boolean classifyAllShell
• ברירת מחדל: לא מוגדר, כך שהמסווג משתמש רק בכללים המובנים שלו

הדוגמה הזו שומרת את כללי ה-soft_deny המובנים, דרך "$defaults", ומוסיפה עוד אחד שחוסם את terraform apply:

{
  "autoMode": {
    "soft_deny": ["$defaults", "Never run terraform apply"]
  }
}

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

#autoMode.classifyAllShell

שלחו כל פקודת Bash ו-PowerShell דרך מסווג המצב האוטומטי בזמן שמצב אוטומטי פעיל. כברירת מחדל, מצב אוטומטי משעה רק כללי allow שיכולים להריץ קוד שרירותי: כללים לכל הכלי וכללי תו כללי כמו Bash(*), וקידומות של מפרש או מעטפת מעטפת כמו Bash(python *). פקודה שכל כלל allow אחר תואם לה, כמו Bash(npm test), מדלגת על המסווג אלא אם היא נושאת דומיינים מותרים לכל פקודה. כשהיא מדלגת, ארגומנט הרסני שהקידומת של הכלל לא צפתה יכול לעבור בלי להיראות. הגדרת המפתח הזה משעה כל כלל allow של מעטפת לסשן כדי שהמסווג יראה כל פקודה. נדרש Claude Code בגרסה v2.1.193 או חדשה יותר.

• היקף: User or managed. נקרא בכל מקום שבו autoMode נקרא.
• סוג: Boolean
  • true: בזמן שמצב אוטומטי פעיל, Claude Code שולח כל פקודת Bash ו-PowerShell דרך המסווג ומשעה את כללי ה-allow של המעטפת שלכם. מחוץ למצב אוטומטי הכללים עדיין חלים
  • false: מצב אוטומטי משעה רק כללי allow שיכולים להריץ קוד שרירותי, כמו Bash(*) ו-Bash(python *). פקודה שכל כלל allow אחר תואם לה מדלגת על המסווג אלא אם היא נושאת דומיינים מותרים לכל פקודה, וכל פקודת מעטפת אחרת עוברת דרכו
• ברירת מחדל: false

{
  "autoMode": {
    "classifyAllShell": true
  }
}

ראו Route all shell commands through the classifier.

#disableAutoMode

הסירו את מצב אוטומטי ממחזור Shift+Tab. כל סשן שהיה מתחיל במצב אוטומטי אחרת, בין מ---permission-mode auto, מקובץ הגדרות, או מברירת המחדל המובנית, מתחיל ב-default במקום. מנהלים מגדירים אותו בהגדרות מנוהלות כדי למנוע ממפתחים בארגון שלהם להשתמש במצב אוטומטי.

• היקף: Any file. הכי שימושי בהגדרות מנוהלות, שבהן משתמשים לא יכולים לעקוף אותו. מתקבל גם תחת permissions בתור permissions.disableAutoMode.
• סוג: המחרוזת "disable"
• ברירת מחדל: לא מוגדר

{
  "disableAutoMode": "disable"
}

#permissions

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

• היקף: Any file
• סוג: אובייקט עם allow, ask, deny, additionalDirectories, blockReadsOutsideWorkingDirectories, blockWritesOutsideWorkingDirectories, defaultMode, disableBypassPermissionsMode ו-disableAutoMode
• ברירת מחדל: לא מוגדר

הדוגמה הזו מאשרת פקודות npm run בלי לשאול, מבקשת אישור לפני git push, חוסמת קריאות של .env, ומתחילה סשנים ב-acceptEdits:

{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)"],
    "defaultMode": "acceptEdits"
  }
}

שלושת מערכי הכללים חולקים תחביר אחד. ראו Permission rule syntax תחת permissions.allow. לאופן שבו כללי הרשאה מקבצים שונים משתלבים, ראו how permission rules merge across scopes. לאופן שבו מפתחות הגדרות בכלל משתלבים, ראו Settings precedence במדריך ההגדרות.

#useAutoModeDuringPlan

בחרו אם Claude Code משתמש במסווג של מצב אוטומטי כדי לבדוק פקודות מעטפת במצב תכנון. עם ברירת המחדל true, המסווג בודק כל פקודה במהלך התכנון כשמצב אוטומטי זמין ואתם לא רואים בקשה, מלבד הסרות בנתיב קריטי. הגדירו false כדי לקבל בקשת הרשאה לכל פקודה מחוץ לקבוצת הקריאה בלבד המובנית. מופיע ב-/config בתור Use auto mode during plan.

• היקף: משתמש, מקומי או מנוהל. מאגר לא יכול לכבות את זה בשבילכם.
  • ערך false בכל אחד מהקבצים האלה או ב---settings מכבה את זה, אלא אם אתם משאירים את קובץ המשתמש או את הקובץ המקומי בחוץ עם אפשרות כמו --setting-sources. התעלמות מקובץ שהושאר בחוץ דורשת Claude Code v2.1.314 או מאוחר יותר
• סוג: Boolean
  • true: כמו ערך לא מוגדר. כשמצב אוטומטי זמין, המסווג בודק פקודות מעטפת במהלך התכנון
  • false: אתם מקבלים בקשת הרשאה לכל פקודה מחוץ לקבוצת הקריאה בלבד המובנית
• ברירת מחדל: true

settings.json

{
  "useAutoModeDuringPlan": false
}

#permissions.allow

רשמו את שימושי הכלים ש-Claude Code מאשר בלי לשאול אתכם. בכלל MCP, * יכול להופיע רק בשם הכלי אחרי הקידומת mcp__<server>__, כמו mcp__github__get_*. הוא לא יכול להופיע בשם השרת.

• היקף: כל קובץ
• סוג: מערך של מחרוזות כללי הרשאה
• ברירת מחדל: לא מוגדר
• עקיפות לכל סשן: --allowedTools מוסיף כללי allow לסשן אחד, וכלל deny מכל קובץ הגדרות עדיין חוסם כלי שהוא מציין

הדוגמה הזו מאשרת את git diff ומאפשרת ל-Claude Code לקרוא את .zshrc שלכם בלי לשאול:

settings.json

{
  "permissions": {
    "allow": ["Bash(git diff *)", "Read(~/.zshrc)"]
  }
}

Claude Code מחיל כללי allow מ-.claude/settings.json של פרויקט רק אחרי שאתם מקבלים את תיבת הדו שיח של אמון בסביבת העבודה עבור התיקייה הזו.

#תחביר כללי הרשאה

כללי הרשאה עוקבים אחרי התבנית Tool או Tool(specifier). Claude Code מעריך קודם כללי deny, אחר כך ask, ואחר כך allow, וההתאמה הראשונה מחליטה בלי קשר לכמה כל כלל ספציפי. ראו את סדר הערכת כללי ההרשאה.

כל שורה מציגה צורת כלל אחת ומה היא מתאימה.

לתחביר הכללים המלא, כולל התנהגות של תווי wildcard, תבניות ייעודיות לכלים Read, Edit, WebFetch, MCP ו-Agent, ומגבלות האבטחה של תבניות Bash, ראו תחביר כללי הרשאה.

#permissions.ask

רשמו את שימושי הכלים שמבקשים מכם אישור גם במצב הרשאה שהיה מאשר אותם אחרת, כמו acceptEdits או bypassPermissions. במצב dontAsk Claude Code דוחה שימוש תואם בכלי במקום להציג בקשה.

• היקף: כל קובץ
• סוג: מערך של מחרוזות כללי הרשאה
• ברירת מחדל: לא מוגדר

settings.json

{
  "permissions": {
    "ask": ["Bash(git push *)"]
  }
}

#permissions.deny

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

כללי deny של Read ושל Edit חלים על כלי הקבצים המובנים של Claude, על פקודות קבצים ש-Claude Code מזהה ב-Bash, כמו cat, head, tail, sed ו-tee, ועל היעדים של הפניות ב-Bash כמו > file ו-< file. הם לא חלים על פקודה שקוראת קבצים בלי לנקוב בשמם, כמו grep -r pattern ., או על תהליכי משנה שרירותיים, ולכן לאכיפה ברמת מערכת ההפעלה הפעילו את ארגז החול.

• היקף: כל קובץ
• סוג: מערך של מחרוזות כללי הרשאה
• ברירת מחדל: לא מוגדר
• עקיפות לכל סשן: --disallowedTools מוסיף כללי deny לסשן אחד לצד המפתח הזה

הדוגמה הזו דוחה קריאות של קובצי .env, תיקיית secrets וקובץ אישורים, וחוסמת פקודות curl:

settings.json

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(./config/credentials.json)",
      "Bash(curl *)"
    ]
  }
}

שמות כלים מקבלים תבניות glob, כך ש-"*" דוחה כל כלי ו-"mcp__*" דוחה כל כלי MCP. Claude Code מתעלם מכלל deny עבור הכלי EndConversation כל עוד כלי אחר עדיין זמין ל-Claude. כלל deny של Bash מתאים לפקודה כפי ש-Claude כותב אותה, כך ש-Bash(curl *) לא עוצר את /usr/bin/curl או את sh -c 'curl …'. ראו מה כלל Bash לא מתאים. המפתח הזה מחליף את הגדרת ignorePatterns שיצאה משימוש.

#permissions.additionalDirectories

תנו ל-Claude גישת קבצים לתיקיות מחוץ לזו שהתחלתם בה, כתיקיות עבודה נוספות. רוב ההגדרות של .claude/ לא מתגלות מהתיקיות האלה.

• היקף: כל קובץ, עם מגבלות על גישת הכתיבה של ארגז החול שרשומות פרויקט ומקומיות נותנות
• סוג: מערך של נתיבי תיקיות
• ברירת מחדל: לא מוגדר
• עקיפות לכל סשן: --add-dir ו-/add-dir מוסיפים תיקיות לסשן אחד לצד המפתח הזה

settings.json

{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}

כמו כללי allow, רשומות ב-.claude/settings.json של פרויקט נכנסות לתוקף רק אחרי שאתם מקבלים את תיבת הדו שיח של אמון בסביבת העבודה עבור התיקייה הזו.

#permissions.blockReadsOutsideWorkingDirectories

גרמו לכלי הקבצים של Claude לסרב לקריאות מחוץ לתיקיות העבודה שלכם בכל מצב הרשאה, כולל bypassPermissions. Claude Code דוחה קריאות Read, Grep, Glob ו-LSP בנתיבים האלה ואומר ל-Claude לבקש מכם להוסיף את התיקייה עם /add-dir. קבצים ש-Claude Code עצמו צריך נשארים קריאים, כמו ה-skills, ה-plugins, ה-rules, ה-agents וה-commands שלכם, וקובץ הזיכרון CLAUDE.md תחת ~/.claude/. נדרש Claude Code v2.1.257 או מאוחר יותר.

Claude Code לא מסרב לפקודות מעטפת באותו אופן:

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

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

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

• היקף: כל קובץ. ערך true בכל קובץ חל, כך שמאגר יכול להפעיל את החסימה עבור עצמו אבל לא יכול לבטל את שלכם.
• סוג: Boolean
  • true: כלי הקבצים של Claude מסרבים לקריאות מחוץ לתיקיות העבודה
  • false: כמו ערך לא מוגדר. החסימה עדיין חלה אם קובץ אחר מגדיר true
• ברירת מחדל: לא מוגדר, כך שקריאות מחוץ לתיקיות העבודה עוקבות אחרי מצב ההרשאה שלכם

settings.json

{
  "permissions": {
    "blockReadsOutsideWorkingDirectories": true
  }
}

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

תיקיות שאתם מוסיפים עם --add-dir, /add-dir, או additionalDirectories בהגדרות המשתמש או המנוהלות נחשבות לתיקיות עבודה לצורך החסימה. תיקיות שנוספו רק בהגדרות המאגר לא נחשבות: אלה ב-.claude/settings.json, ואלה ב-.claude/settings.local.json אלא אם git מדווח שהקובץ לא במעקב. בתיקייה שאינה מאגר git, או כש-git עוקב אחרי הקובץ, Claude Code מתייחס ל-.claude/settings.local.json כהגדרות מאגר, אז שימו תיקיות שאתם רוצים שיישארו קריאות בהגדרות המשתמש שלכם.

כש-autoMemoryDirectory מגיע מ-.claude/settings.json של הפרויקט, או מ-.claude/settings.local.json שמטופל כמסופק על ידי המאגר, Claude Code לא טוען זיכרון אוטומטי מהתיקייה הזו ולא שומר אליה.

#פקודות בארגז חול תחת החסימה

כשארגז החול פועל, החסימה מכסה גם פקודות בארגז חול. Claude Code שולל מהן גישת קריאה לתיקיית הבית שלכם ולשורשים האחרים שמחזיקים קבצי משתמש: /Users, /home, /root, /Volumes, /mnt, /media, /run/media ו-/srv. אחר כך הוא פותח מחדש את תיקיות העבודה, עצי עבודה ש-Claude Code יוצר בסשן, את תיקיית הקבצים הזמניים של הסשן, ואת החלקים של ~/.claude שפקודות צריכות, כמו skills ו-plugins. כל עוד החסימה בתוקף, רשומות allowRead ו-allowWrite מהגדרות המאגר לא נחשבות.

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

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

• בידוד מערכת הקבצים כבוי דרך sandbox.filesystem.disabled
• allowManagedReadPathsOnly מוגדר
• הנתיב של התיקייה שבה התחלתם את Claude Code מכיל תו glob כמו *, ? או [

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

• ~/.gitconfig
• הקבצים config, ignore ו-attributes תחת $XDG_CONFIG_HOME/git, שברירת המחדל שלו היא ~/.config/git
• קבצים שהגדרות git הגלובליות שלכם מציינות דרך [include], [includeIf], core.excludesFile או core.attributesFile

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

ב-Linux וב-WSL2, קובץ הגדרות שהוא symlink יכול להישאר לא קריא בנתיב שלו עצמו, ואז git רץ בלעדיו. ~/.git-credentials ו-$XDG_CONFIG_HOME/git/credentials נשארים חסומים.

אם קובץ שנפתח מחדש מחזיק סוד, כמו אסימון http.extraHeader, הוסיפו את הנתיב שלו ל-sandbox.filesystem.denyRead. רשומת denyRead שמכסה קובץ תמיד גוברת על הפתיחה מחדש הזו.

#permissions.blockWritesOutsideWorkingDirectories

גרמו לכלים Write, Edit ו-NotebookEdit לסרב לנתיבים מחוץ לתיקיות העבודה שלכם בכל מצב הרשאה, כולל bypassPermissions, מלבד חלק מהקבצים של Claude Code עצמו. המפתח לא מגביל פקודות מעטפת, כלי MCP, או את התוכניות ש-hooks מריצים. כדי להגביל לאן פקודות מעטפת כותבות, הפעילו ארגז חול. נדרש Claude Code v2.1.314 או מאוחר יותר.

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

• היקף: כל קובץ. ערך true בכל קובץ שהסשן טוען חל, כך שמאגר יכול להפעיל את החסימה עבור עצמו אבל לא יכול לבטל את שלכם. בסשן ענן, ייתכן ש-Claude Code לא יחיל את המפתח, כי כלי הקבצים רצים במכולה שהיא עצמה הגבול.
• סוג: Boolean
  • true: מפעיל את החסימה
  • false: כמו ערך לא מוגדר. החסימה עדיין חלה אם קובץ אחר מגדיר true
• ברירת מחדל: לא מוגדר, כך שכתיבות מחוץ לתיקיות העבודה עוקבות אחרי מצב ההרשאה שלכם. החסימה גם פועלת כל עוד Claude Code לא יכול לקרוא את אובייקט permissions בהגדרות המנוהלות שלכם.

settings.json

{
  "permissions": {
    "blockWritesOutsideWorkingDirectories": true
  }
}

כדי לבדוק את החסימה, בקשו מ-Claude להשתמש בכלי Write כדי ליצור קובץ מחוץ לתיקיות העבודה שלכם, כמו ~/block-test.txt אם תיקיית הבית שלכם אינה אחת מהן. Claude Code מסרב לקריאה, והסירוב אומר שההגדרה חוסמת כתיבות מחוץ לתיקיות העבודה.

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

#למה חסימת הכתיבה מסרבת ומה נשאר ניתן לכתיבה

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

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

• קובצי הגדרות של Claude Code: Claude Code מסרב לכתיבות האלה גם בתוך תיקיות העבודה, כי קובץ הגדרות יכול לבטל את החסימה. ערכו קובצי הגדרות בעצמכם.
• תיקייה שרק הגדרות המאגר מוסיפות: תיקייה ש-additionalDirectories מציינת רק ב-.claude/settings.json, או ב-.claude/settings.local.json אלא אם git מדווח שהקובץ לא במעקב
• עץ עבודה של תת סוכן: עריכות קבצים של תת סוכן עם isolation: worktree נדחות כשעץ העבודה שלו נמצא מחוץ לתיקיות העבודה
• זיכרון אוטומטי בתיקייה שהמאגר בחר: תיקייה ש-autoMemoryDirectory מציינת בהגדרות המאגר

קובצי הגדרות נשארים בסירוב, בכל מה שתוסיפו. כדי לאפשר כתיבה בכל אחד מהמקרים האחרים, הוסיפו תיקיית עבודה. /add-dir צריך תיקייה שקיימת, אז ציינו את התיקייה .claude/worktrees בשורש המאגר עבור עצי עבודה של תתי סוכנים.

#לאפשר לתיקייה אחת לעבור את חסימת הקריאה או הכתיבה

כדי לאפשר ל-Claude להגיע לתיקייה אחת מחוץ לפרויקט בזמן ש-blockReadsOutsideWorkingDirectories או blockWritesOutsideWorkingDirectories הוא true, הוסיפו אותה כתיקיית עבודה. הריצו /add-dir <directory> בסשן, העבירו --add-dir <directory> כשאתם מתחילים את Claude Code, או ציינו אותה תחת additionalDirectories בהגדרות המשתמש או המנוהלות שלכם. אף כלל allow לא מעביר את כלי הקבצים של Claude דרך אף אחת משתי החסימות.

#permissions.defaultMode

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

• Scope: Any file. auto ו-bypassPermissions לא נכנסים לתוקף מהגדרות פרויקט או מקומיות, ולכן יש להגדיר אותם ב-~/.claude/settings.json. לפני v2.1.257, bypassPermissions נכנס לתוקף מכל קובץ. לשיחות שהרחבת VS Code מתחילה, Claude Code קורא רק ערכי user, managed ו---settings.
• Type: מחרוזת, אחת מאלה:
  • "default": Claude Code מריץ רק קריאות בלי לשאול
  • "acceptEdits": Claude Code מריץ גם עריכות קבצים ופקודות מערכת קבצים נפוצות כמו mkdir ו-mv בלי לשאול
  • "plan": Claude Code קורא ומתכנן אבל חוסם עריכות עד שאתה מאשר תוכנית
  • "auto": Claude Code רץ בלי בקשות שגרתיות. לפני פעולות כמו פקודות מעטפת ובקשות רשת, מסווג ברקע בודק שהן תואמות לבקשה שלך
  • "dontAsk": Claude Code דוחה אוטומטית כל קריאה שבלעדיו הייתה מבקשת אישור, אם כי mod שהתקנת עדיין יכול לאשר חלק מהקריאות האלה. קריאות קבצים בתוך ספריות העבודה שלך, פעולות אחרות שלא צריכות אישור, וכלים שאושרו מראש עדיין רצים, חוץ מקריאות מנתיבי רשת
  • "bypassPermissions": Claude Code מריץ הכול בלי לשאול
  • "manual": כינוי ל-"default"
• Default: לא מוגדר
• Per-session overrides: --permission-mode, והמקבילה שלו --dangerously-skip-permissions עבור bypassPermissions, גוברים על המפתח הזה להפעלה אחת

{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

כללי הרשאות נערמים מעל כל מצב: כללי deny חוסמים בכל מצב, כולל bypassPermissions. ראה Permission modes. בהפעלות ענן, Claude Code מכבד מהמפתח הזה רק את acceptEdits, plan, default ו-auto. לשיחות שהרחבת VS Code מתחילה, ראה איזו הגדרה ההרחבה קוראת עבור מצב ההרשאות ההתחלתי.

#permissions.disableBypassPermissionsMode

מונע מכל אחד להיכנס למצב bypassPermissions. Claude Code דוחה אז את הדגל --dangerously-skip-permissions, ומתעלם מ-permissionMode: bypassPermissions של הגדרת סוכן, כך שהסוכן המשנה רץ עם מצב ההרשאות של הפעלת האב.

• Scope: Any file. בדרך כלל מוגדר בהגדרות מנוהלות כדי לאכוף מדיניות ארגונית.
• Type: המחרוזת "disable"
• Default: לא מוגדר
• Per-session overrides: המפתח הזה גובר על --dangerously-skip-permissions, ש-Claude Code דוחה כל עוד המפתח מוגדר

{
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}

לפני v2.1.223, Claude Code החיל את מצב ההרשאות מה-frontmatter גם כש-bypass היה מושבת.

#skipAutoPermissionPrompt

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

• Scope: User or managed. מאגר לא יכול להגדיר אותו עבורך.
• Type: Boolean
  • true: Claude Code מדלג על ההודעה
  • false: כמו לא מוגדר. ההודעה מופיעה פעם אחת אלא אם קובץ אחר מאלה מגדיר true
• Default: לא מוגדר, ולכן ההודעה מופיעה פעם אחת

{
  "skipAutoPermissionPrompt": true
}

#skipDangerousModePermissionPrompt

מדלג על תיבת האישור ש-Claude Code מציג לפני שהפעלה נכנסת למצב bypassPermissions, בין אם מ---dangerously-skip-permissions ובין אם מ-defaultMode: "bypassPermissions". Claude Code כותב כאן true בהגדרות המשתמש שלך כשאתה מקבל את התיבה פעם אחת.

• Scope: User, local, or managed. מאגר לא מהימן לא יכול לדלג על התיבה עבורך.
• Type: Boolean
  • true: Claude Code מדלג על תיבת האישור לפני שהפעלה נכנסת למצב bypassPermissions
  • false: כמו לא מוגדר. התיבה מופיעה אלא אם קובץ אחר מאלה מגדיר true
• Default: לא מוגדר, ולכן התיבה מופיעה

{
  "skipDangerousModePermissionPrompt": true
}

#הגדרות Sandbox

מבודד את הפקודות ש-Claude מריץ ממערכת הקבצים שלך, מהרשת שלך ומהאישורים שלך. לאופן פעולת ה-sandbox ולדרישות הפלטפורמה, ראה Sandboxing.

#sandbox

מבודד את פקודות Bash ש-Claude מריץ ממערכת הקבצים ומהרשת באמצעות sandboxing. מפעילים את ה-sandbox עם enabled, ואז מצמצמים או מרחיבים את מה שפקודות בתוך ה-sandbox יכולות לגעת בו באמצעות אובייקטי המשנה filesystem, network ו-credentials. ה-sandbox רץ ב-macOS, ב-Linux וב-WSL2.

• Scope: Any file
• Type: אובייקט עם enabled, failIfUnavailable, autoAllowBashIfSandboxed, excludedCommands, allowUnsandboxedCommands, enableWeakerNestedSandbox, enableWeakerNetworkIsolation, allowAppleEvents, allowNestedUserNamespaces, bwrapPath, socatPath, ignoreViolations ו-ripgrep, ובנוסף האובייקטים filesystem, network ו-credentials
• Default: לא מוגדר, ולכן Claude Code מריץ פקודות בלי sandbox

זה מפעיל את ה-sandbox, מדלג על בקשות הרשאה לפקודות בתוך ה-sandbox, מריץ את docker מחוץ ל-sandbox, פותח שני נתיבי כתיבה נוספים, מסתיר את קובץ האישורים של AWS, ומאשר מראש את GitHub ואת npm:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker *"],
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

כשהגדרות מנוהלות מגדירות מפתח Boolean כמו enabled או failIfUnavailable, הערך הזה גובר על כל מה שמפתח מגדיר. Claude Code ממזג מפתחות מערך על פני היקפי ההגדרות שההפעלה טוענת, כך שמפתח יכול להוסיף רשומות. ראה Keep developers from widening the policy לנעילות שמיועדות רק להגדרות מנוהלות. כדי לחייב sandbox לארגון, ראה Enforce sandboxing with managed settings.

#sandbox.enabled

מפעיל sandboxing לפקודות Bash. כשבוחרים מצב בלוח /sandbox, Claude Code כותב את המפתח הזה ל-.claude/settings.local.json של הפרויקט הנוכחי. הגדר אותו ב-~/.claude/settings.json כדי להחיל sandbox על כל פרויקט.

• Scope: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• Type: Boolean
  • true: Claude Code מריץ פקודות Bash בתוך sandbox
  • false: פקודות Bash רצות בלי sandbox
• Default: false

{
  "sandbox": {
    "enabled": true
  }
}

ב-Linux וב-WSL2 ה-sandbox צריך את bubblewrap ואת socat. ראה Set up Linux and WSL2. כשה-sandbox לא יכול להתחיל, Claude Code מריץ פקודות בלי sandbox אלא אם מגדירים גם את failIfUnavailable.

#sandbox.failIfUnavailable

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

בפלטפורמה שה-sandbox לא תומך בה, Claude Code לא מתחיל כשהמפתח הזה דלוק. ראה Enforce sandboxing with managed settings.

• Scope: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• Type: Boolean
  • true: Claude Code יוצא עם שגיאה בהפעלה כש-sandbox.enabled הוא true אבל ה-sandbox לא יכול להתחיל. אם ה-sandbox עובר את הבדיקה הזאת ואחר כך נכשל באתחול, ההפעלה ממשיכה לרוץ ו-Claude Code מסרב לכל פקודה בתוך sandbox
  • false: Claude Code מריץ פקודות בלי sandbox כשה-sandbox לא יכול להתחיל
• Default: false

זה מפעיל את ה-sandbox למכונות מנוהלות ומגדיר את failIfUnavailable ל-true:

{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true
  }
}

ראה Enforce sandboxing with managed settings.

#sandbox.autoAllowBashIfSandboxed

מאפשר ל-Claude Code להריץ פקודות Bash בתוך sandbox בלי בקשת הרשאה. פקודות שלא יכולות לרוץ בתוך ה-sandbox עדיין עוברות את זרימת ההרשאות הרגילה, וכללי deny וכללי ask שמוגבלים לתוכן כמו Bash(git push *) עדיין חלים. כלל ask שהוא רק Bash מדולג לפקודות בתוך sandbox. הגדר אותו ל-false כדי לשלוח גם פקודות בתוך sandbox דרך זרימת ההרשאות הרגילה, מה שלשונית Mode של /sandbox קוראת לו מצב הרשאות רגיל.

• Scope: Any file
• Type: Boolean
  • true: Claude Code מריץ פקודות Bash בתוך sandbox בלי בקשת הרשאה, חוץ מהמקרים שמצב Auto-allow מתאר. CLAUDE_CODE_SUBPROCESS_ENV_SCRUB מכבה את auto-allow
  • false: פקודות בתוך sandbox עוברות את זרימת ההרשאות הרגילה, כך שכללי ה-allow ומצב ההרשאות שלך מחליטים. לשונית Mode של /sandbox קוראת לזה מצב הרשאות רגיל
• Default: true

זה משאיר את ה-sandbox דלוק ושולח פקודות בתוך sandbox דרך זרימת ההרשאות הרגילה:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false
  }
}

ראה Auto-allow mode על מה שמצב auto-allow עדיין מבקש עליו ועל ההתנהגות שלו במצב plan.

#sandbox.excludedCommands

מציין פקודות ש-Claude Code מריץ מחוץ ל-sandbox, כמו כלים שלא עובדים תחתיו. כל רשומה משתמשת באותו תחביר כמו התוכן של כלל הרשאה מסוג Bash(...): פקודה מדויקת, קידומת כמו docker *, או תבנית תו כללי. תבנית בלי תו כללי היא התאמה מדויקת, ולכן docker תואם רק ל-docker בלי ארגומנטים.

הרשומות שלך מוציאות קריאת Bash מה-sandbox רק כשהן מכסות כל פקודה בתוכה, וצורות קריאה מסוימות נשארות בתוך sandbox גם אז. רשומת docker * לבדה לא מוציאה את npm ci && docker build . מה-sandbox.

• Scope: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• Type: מערך של תבניות פקודה
• Default: לא מוגדר, ולכן אף פקודה לא מוחרגת

{
  "sandbox": {
    "excludedCommands": ["docker *"]
  }
}

Claude Code משאיר קריאת Bash בתוך sandbox כשיש לה אחת מהצורות האלה, בין היתר:

• פקודה שמתחילה ב-sudo, ב-eval או ב-xargs
• cd, pushd או popd, בכל מקום שהם מופיעים בקריאה
• החלפת פקודה, subshell, או בלוק זרימת בקרה כמו if או for
• הפניה, כמו docker build . > build.log או heredoc מסוג <<EOF, חוץ מהפניה שרק משכפלת מתאר קובץ, כמו ש-2>&1 עושה
• שם פקודה שמגיע ממשתנה
• git clone, git init, git worktree add, git worktree move או git bundle create עם ארגומנט נתיב שהוא מוחלט, מתחיל ב-~, או מכיל מקטע ..

לדוגמה, cd build && docker compose up נשאר בתוך sandbox תחת רשומת docker *, והוספת רשומת cd לא משנה את זה. תחת רשומת git *, git clone <url> vendor/lib רץ מחוץ ל-sandbox, אבל git clone <url> ~/tools נשאר בתוך sandbox. clone כותב עץ שלם של קבצים, אולי גם קבצים ברי הרצה, בכל מקום שנתיב היעד שלו מצביע אליו.

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

רשומות מהיקפי ההגדרות שההפעלה טוענת מתאחדות לרשימה אחת, אלא אם ה-sandbox הוא admin-required. כל עוד הוא כזה, Claude Code מתעלם מרשומות ב-.claude/settings.json וב-.claude/settings.local.json, כך שמאגר ששוכפל לא יכול להוציא פקודות מה-sandbox. רשומות בהגדרות מנוהלות, ב---settings וב-~/.claude/settings.json שלך עדיין חלות, ואין נעילה שמיועדת רק להגדרות מנוהלות שמכסה את הרשימה הזאת.

#sandbox.allowUnsandboxedCommands

מאפשר ל-Claude לנסות שוב פקודה מחוץ ל-sandbox עם הפרמטר dangerouslyDisableSandbox אחרי שה-sandbox חוסם אותה. כשהערך הוא false, Claude Code מתעלם מהפרמטר הזה. כל עוד ה-sandbox רץ, הפקודות ש-Claude מריץ נשארות אז בתוך sandbox אלא אם הן תואמות לרשומת excludedCommands. לשונית Overrides של /sandbox מציגה את המצב הזה כ-Strict sandbox mode. ערך false בהגדרות מנוהלות מפעיל מצב sandbox קפדני למפתחים שהוא מכסה.

• Scope: Any file, עם מגבלה על הגדרות פרויקט ומקומיות
• Type: Boolean
  • true: Claude יכול לנסות שוב פקודה מחוץ ל-sandbox עם הפרמטר dangerouslyDisableSandbox אחרי שה-sandbox חוסם אותה
  • false: Claude Code מתעלם מהפרמטר הזה, ולכן כל עוד ה-sandbox רץ, הפקודות ש-Claude מריץ נשארות בתוך sandbox אלא אם הן תואמות לרשומת excludedCommands
• Default: true

זה אוכף מצב sandbox קפדני לכל מי שההגדרות המנוהלות מכסות:

{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false
  }
}

ערך false מהגדרות מנוהלות או מ---settings גם הופך את ה-sandbox ל-admin-required. ערך false בהגדרות המשתמש שלך עומד מול true של פרויקט אבל לא הופך את ה-sandbox ל-admin-required. עמידה מול ערך של פרויקט דורשת Claude Code בגרסה v2.1.285 או חדשה יותר.

מי מאשר ניסיון חוזר מחוץ ל-sandbox תלוי במצב ההרשאות ובכללי ה-allow שלך. ראה The unsandboxed retry escape hatch.

כדי לראות מתי פקודות שאתה מקליד בעצמך בשורת מצב המעטפת עם הקידומת ! רצות בתוך sandbox, ראה strict sandbox mode.

#sandbox.filesystem

שולט בנתיבים שפקודות בארגז החול יכולות לקרוא ולכתוב. כברירת מחדל הן יכולות לכתוב לספריית העבודה, לספריית הזמני של המשתמש, ולספריות שמוסיפים עם --add-dir, /add-dir, או permissions.additionalDirectories, ויכולות לקרוא את שאר מערכת הקבצים, כולל קבצי אישורים. מרחיבים או מצמצמים את זה עם ארבע רשימות הנתיבים, או מכבים את שכבת מערכת הקבצים עם disabled. ראו בידוד מערכת קבצים לגבולות ברירת המחדל.

• היקף: כל קובץ
• סוג: אובייקט עם המערכים allowWrite, denyWrite, denyRead ו-allowRead, ועם ערכי Boolean בשם allowManagedReadPathsOnly ו-disabled
• ברירת מחדל: לא מוגדר, ולכן חלים גבולות הקריאה והכתיבה של ברירת המחדל

זה מאפשר לפקודות בארגז החול לכתוב לספריית בנייה ול-kubeconfig שלכם, ומסתיר את קובץ האישורים של AWS:

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

Claude Code אוכף את הרשימות האלה בגבול ארגז החול של מערכת ההפעלה, ולכן הן חלות על כל תהליך משנה שפקודה בארגז החול מפעילה, כגון kubectl, terraform, או npm. Claude Code מוסיף את כללי ההרשאה שלכם לאותן רשימות: כללי allow ו-deny של Edit אל allowWrite ו-denyWrite, כללי deny של Read אל denyRead, וכללי allow ו-deny של WebFetch(domain:...) אל רשימות הדומיינים של network.

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

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

#קידומות נתיב בארגז החול

נתיבים ב-allowWrite, denyWrite, denyRead, allowRead, ו-credentials.files נפתרים לפי הקידומת שלהם:

קידומת //path לנתיבים מוחלטים גם עובדת. אם משתמשים בלוכסן יחיד /path ומצפים לרזולוציה יחסית לפרויקט, עוברים ל-./path. התחביר הזה שונה מכללי הרשאה של Read ו-Edit, שמשתמשים ב-//path למוחלט וב-/path ליחסי לפרויקט: נתיבי מערכת הקבצים של ארגז החול משתמשים במוסכמות רגילות, ולכן /tmp/build הוא נתיב מוחלט.

Claude Code מסיר לוכסן סופי מנתיב ספרייה, כך ש-~/.aws ו-~/.aws/ תואמים לאותה ספרייה. לפני v2.1.224, Claude Code העביר את הלוכסן הסופי לארגז החול, ו-Claude עדיין יכול היה לקרוא או לכתוב נתיבים מתחת לרשומת denyRead או denyWrite שנכתבה עם לוכסן כזה.

#איפה תווי הכללה עובדים בנתיבי ארגז החול

תווי ההכללה *, ?, ו-** עובדים בכל ארבע רשימות הנתיבים של sandbox.filesystem ב-macOS, ובפחות מקומות ב-Linux וב-WSL2:

ב-~/keys/*.pem, תו ההכללה בא אחרי שם הספרייה הראשונה, שהוא home עבור ספריית בית /home/alice:

~/keys/*.pem              הרשומה
/home/alice/keys/*.pem    הנתיב המלא שלה
 ^^^^                     שם הספרייה הראשונה, home

ב-Linux וב-WSL2, לשונית Config של /sandbox בסשן מזהירה על כללי הרשאת Edit שמכילים תו הכללה שאינו /** סופי. תווי ההכללה האלה לא עובדים לפקודות בארגז החול. הוסיפו כל נתיב שהכלל אמור לכסות, או את הספרייה שמחזיקה אותם, אל allowWrite עבור כלל allow או אל denyWrite עבור כלל deny.

#שמות ספריות עם סוגריים מרובעים, מסולסלים או עגולים

כדי לאפשר או לחסום ספרייה ששמה מכיל סוגריים מרובעים, כתבו את השם כפי שהוא, כגון ./app/[slug]. ברשומה הזו, [slug] הוא השם האמיתי של הספרייה, כולל הסוגריים:

app/
└── [slug]/
    └── page.tsx

הרשומה הזו מכסה את הכל מתחת לספרייה, ולכן השמיטו /** סופי. ב-macOS וב-Linux וב-WSL2, הספרייה app/[slug] חייבת להתקיים כשהפקודה בארגז החול מתחילה.

• סוגריים מרובעים כגון [slug]: בכל רשימה ב-macOS, וב-denyRead וב-allowRead ב-Linux וב-WSL2, הסוגריים ב-./app/[slug] הם גם תבנית. הרשומה אז תואמת גם כל נתיב מתחת ל-app ששמו תו אחד מתוך slug, כגון app/s או app/g. עם הרשומה הזו ב-allowRead, או ב-allowWrite ב-macOS, פקודות בארגז החול יכולות להגיע גם לנתיבים האלה. שנו את השם של כל נתיב שהן לא אמורות להגיע אליו.
• סוגריים מרובעים כגון [user-id] או [post-id], שבהם התו משמאל למקף ממוין אחרי התו מימינו: ./app/[user-id] מכסה רק את הספרייה עם בדיוק השם הזה, בכל רשימה בכל פלטפורמה. לפני v2.1.304, פקודות בארגז החול ב-Linux וב-WSL2 נכשלו בהפעלה בזמן ש-denyRead או allowRead החזיקו רשומה כזו.
• סוגריים מסולסלים וסוגריים עגולים: אלה תווים רגילים, ולכן ~/data/{keys,tokens} מכסה ספרייה אחת בשם {keys,tokens}, לא שתי חלופות. כדי לכסות את ~/data/keys ואת ~/data/tokens, הוסיפו כל אחת כרשומה משלה.

#sandbox.filesystem.allowWrite

מוסיף נתיבים שפקודות בארגז החול יכולות לכתוב אליהם, מעבר לספריית העבודה, לספריית הזמני של המשתמש, ולספריות שהוספתם עם --add-dir, /add-dir, או permissions.additionalDirectories. השתמשו בזה כשתהליך משנה כגון kubectl או כלי בנייה צריך לכתוב מחוץ לפרויקט.

• היקף: כל קובץ, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: מערך של מחרוזות נתיב, לפי קידומות הנתיב של ארגז החול
• ברירת מחדל: לא מוגדר, ולכן פקודות בארגז החול יכולות לכתוב לספריית העבודה, לספריית הזמני של המשתמש, לספריות שהוספתם עם --add-dir או /add-dir, ולספריות ב-permissions.additionalDirectories

זה מאפשר לבנייה לכתוב מתחת ל-/tmp/build ומאפשר ל-kubectl לעדכן את ה-kubeconfig שלכם:

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"]
    }
  }
}

Claude Code ממזג רשומות allowWrite ואת הנתיבים מכללי הרשאת allow של Edit(...) על פני היקפי ההגדרות שהסשן טוען, ומשמיט את אלה מהגדרות המאגר בזמן ש-permissions.blockReadsOutsideWorkingDirectories פועל. נעילות מאגר יכולות להשמיט גם את רשומות המאגר. רשומת allowWrite לא יכולה להסיר נתיב מוגן.

#sandbox.filesystem.denyWrite

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

• היקף: כל קובץ
• סוג: מערך של מחרוזות נתיב, לפי קידומות הנתיב של ארגז החול
• ברירת מחדל: לא מוגדר

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

{
  "sandbox": {
    "filesystem": {
      "denyWrite": ["/etc", "/usr/local/bin"]
    }
  }
}

Claude Code ממזג רשומות על פני כל היקף הגדרות שהסשן טוען, ומוסיף את הנתיבים מכללי הרשאת deny של Edit(...).

#sandbox.filesystem.denyRead

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

• היקף: כל קובץ
• סוג: מערך של מחרוזות נתיב, לפי קידומות הנתיב של ארגז החול
• ברירת מחדל: לא מוגדר, ולכן פקודות בארגז החול שומרות על גישת הקריאה של ברירת המחדל, שכוללת קבצי אישורים כגון ~/.aws/credentials

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

Claude Code ממזג רשומות על פני כל היקף הגדרות שהסשן טוען, ומוסיף את הנתיבים מכללי הרשאת deny של Read(...). כש-filesystem.disabled הוא true, Claude Code לא אוכף את הרשומות האלה.

#sandbox.filesystem.allowRead

פותח מחדש קריאה לנתיבים מסוימים בתוך אזור ש-denyRead חוסם, כדי לבנות גישת קריאה רק לסביבת העבודה. רשומת denyRead מדויקת או עם תו הכללה נשארת חסומה בתוך allowRead רחב יותר, כפי שטבלת החפיפה מראה. כשרשומת denyRead עם תו הכללה כגון ~/**/.env תואמת ספרייה, Claude Code חוסם גם קריאה של התוכן שלה. לפני v2.1.236 ב-macOS, Claude Code פתח מחדש את הנתיבים שרשומת denyRead עם תו הכללה תאמה בכל מקום שרשומת allowRead רחבה יותר כיסתה אותם, והשאיר את תוכן הספרייה התואמת קריא.

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

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

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    }
  }
}

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

#sandbox.filesystem.allowManagedReadPathsOnly

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

• היקף: מנוהל
• סוג: Boolean
  • true: Claude Code מכבד רק את רשומות allowRead מהגדרות מנוהלות
  • false: רשומות allowRead מקובצי הגדרות אחרים יכולות להתמזג
• ברירת מחדל: false

זה חוסם קריאה של ספריית הבית, פותח מחדש את ~/work, ועוצר מפתחים מפתיחה מחדש של כל דבר אחר:

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["~/work"],
      "allowManagedReadPathsOnly": true
    }
  }
}

ראו מניעת הרחבת המדיניות על ידי מפתחים.

#sandbox.filesystem.disabled

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

• היקף: משתמש או מנוהל. כשהגדרות מנוהלות מגדירות את sandbox.filesystem בכלל, או מפרטות רשומת sandbox.credentials.files עם "mode": "deny", רק הגדרות מנוהלות יכולות להגדיר אותו.
• סוג: Boolean
  • true: Claude Code מדלג על בידוד מערכת הקבצים ושומר על בידוד הרשת
  • false: בידוד מערכת הקבצים נשאר פעיל
• ברירת מחדל: false, ולכן בידוד מערכת הקבצים נשאר פעיל

זה משאיר את מערכת הקבצים פתוחה ומגביל את יציאת הרשת אל GitHub ו-npm:

{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "disabled": true
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

כשהשכבה כבויה, Claude Code לא אוכף רשומות denyRead או רשומות deny של credentials.files, בעוד שרשומות credentials.envVars ורשומות mask שהוחלו ממשיכות לעבוד. autoAllowBashIfSandboxed עדיין ברירת המחדל שלו היא true, ולכן הגדירו אותו ל-false כדי להמשיך לבקש אישור. ראו כיבוי בידוד מערכת הקבצים לרשימה המלאה של המקורות שיכולים להגדיר אותו ולמה שמשתנה כשהבידוד כבוי.

#sandbox.ignoreViolations

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

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

{
  "sandbox": {
    "ignoreViolations": {
      "*": ["/etc/hosts"]
    }
  }
}

#sandbox.enableWeakerNestedSandbox

מריץ את ארגז החול של Linux בתוך מכולת Docker unprivileged, שבה bubblewrap לא יכול לעגן /proc חדש. במקום זה ארגז החול הפנימי מבצע bind-mount ל-/proc הקיים של המכולה, וזה חושף מידע על תהליכים שעיגון חדש היה מסתיר. זה מפחית את האבטחה. השתמשו בזה רק כשהמכולה החיצונית כבר מספקת את הבידוד שאתם צריכים.

• היקף: כל קובץ, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: Boolean
  • true: ארגז החול הפנימי מבצע bind-mount ל-/proc הקיים של המכולה במקום לעגן אחד חדש
  • false: ארגז החול מעגן /proc חדש, וזה לא עובד במכולת Docker unprivileged
• ברירת מחדל: false

{
  "sandbox": {
    "enabled": true,
    "enableWeakerNestedSandbox": true
  }
}

רק Linux ו-WSL2. ראו Bubblewrap נכשל בהפעלה בתוך מכולה.

#sandbox.enableWeakerNetworkIsolation

מאפשר לפקודות בארגז החול ב-macOS להגיע לשירות האמון של TLS במערכת, com.apple.trustd.agent. כלים מבוססי Go כגון gh, gcloud, ו-terraform צריכים אותו כדי לאמת אישורי TLS כשמשתמשים ב-network.httpProxyPort עם פרוקסי MITM ו-CA מותאם. זה מפחית את האבטחה בכך שנפתח נתיב אפשרי להוצאת נתונים דרך שירות האמון.

• היקף: כל קובץ, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: Boolean
  • true: פקודות בארגז החול ב-macOS יכולות להגיע אל com.apple.trustd.agent
  • false: פקודות בארגז החול ב-macOS לא יכולות להגיע לשירות האמון של TLS במערכת
• ברירת מחדל: false

{
  "sandbox": {
    "enabled": true,
    "enableWeakerNetworkIsolation": true
  }
}

אם לא משתמשים בפרוקסי MITM, פרטו את הכלים שנכשלים ב-excludedCommands. ראו כלי CLI מבוססי Go נכשלים באימות TLS ב-macOS.

#sandbox.allowAppleEvents

מאפשר לפקודות בארגז חול ב-macOS לשלוח Apple Events, ש-open, osascript וכלים שפותחים כתובות URL בדפדפן זקוקים להם. בלעדיו הם נכשלים עם שגיאה -600. זה מסיר את בידוד הרצת הקוד: פקודות בארגז חול יכולות להפעיל יישומים אחרים מחוץ לארגז החול בלי בקשת אישור מהמשתמש, ויכולות לשלוח פקודות AppleScript ליישומים שרצים, כמו Terminal, בכפוף לבקשת ההסכמה לאוטומציה של macOS לכל יישום (TCC).

• היקף: משתמש או מנוהל
• סוג: בוליאני
  • true: פקודות בארגז חול ב-macOS יכולות לשלוח Apple Events
  • false: פקודות בארגז חול ב-macOS לא יכולות לשלוח Apple Events, ולכן open ו-osascript נכשלים עם שגיאה -600
• ברירת מחדל: false

{
  "sandbox": {
    "enabled": true,
    "allowAppleEvents": true
  }
}

כדי לשמור על הבידוד ועדיין להריץ כלי אחד כזה, הוסף אותו ל-excludedCommands במקום. ראה Apple Events ב-macOS.

#sandbox.allowNestedUserNamespaces

מאפשר לפקודות בארגז חול ב-Linux וב-WSL2 ליצור מרחבי שמות משתמש (user namespaces), שארגז החול של Chromium ושל Electron, bubblewrap מקונן, ו-unshare זקוקים להם. אם מגדירים את המפתח הזה ל-true, מכבים גבול אבטחה: קוד מפקודה בארגז חול יכול בסופו של דבר לרוץ מחוץ לארגז החול. עבור Podman או Buildah בלי root, השתמש ב-excludedCommands במקום, כי ארגז החול עוצר אותם גם בדרכים אחרות. דורש Claude Code בגרסה v2.1.305 או חדשה יותר.

• היקף: משתמש או מנוהל. ערך true נלקח בחשבון מ-~/.claude/settings.json, מ-JSON שמועבר עם --settings, או מהגדרות מנוהלות. Claude Code מתעלם מ-true בקובץ .claude/settings.json או .claude/settings.local.json של פרויקט. בסשן שבו CLAUDE_CODE_SUBPROCESS_ENV_SCRUB מוגדר ל-1, Claude Code מתעלם מ-true מכל מקור. ערך false נלקח בחשבון מכל קובץ, לפי קדימות הגדרות.
• סוג: בוליאני
  • true: פקודות בארגז חול יכולות ליצור user namespaces
  • false: המפתח הזה לא מאפשר שום דבר נוסף, וברירת המחדל של ארגז החול חלה
• ברירת מחדל: false

{
  "sandbox": {
    "enabled": true,
    "allowNestedUserNamespaces": true
  }
}

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

כדי למצוא את התיקון לכלי שלך, ראה Chromium או Podman בלי root נכשלים בתוך ארגז החול ב-Linux.

#sandbox.ripgrep

מכוון את ארגז החול אל קובץ בינארי של ripgrep משלך במקום זה ש-Claude Code משתמש בו, למשל כשהפלטפורמה שלך צריכה rg שנבנה אחרת.

• היקף: משתמש או מנוהל
• סוג: אובייקט עם command, הנתיב אל קובץ ה-ripgrep הבינארי, ו-args אופציונלי, מערך של ארגומנטים להוספה בהתחלה
• ברירת מחדל: לא מוגדר, כך שארגז החול משתמש באותו קובץ ripgrep בינארי כמו Claude Code. זה הקובץ המצורף, אלא אם מגדירים את USE_BUILTIN_RIPGREP ל-0

{
  "sandbox": {
    "ripgrep": {
      "command": "/usr/local/bin/rg"
    }
  }
}

#sandbox.bwrapPath

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

• היקף: מנוהל. Claude Code קורא אותו רק מהגדרות מנוהלות, כדי שקובץ של משתמש, פרויקט או קובץ מקומי לא יוכל לכוון את ארגז החול אל קובץ בינארי אחר.
• סוג: מחרוזת, נתיב מוחלט. Claude Code משמיט נתיב יחסי ונופל חזרה לחיפוש ב-PATH
• ברירת מחדל: לא מוגדר, כך ש-Claude Code מוצא את bwrap ב-PATH

{
  "sandbox": {
    "enabled": true,
    "bwrapPath": "/opt/admin/bwrap"
  }
}

Linux ו-WSL2 בלבד.

#sandbox.socatPath

מכוון את פרוקסי הרשת של ארגז החול אל קובץ socat בינארי שמותקן מחוץ ל-PATH.

• היקף: מנוהל
• סוג: מחרוזת, נתיב מוחלט. Claude Code משמיט נתיב יחסי ונופל חזרה לחיפוש ב-PATH
• ברירת מחדל: לא מוגדר, כך ש-Claude Code מוצא את socat ב-PATH

{
  "sandbox": {
    "enabled": true,
    "socatPath": "/opt/admin/socat"
  }
}

Linux ו-WSL2 בלבד.

#sandbox.credentials

מצהיר על קובצי אישורים ומשתני סביבה שיש להגן עליהם מפני פקודות בארגז חול. כל רשומה מציינת path של קובץ או name של משתנה ו-mode: deny מסתיר את האישור בתוך ארגז החול, ו-mask מציג לפקודות בארגז החול מציין מקום בזמן שפרוקסי ארגז החול מחליף בערך האמיתי בבקשות יוצאות. Claude Code מגן רק על הרשומות שאתה מציין. אין רשימת דחיית אישורים מובנית.

• היקף: כל קובץ. Claude Code מכבד רשומות mask, וגם allowPlaintextInject, awsPairs ו-sigv4, רק מהגדרות משתמש, הגדרות מנוהלות ודגל --settings.
• סוג: אובייקט עם files, envVars, allowPlaintextInject, awsPairs ו-sigv4
• ברירת מחדל: לא מוגדר, כך שאף אישור אינו מוגן

זה מסתיר את קובץ אישורי ה-AWS שלך ומסיר את GITHUB_TOKEN מפקודות בארגז חול:

{
  "sandbox": {
    "credentials": {
      "files": [{ "path": "~/.aws/credentials", "mode": "deny" }],
      "envVars": [{ "name": "GITHUB_TOKEN", "mode": "deny" }]
    }
  }
}

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

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

כשרשומת sandbox.credentials מנוהלת נכשלת באימות, Claude Code ממשיך להגן על האישור במקום שבו הוא יכול:

• רשומה ב-files או ב-envVars שעדיין יש לה path או name תקין ו-mode של mask או deny, כמו רשומה שתבנית ה-extract שלה בלי קבוצה לוכדת, מונמכת ל-mode: "deny" עם אזהרה, כך שהאישור נשאר חסום, לא ממסוך, עד שמתקנים את הרשומה. רשומת files שהונמכה מקבעת את filesystem.disabled כמו רשומת deny מפורשת, והאזהרה מציינת שחסימת הקריאה שלה לא נאכפת אם הגדרות מנוהלות מכבות את בידוד מערכת הקבצים.
• רשומה עם mode לא מוכר או עם path או name לא תקין מוסרת.
• כל מקרה מזהיר. בין אם רשומה הונמכה ובין אם הוסרה, הרשומות התקינות שנותרו עדיין נאכפות.

חל ב-v2.1.191 ואילך. לפני v2.1.221, כל רשומה לא תקינה הוסרה. למפתחות המנוהלים האחרים עם טיפול לפי שדה, ראה רשומות לא תקינות בהגדרות מנוהלות.

#sandbox.credentials.files

מגן על קובצי אישורים או ספריות מפני פקודות בארגז חול. עם "mode": "deny", Claude Code חוסם קריאות של הנתיב בתוך ארגז החול, אותה חסימת קריאה כמו sandbox.filesystem.denyRead. עם "mode": "mask", פקודות בארגז חול ב-Linux וב-WSL2 קוראות עותק sentinel של הקובץ, ופרוקסי ארגז החול מחליף בערך האמיתי בבקשות יוצאות אל injectHosts של אותה רשומה. ב-macOS הקובץ אינו קריא בתוך ארגז החול במקום זאת. "mode": "mask" דורש Claude Code בגרסה v2.1.221 או חדשה יותר.

• היקף: כל קובץ. Claude Code משמיט רשומות mask מקובץ הפרויקט .claude/settings.json ומהקובץ המקומי .claude/settings.local.json.
• סוג: מערך של אובייקטים, כל אחד עם path ו-mode של "deny" או "mask", ועם שדות המסכה לקבצים האופציונליים
• ברירת מחדל: לא מוגדר, כך שאף קובץ אישורים אינו מוגן

זה מסתיר את קובץ אישורי ה-AWS שלך וממסך את קובץ המארחים של gh, ומחליף בערך האמיתי רק בבקשות אל api.github.com:

{
  "sandbox": {
    "credentials": {
      "files": [
        { "path": "~/.aws/credentials", "mode": "deny" },
        { "path": "~/.config/gh/hosts.yml", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}

נתיבים משתמשים באותן קידומות כמו הגדרות sandbox.filesystem.*, ו-Claude Code ממזג את המערכים מכל היקף הגדרות שהסשן טוען. הגנה על אישורים מכסה מה עדיין חל ממקורות שמוציאים עם --setting-sources. רשומות mask דורשות Claude Code בגרסה v2.1.221 או חדשה יותר.

החלפת mask רצה רק דרך פרוקסי ארגז החול, אז הגדר sandbox.network.tlsTerminate, או allowPlaintextInject לרשתות בדיקה ב-HTTP רגיל. mask חל על קובץ יחיד, אז ציין כל קובץ אישורים בנפרד. Claude Code מקבל אבל מתעלם משדות ה-mask ברשומת deny. מיסוך אישורים מכסה אילו מקורות הגדרות מכובדים, ומיסוך קובצי אישורים מכסה מתי רשומה נופלת חזרה ל-deny.

#שדות מסכה לקבצים

רשומת mask מקבלת את השדות האופציונליים האלה. בלי extract או decode, Claude Code מחליף את כל תוכן הקובץ ב-sentinel אחד. ב-macOS כשבידוד מערכת הקבצים פועל, Claude Code מחיל רשומת mask כ-deny לפני ש-extract או decode רצים. ראה מיסוך קובצי אישורים.

זה ממסך רק את ערך oauth_token בקובץ המארחים של gh, מחליף כל עותק אחר שלו בקובץ, הופך את הקובץ ללא קריא אם התבנית לא תואמת דבר, ומחליף באסימון האמיתי רק בבקשות אל api.github.com:

{
  "sandbox": {
    "credentials": {
      "files": [
        {
          "path": "~/.config/gh/hosts.yml",
          "mode": "mask",
          "extract": "oauth_token:\\s*(\\S+)",
          "maskDuplicates": true,
          "onExtractNoMatch": "deny",
          "injectHosts": ["api.github.com"]
        }
      ]
    }
  }
}

#sandbox.credentials.envVars

הגנה על משתני סביבה מפני פקודות בתוך ארגז החול. עם "mode": "deny", Claude Code מסיר את המשתנה מסביבת הפקודות שבתוך ארגז החול. עם "mode": "mask", פקודות בתוך ארגז החול רואות ערך זקיף לכל הפעלה, ופרוקסי ארגז החול מחליף אותו בערך האמיתי בבקשות יוצאות אל injectHosts של הרשומה, כך שכלים כמו gh ו-npm ממשיכים לאמת בלי להחזיק את האישור האמיתי.

• היקף: Any file. Claude Code משמיט רשומות mask מקובץ הפרויקט .claude/settings.json ומהקובץ המקומי .claude/settings.local.json.
• סוג: מערך של אובייקטים, כל אחד עם name ועם mode של "deny" או "mask", ועם שדות המסכה האופציונליים למשתני סביבה
• ברירת מחדל: לא מוגדר, כך שאף משתנה סביבה אינו מוגן

זה מסיר את NPM_TOKEN מפקודות בתוך ארגז החול וממסך את GITHUB_TOKEN, ומחליף בערך האמיתי רק בבקשות אל api.github.com:

{
  "sandbox": {
    "credentials": {
      "envVars": [
        { "name": "NPM_TOKEN", "mode": "deny" },
        { "name": "GITHUB_TOKEN", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}

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

החלפת mask רצה רק דרך פרוקסי ארגז החול, לכן הגדירו את sandbox.network.tlsTerminate, או את allowPlaintextInject לרשתות בדיקה ב-HTTP רגיל. ראו מיסוך אישורים. Claude Code מקבל אך מתעלם משדות mask ברשומת deny.

#שדות מסכה למשתני סביבה

רשומת mask מקבלת את השדות האופציונליים האלה. בלי extract או decode, Claude Code מחליף את כל הערך בזקיף אחד. אי אפשר לשלב extract ו-decode באותה רשומה.

זה ממסך רק את הסיסמה בתוך DATABASE_URL, מבטל את הגדרת המשתנה אם התבנית לא מתאימה לכלום, וממסך JWT ב-SERVICE_JWT תוך השארת כל claim קריא חוץ מ-api_key:

{
  "sandbox": {
    "credentials": {
      "envVars": [
        {
          "name": "DATABASE_URL",
          "mode": "mask",
          "extract": "://[^:]+:([^@]+)@",
          "onExtractNoMatch": "deny"
        },
        {
          "name": "SERVICE_JWT",
          "mode": "mask",
          "decode": "jwt",
          "maskClaims": ["api_key"]
        }
      ]
    }
  }
}

#sandbox.credentials.allowPlaintextInject

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

• היקף: User or managed
• סוג: בוליאני
  • true: Claude Code מתיר החלפת mask גם בבקשות HTTP רגיל וגם ב-HTTPS עם סיום TLS
  • false: Claude Code מתיר החלפת mask רק ב-HTTPS עם סיום TLS
• ברירת מחדל: false

{
  "sandbox": {
    "credentials": {
      "allowPlaintextInject": true
    }
  }
}

#sandbox.credentials.awsPairs

קיבוץ משתני סביבה ממסוכים שיוצרים אישור AWS אחד לחתימה מחדש ב-SigV4, כשהאישור שלכם נמצא במשתנים עם שמות לא סטנדרטיים. Claude Code מקשר אוטומטית את השלשה המקובלת AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY ו-AWS_SESSION_TOKEN כשאתם ממסכים את כל הערכים שלהם, ולכן אתם צריכים את המפתח הזה רק לשמות אחרים. דורש Claude Code v2.1.224 או חדש יותר.

• היקף: User or managed
• סוג: מערך של אובייקטים, כל אחד עם accessKeyIdVar, secretAccessKeyVar, ובאופן אופציונלי sessionTokenVar, שמציינים רשומות של sandbox.credentials.envVars
• ברירת מחדל: לא מוגדר, כך שרק השלשה המקובלת מזווגת

זה מקשר שלושה משתנים עם שמות מותאמים לאישור AWS אחד לחתימה מחדש:

{
  "sandbox": {
    "credentials": {
      "awsPairs": [
        {
          "accessKeyIdVar": "MY_KEY_ID",
          "secretAccessKeyVar": "MY_SECRET_KEY",
          "sessionTokenVar": "MY_SESSION_TOKEN"
        }
      ]
    }
  }
}

כל משתנה ששמו צוין חייב להיות רשומת mask של כל הערך ב-sandbox.credentials.envVars, בלי extract או decode, ויכול למלא רק משבצת אחת בכל הזוגות. הכללים האלה חלים גם:

• הפרוקסי חותם מחדש בקשות במארחים שרשומים ב-injectHosts של רשומת מזהה מפתח הגישה
• כש-sessionTokenVar מוגדר, הפרוקסי שולח את האסימון האמיתי כ-x-amz-security-token בבקשות שנחתמו מחדש
• ציון של אחד מהמשתנים המקובלים בזוג מחליף את הזיווג האוטומטי

#sandbox.credentials.sigv4

בחירה במה שפרוקסי ארגז החול עושה עם צורות בקשת AWS שאי אפשר לחתום מחדש: streaming להעלאות זורמות aws-chunked, presigned לכתובות URL חתומות מראש, ו-sigv4a לחתימות אסימטריות SigV4A. זה חל רק על בקשות שנחתמו עם מזהה מפתח גישה של מציין מיקום מזוג ממסוך. דורש Claude Code v2.1.224 או חדש יותר.

• היקף: User or managed
• סוג: אובייקט עם streaming, presigned ו-sigv4a, כל אחד מהם אחד מאלה:
  • "deny": הפרוקסי נכשל בבקשה
  • "passthrough": הפרוקסי מעביר את הבקשה חתומה עם מציין המיקום הממסוך, כך שהכלי מקבל את הדחייה של AWS עצמה
• ברירת מחדל: לא מוגדר, כך שכל צורה היא "deny"

זה מעביר העלאות זורמות במקום להכשיל אותן בפרוקסי:

{
  "sandbox": {
    "credentials": {
      "sigv4": {
        "streaming": "passthrough"
      }
    }
  }
}

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

#sandbox.network

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

• היקף: Any file. strictAllowlist, allowManagedDomainsOnly ו-tlsTerminate נקראים ממקורות מעטים יותר, כפי שהרשומות שלהם אומרות.
• סוג: אובייקט עם מפתחות המשנה שלמטה
• ברירת מחדל: לא מוגדר, כך שאף דומיין אינו מותר מראש ומצב ההרשאה שלכם מחליט מה קורה לכל מארח חדש

זה מתיר מראש את GitHub ואת npm, חוסם את uploads.github.com, ומאפשר לפקודות להיקשר ל-localhost:

{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "deniedDomains": ["uploads.github.com"],
      "allowLocalBinding": true
    }
  }
}

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

#sandbox.network.allowUnixSockets

רשימת נתיבי שקעי Unix שפקודות בתוך ארגז החול יכולות להתחבר אליהם ב-macOS. Claude Code מתעלם מהרשימה הזו ב-Linux וב-WSL2, שם מסנן seccomp לא יכול לבדוק נתיבי שקע. השתמשו שם ב-allowAllUnixSockets במקום זאת.

• היקף: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: מערך של מחרוזות, כל אחת נתיב שקע
• ברירת מחדל: לא מוגדר, כך שארגז החול של macOS חוסם כל שקע Unix

{
  "sandbox": {
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"]
    }
  }
}

נתיב שקע יכול להעניק גישה רחבה: התרת /var/run/docker.sock, למשל, מאפשרת לפקודה בתוך ארגז החול לשלוט בדמון Docker. ראו מגבלות אבטחה.

#sandbox.network.allowAllUnixSockets

מאפשר לפקודות בתוך ארגז החול להתחבר לכל שקע Unix. ב-Linux וב-WSL2, מסנן seccomp של ארגז החול חוסם קריאות socket(AF_UNIX, ...), ולכן זו הדרך היחידה להתיר שם שקעי Unix. כשהמסנן חסר, וזה מה ש-/sandbox מדווח בלשונית Dependencies, ארגז החול לא חוסם קריאות לשקעי Unix. ראו הגדרת Linux ו-WSL2 למקור המסנן.

• היקף: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: בוליאני
  • true: פקודות בתוך ארגז החול יכולות להתחבר לכל שקע Unix. ב-Linux וב-WSL2 הן יכולות גם להתחבר לשקעי VM, משפחת הכתובות AF_VSOCK
  • false: ארגז החול חוסם חיבורי שקע Unix: ב-macOS חוץ מהנתיבים ב-allowUnixSockets, וב-Linux וב-WSL2 דרך מסנן seccomp כשהוא קיים
• ברירת מחדל: false

{
  "sandbox": {
    "network": {
      "allowAllUnixSockets": true
    }
  }
}

ב-WSL2, true גם פותח מחדש את שקע ה-interop שמפעיל קבצי בינארי של Windows כמו cmd.exe ו-powershell.exe.

#sandbox.network.allowLocalBinding

מאפשר לפקודות בתוך ארגז החול ב-macOS להאזין ביציאות רשת, למשל כדי להפעיל שרת פיתוח, ולהתחבר לכל יציאה ב-localhost. פקודה שמאזינה בכתובת שאינה loopback מקבלת חיבורים ממכונות אחרות. למפתח אין השפעה ב-Linux וב-WSL2, שם לכל פקודה בתוך ארגז החול יש ממשק loopback משלה. כדי להגיע לשרת במארח מ-Linux או מ-WSL2, ראו פקודה נכשלת בהגעה לשרת ב-localhost.

• היקף: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: בוליאני
  • true: פקודות בתוך ארגז החול ב-macOS יכולות להאזין בכל כתובת מקומית ולהתחבר לכל יציאה ב-localhost
  • false: פקודות בתוך ארגז החול ב-macOS לא יכולות להאזין ביציאה או להתחבר ישירות לשרתים ב-localhost
• ברירת מחדל: false

{
  "sandbox": {
    "network": {
      "allowLocalBinding": true
    }
  }
}

#sandbox.network.allowMachLookup

רשימת שמות שירותי XPC ו-Mach נוספים שארגז החול של macOS רשאי לחפש. כלים שמתקשרים דרך XPC, כמו iOS Simulator או Playwright, צריכים ששירותיהם יופיעו כאן. פקודות בתוך ארגז החול יכולות להגיע מחוץ לארגז החול לכל שירות שאתם רושמים, וארגז החול לא מגביל את מה שהשירותים האלה עושים עבור הפקודות האלה.

• היקף: Any file, עם מגבלות על הגדרות פרויקט ומקומיות
• סוג: מערך של מחרוזות, כל אחת שם שירות. * יחיד בסוף מתאים לקידומת, ו-"*" לבדו מתאים לכל שירות
• ברירת מחדל: לא מוגדר

זה מתיר כל שירות תחת הקידומת com.apple.CoreSimulator.:

{
  "sandbox": {
    "network": {
      "allowMachLookup": ["com.apple.CoreSimulator.*"]
    }
  }
}

#sandbox.network.allowedDomains

התרה מראש של דומיינים לתעבורה יוצאת מפקודות בתוך ארגז החול, כך שארגז החול לא מבקש אישור עבורם. תווים כלליים כמו *.example.com מתאימים לתת-דומיינים, וסיומת :port אופציונלית מגבילה רשומה ליציאה אחת. רשומה בלי יציאה מתאימה לכל יציאה.

• היקף: Any file, עם מגבלות על הגדרות פרויקט ומקומיות. רק הגדרות מנוהלות כש-allowManagedDomainsOnly מוגדר.
• סוג: מערך של מחרוזות, כל אחת דומיין, תבנית תו כללי, או ליטרל IP, עם סיומת :port אופציונלית
• ברירת מחדל: לא מוגדר, כך שמצב ההרשאה שלכם מחליט מה קורה לכל מארח חדש

זה מתיר מראש את GitHub בכל יציאה, כל תת-דומיין של npm, ומארח API אחד ביציאה 443 בלבד:

{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "api.example.com:443"]
    }
  }
}

כתבו ליטרלים של IPv6 בסוגריים מרובעים, עם יציאה אופציונלית: "[::1]" מתיר כל יציאה ו-"[::1]:443" יציאה אחת. הצורה עם סוגריים מרובעים דורשת Claude Code v2.1.229 או חדש יותר. ראו כתובות IPv6 ברשימות דומיינים.

#sandbox.network.deniedDomains

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

• היקף: Any file
• סוג: מערך של מחרוזות, כל אחת דומיין, תבנית תו כללי, או ליטרל IP, עם סיומת :port אופציונלית
• ברירת מחדל: לא מוגדר

{
  "sandbox": {
    "network": {
      "deniedDomains": ["sensitive.cloud.example.com"]
    }
  }
}

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

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

#sandbox.network.strictAllowlist

מונע מפקודות בארגז חול גישה למארחים שמחוץ לרשימת ההיתר, במקום לבקש אישור. רשימת ההיתר היא allowedDomains בתוספת דומיינים מכללי allow של WebFetch(domain:...), או רק הרשומות מהגדרות מנוהלות כאשר allowManagedDomainsOnly מוגדר. נעילות שחלות בלי ארגז חול שנדרש לו מנהל מכסות את הרשומות של מאגר. דורש את Claude Code בגרסה v2.1.219 או מאוחרת יותר.

• היקף: משתמש או מנוהל. מאגר לא יכול להפעיל או לכבות את זה.
• סוג: בוליאני
  • true: Claude Code מונע מפקודות בארגז חול גישה למארחים שמחוץ לרשימת ההיתר
  • false: אלא אם קובץ הגדרות מהימן אחר מגדיר true, Claude Code מחליט על מארח שמחוץ לרשימת ההיתר לפי מצב הרשאה במקום לדחות אותו מיד: במצב auto הוא בודק את המארח מול הדומיינים המותרים לפי פקודה של הפקודה, במצב dontAsk הוא דוחה, במצב bypassPermissions ובסשנים אינטראקטיביים של מסוף במצב plan שבהם bypass זמין הוא מתיר, ובשאר המקרים הוא שואל אותך
• ברירת מחדל: false

{
  "sandbox": {
    "network": {
      "strictAllowlist": true
    }
  }
}

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

#sandbox.network.allowManagedDomainsOnly

נועל את רשימת ההיתר של הרשת למה שהגדרות מנוהלות מגדירות. Claude Code מכבד אז רק את allowedDomains וכללי allow של WebFetch(domain:...) מהגדרות מנוהלות, מתעלם מדומיינים מהגדרות משתמש, פרויקט, מקומיות ו --settings, וחוסם דומיין שאינו מותר באופן אוטומטי במקום לבקש אישור.

• היקף: מנוהל
• סוג: בוליאני
  • true: Claude Code מכבד רק את allowedDomains וכללי allow של WebFetch(domain:...) מהגדרות מנוהלות, וחוסם דומיין שאינו מותר במקום לבקש אישור
  • false: דומיינים מקובצי הגדרות אחרים יכולים להתמזג לתוך רשימת ההיתר
• ברירת מחדל: false

זה נועל את רשימת ההיתר ל GitHub ול npm, ומתעלם מכל דומיין שמפתחים מוסיפים:

{
  "sandbox": {
    "network": {
      "allowManagedDomainsOnly": true,
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

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

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

#sandbox.network.httpProxyPort

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

• היקף: כל קובץ, אלא אם הגדרות ארגז חול אחרות מגבילות אילו קבצים יכולים להגדיר פורט
• סוג: מספר, פורט TCP מקומי
• ברירת מחדל: לא מוגדר, כך ש Claude Code מריץ פרוקסי משלו

{
  "sandbox": {
    "network": {
      "httpProxyPort": 8080
    }
  }
}

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

#sandbox.network.socksProxyPort

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

• היקף: כל קובץ, אלא אם הגדרות ארגז חול אחרות מגבילות אילו קבצים יכולים להגדיר פורט
• סוג: מספר, פורט TCP מקומי
• ברירת מחדל: לא מוגדר, כך ש Claude Code מריץ פרוקסי משלו

{
  "sandbox": {
    "network": {
      "socksProxyPort": 8081
    }
  }
}

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

#sandbox.network.tlsTerminate

גורם לפרוקסי של ארגז החול לסיים TLS כדי שיוכל לקרוא את תוכן בקשות HTTPS. זה ניסיוני, והחלפת אישורים מסוג mask דורשת את זה. הגדר {} כדי ליצור רשות אישורים זמנית לסשן, או הגדר את caCertPath ואת caKeyPath כדי להשתמש ברשות משלך.

• היקף: משתמש או מנוהל. מאגר לא יכול להפעיל את זה או לספק רשות אישורים.
• סוג: אובייקט עם מחרוזות אופציונליות caCertPath ו caKeyPath, כל אחת נתיב קובץ
• ברירת מחדל: לא מוגדר, כך שהפרוקסי לא מסיים TLS ולא בודק אותו

{
  "sandbox": {
    "network": {
      "tlsTerminate": {}
    }
  }
}

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

#זיכרון והקשר

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

#autoCompactEnabled

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code דוחס את השיחה אוטומטית כשההקשר מתקרב למגבלה
  • false: Claude Code לא דוחס אוטומטית
• ברירת מחדל: true
• עקיפות לסשן: DISABLE_AUTO_COMPACT מכבה דחיסה אוטומטית לסשן אחד. מי משניהם שמכבה את זה, השני לא יכול להפעיל את זה מחדש

{
  "autoCompactEnabled": false
}

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

#autoCompactWindow

מגדיר כמה חלון ההקשר מתמלא לפני ש Claude Code דוחס אוטומטית.

• היקף: כל קובץ
• סוג: מספר טוקנים, מ 100000 עד 1000000. Claude Code מגביל את הערך לחלון ההקשר של המודל שלך. סקירת המודלים מפרטת את החלון של כל מודל
• ברירת מחדל: לא מוגדר, כך ש Claude Code בוחר חלון שמותאם למודל שלך
• עקיפות לסשן: --autocompact גובר על המפתח הזה לסשן אחד, ו CLAUDE_CODE_AUTO_COMPACT_WINDOW גובר על שניהם אלא אם Claude Code מתעלם מערך המשתנה

{
  "autoCompactWindow": 500000
}

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

#autoMemoryDirectory

שומר זיכרון אוטומטי בתיקייה שאתה בוחר במקום ברירת המחדל לפי פרויקט.

• היקף: כל קובץ
• סוג: מחרוזת, נתיב תיקייה מוחלט או עם קידומת ~/
• ברירת מחדל: לא מוגדר, כך ש Claude Code משתמש ב ~/.claude/projects/<project>/memory/

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

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

#autoMemoryEnabled

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: זהה למצב לא מוגדר. הזיכרון האוטומטי נשאר מופעל אלא אם משהו שגובר על המפתח הזה מכבה אותו לסשן, כמו --bare, מצב בטוח, או CLAUDE_CODE_DISABLE_AUTO_MEMORY
  • false: Claude לא קורא מתיקיית הזיכרון האוטומטי ולא כותב אליה
• ברירת מחדל: true
• עקיפות לסשן: CLAUDE_CODE_DISABLE_AUTO_MEMORY גובר על המפתח הזה לסשן אחד, בכל אחד מהכיוונים

{
  "autoMemoryEnabled": false
}

#bashOutputMaxChars

מגדיר כמה תווים מהפלט ש Claude מקבל ישירות של פקודת Bash או PowerShell שהצליחה. כשהפלט עובר את המגבלה, Claude Code שומר אותו לקובץ ו Claude מקבל תצוגה מקדימה קצרה בתוספת נתיב הקובץ. העלה את המגבלה כשפלט פקודה, כמו בנייה מפורטת או יומן של חבילת בדיקות מלאה, חורג באופן קבוע מברירת המחדל ואתה רוצה ש Claude יקרא אותו בלי לפתוח את הקובץ. דורש את Claude Code בגרסה v2.1.261 או מאוחרת יותר.

• היקף: כל קובץ
• סוג: מספר תווים, מספר שלם חיובי. Claude Code מצמצם את הערך לטווח 4000 עד 128000
• ברירת מחדל: לא מוגדר, כך ש Claude מקבל עד 30,000 תווים ישירות

{
  "bashOutputMaxChars": 100000
}

כשמגדירים את המפתח הזה, Claude Code מתעלם ממשתנה הסביבה BASH_MAX_OUTPUT_LENGTH.

#claudeMd

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

• היקף: מנוהל
• סוג: מחרוזת, הטקסט של קובץ CLAUDE.md. כתוב אותו כמו שהיית כותב את הקובץ, כולל Markdown, עם מעברי שורה כ \n
• ברירת מחדל: לא מוגדר

הדוגמה הזו פורסת שני כללים כרשימת Markdown קצרה:

{
  "claudeMd": "# Engineering rules\n\n- Always run make lint before committing.\n- Never push directly to main."
}

ראה פריסת CLAUDE.md לכל הארגון.

#claudeMdExcludes

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

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

{
  "claudeMdExcludes": ["**/vendor/**/CLAUDE.md"]
}

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

#env

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

• Scope: Any file
• Type: אובייקט שממפה שמות משתנים לערכי מחרוזת
• Default: לא מוגדר

הדוגמה הזו מכבה דחיסה אוטומטית ומנתבת בקשות API דרך פרוקסי:

{
  "env": {
    "DISABLE_AUTO_COMPACT": "1",
    "ANTHROPIC_BASE_URL": "https://proxy.example.com"
  }
}

#איך ערכי env מתנהגים מול המעטפת

• ערך כאן דורס את אותו משתנה שיוצא במעטפת, וכשיותר מקובץ הגדרות אחד מגדיר משתנה, חל זה עם הקדימות הגבוהה ביותר. משתנים שקלוד קוד מתעלם מהם ב-env מפרט את החריגים להגדרות פרויקט ולהגדרות מקומיות.
• כשאפליקציית Claude Desktop או רץ של סביבה מתארחת עצמית מפעילים את הסשן, סביבת ההפעלה שהוא בונה מקבלת קדימות במקום: קלוד קוד מתעלם מערך env מכל קובץ הגדרות למשתנה שסביבת ההפעלה כבר מגדירה. יומן הדיבוג מציין כל משתנה שהתעלמו ממנו.
• כדי לבטל ייצוא של המעטפת, מגדירים את המשתנה ל-"". קלוד קוד מתייחס לערך ריק כלא מוגדר לבחירת ספק, ותהליכי משנה יורשים את הערך הריק.
• NO_COLOR ו-FORCE_COLOR שמוגדרים כאן מגיעים רק לתהליכי משנה. כדי לשנות את צבעי הממשק של קלוד קוד עצמו, מגדירים אותם במעטפת לפני שמפעילים את claude.
• הערכים כאן הם טקסט רגיל בקובץ ההגדרות ומגיעים לכל תהליך משנה שקלוד קוד מפעיל. עבור אסימון bearer של OTLP שמתחלף, משתמשים ב-otelHeadersHelper. עבור אישורי API, משתמשים ב-apiKeyHelper.

#מתי קלוד קוד מיישם ערכי env

• מהגדרות משתמש, --settings והגדרות מנוהלות: בהפעלה, ושוב בסשן הפעיל כששינוי שנשמר משנה את env הממוזג.
• מהגדרות פרויקט והגדרות מקומיות: אחרי שסומכים על סביבת העבודה, או בהפעלה במצב -p, שלעולם לא מציג את דו שיח האמון, ושוב כששינוי שנשמר משנה את env הממוזג.
• משתנים שקלוד קוד מסווג כבטוחים, כמו בחירת מודל, פסקי זמן ומגבלות, ומתגי תכונות: בהפעלה מכל קובץ הגדרות, מלבד המשתנים שהגדרות פרויקט והגדרות מקומיות לא יכולות להגדיר.
• אחרי העברת הסשן עם /cd בגרסה v2.1.246 או מאוחרת יותר: ערכי env של הפרויקט ושל ההגדרות המקומיות בתיקייה החדשה, מעל אלה של התיקייה הקודמת.

#משתנים שקלוד קוד מתעלם מהם ב-env

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

  • משתנים שבוחרים איפה קלוד קוד מאחסן או כותב את הקבצים שלו: CLAUDE_CONFIG_DIR, CLAUDE_CODE_TMPDIR, ומשתני תיקיות של מערכת ההפעלה כמו HOME, TMPDIR, TMP, TEMP ומשפחת XDG_*.

  • משתני Windows שבוחרים את התוכניות ואת התצורה ברמת המכונה לתהליכים שקלוד קוד מפעיל, כמו SystemRoot, ComSpec, ProgramData, LOCALAPPDATA, PATHEXT, PSModulePath ומשפחת ProgramFiles.

  • משתנים שמייצאים תוכן סשן: OTEL_LOG_RAW_API_BODIES וצמד המעקב המפורט של הבטא ENABLE_BETA_TRACING_DETAILED ו-BETA_TRACING_ENDPOINT.

  • משתני מייצא OpenTelemetry שמפעילים טלמטריה, בוחרים לאן היא הולכת, או בוחרים איזה תוכן היא לוכדת:

    • CLAUDE_CODE_ENABLE_TELEMETRY, ועוד צמד הבטא של הטלמטריה המורחבת CLAUDE_CODE_ENHANCED_TELEMETRY_BETA ו-ENABLE_ENHANCED_TELEMETRY_BETA
    • בוררי המייצא OTEL_LOGS_EXPORTER, OTEL_METRICS_EXPORTER ו-OTEL_TRACES_EXPORTER
    • משתני התוכן OTEL_LOG_USER_PROMPTS, OTEL_LOG_ASSISTANT_RESPONSES, OTEL_LOG_TOOL_CONTENT ו-OTEL_LOG_TOOL_DETAILS
    • משתני OTEL_EXPORTER_OTLP_* ששמם מסתיים ב-_ENDPOINT, _HEADERS, _PROTOCOL, _CERTIFICATE, _CLIENT_KEY או _INSECURE, בצורה הכללית ובצורה לפי אות, כמו OTEL_EXPORTER_OTLP_ENDPOINT ו-OTEL_EXPORTER_OTLP_METRICS_HEADERS
    • OTEL_EXPORTER_PROMETHEUS_HOST ו-OTEL_EXPORTER_PROMETHEUS_PORT

    רק הערכים האלה עדיין חלים מהגדרות פרויקט ומהגדרות מקומיות, כי הם מכבים משהו: none לשלושת בוררי המייצא, וערך כיבוי כמו 0 עבור OTEL_LOG_USER_PROMPTS, OTEL_LOG_TOOL_CONTENT ו-OTEL_LOG_TOOL_DETAILS. ערך כזה דורס את אותו משתנה בהגדרות המשתמש, אבל לא ערך שסביבת ההפעלה של קלוד קוד, קובץ --settings או הגדרות מנוהלות מגדירים.

    כשקובץ הגדרות פרויקט או הגדרות מקומיות מגדיר משתנה בקבוצה הזו, סשן אינטראקטיבי מקומי מציג הודעה בהפעלה. מריצים /status או claude doctor כדי לראות מאילו קלוד קוד התעלם ואילו כיבו טלמטריה. שניהם מציגים שמות, אף פעם לא ערכים. הרצה לא אינטראקטיבית עם -p או סשן Agent SDK לא מציגה הודעה, לכן בודקים שהאוסף עדיין מקבל נתונים אחרי שדרוג. אם לא, מגדירים את המשתנים בהגדרות המשתמש, בהגדרות מנוהלות, בסביבת המשימה, או בקובץ שמעבירים עם --settings.

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

  • משתנים שמשנים איך קלוד קוד מופעל או מסתנכרן, כמו CLAUDE_CODE_PROCESS_WRAPPER, CLAUDE_CODE_SYNC_SKILLS, CLAUDE_CODE_SYNC_PLUGINS, CLAUDE_CODE_PLUGIN_CACHE_DIR ו-CLAUDE_CODE_PLUGIN_SEED_DIR.

  • משתנים שמגדירים את הכניסה ל-claude.ai, כמו CLAUDE_CODE_OAUTH_TOKEN, CLAUDE_CODE_OAUTH_REFRESH_TOKEN ו-CLAUDE_CODE_OAUTH_SCOPES.

  • משתנה מצב קורא מסך CLAUDE_AX_SCREEN_READER והמשתנים האחרים ששמם מתחיל ב-CLAUDE_AX_, כמו CLAUDE_AX_STARTUP_QUIET_MS.

  • CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS, שמגדיר את הטיימר על דו שיח שלא נענה.

  • CLAUDE_CODE_DISABLE_ATTACHMENTS, שמכבה עיבוד קבצים מצורפים.

  • CLAUDE_CODE_DISABLE_FILE_MENTIONS, שעוצר את קלוד קוד מהרחבת אזכורי @ של קבצים ותיקיות.

  לפני v2.1.251, הגדרות פרויקט והגדרות מקומיות יכלו גם להגדיר את המשתנים ברשימה הזו שבוחרים איפה קלוד קוד כותב את הקבצים שלו או שמייצאים תוכן סשן, מלבד HOME ו-XDG_CONFIG_HOME. לפני v2.1.290, הן יכלו גם להגדיר את משתני טיימר הדו שיח ואת CLAUDE_CODE_DISABLE_ATTACHMENTS.

• משתני זהות שסביבות האירוח של קלוד קוד מחזיקות, כמו CLAUDE_CODE_REMOTE ו-CLAUDE_CODE_ACCOUNT_UUID, מתעלמים מהם מכל קובץ.

• CLAUDE_CODE_MESSAGING_SOCKET ו-CLAUDE_CODE_MESSAGING_TOKEN, שקלוד קוד מייצא בעצמו, מתעלמים מהם מכל קובץ. התעלמות ממשתנה הסוקט דורשת קלוד קוד v2.1.224 או מאוחר יותר, והתעלמות מהאסימון דורשת v2.1.228 או מאוחר יותר.

• CLAUDE_CODE_PROJECT_DIR_NAME, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים ממנו מכל קובץ. דורש v2.1.234 או מאוחר יותר.

• CLAUDE_CODE_RESTRICTED, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים ממנו מכל קובץ.

• CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים ממנו מכל קובץ. המשתנה דורש קלוד קוד v2.1.283 או מאוחר יותר.

• CLAUDE_CODE_DISABLE_DANGEROUS_RM_TIMEOUT, CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT, CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT ו-CLAUDE_CODE_DISABLE_MOUNTED_DRIVE_RM_PROMPT, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים מהם מכל קובץ.

• CLAUDE_CODE_EVEN_MORE_DANGEROUSLY_SKIP_PERMISSIONS, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים ממנו מכל קובץ.

• CLAUDE_CODE_WARN_DISK_FREE_GIB ו-CLAUDE_CODE_WARN_MEMORY_FREE_GIB, שקלוד קוד קורא רק מסביבת ההפעלה, מתעלמים מהם מכל קובץ. המשתנים דורשים קלוד קוד v2.1.304 או מאוחר יותר.

#fileCheckpointingEnabled

גורם לקלוד קוד לצלם קבצים לפני כל עריכה כדי ש-/rewind יוכל לשחזר אותם. מופיע ב-/config כ-Rewind code (checkpoints), והחלפת המצב שם כותבת את המפתח הזה להגדרות המשתמש.

• Scope: Any file
• Type: בוליאני
  • true: קלוד קוד מצלם קבצים לפני כל עריכה כדי ש-/rewind יוכל לשחזר אותם
  • false: קלוד קוד לא מצלם קבצים, ולכן /rewind לא יכול לשחזר אותם
• Default: true
• Per-session overrides: CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING מכבה צילום נקודות ביקורת לסשן אחד. מי משניהם שמכבה אותו, השני לא יכול להפעיל אותו בחזרה

{
  "fileCheckpointingEnabled": false
}

בהרצת -p או בסשן Agent SDK, קלוד קוד מתעלם מהמפתח הזה. ה-SDK מפעיל צילום נקודות ביקורת עם האפשרות enableFileCheckpointing, והרצת -p בלי תוספות צריכה CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true. ראו File checkpointing in the Agent SDK.

#idleCompaction

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

• Terminal: שורה שמתחילה ב-Compacted while idle, before the prompt cache expired
• לוח הצ'אט של VS Code: הודעה שכוללת a summary written while you were away
• אפליקציית שולחן העבודה: אותה הודעה, בתוך שורה שהתווית שלה כוללת Claude Code notice. אם לא רואים את השורה או את הטקסט שלה, עוברים ל-מצב תצוגה Verbose.

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

• Session: אתם בסשן טרמינל אינטראקטיבי, בלוח הצ'אט של תוסף VS Code, או בלשונית Code של אפליקציית שולחן העבודה כשהסשן רץ על המחשב או דרך SSH
• Auto-compaction: autoCompactEnabled פועל
• Prompt cache: השיחה נמצאת על TTL של מטמון הפרומפט לשעה
• Size: ההקשר של השיחה הגיע לסף האסימונים, שאפשר לשנות מברירת המחדל של 200,000
• Idle time: עברה בערך שעה מאז הבקשה האחרונה, והמחשב נשאר ער עד אז

כדי לכבות דחיסת סרק, מגדירים את המפתח הזה ל-false.

• Scope: Any file
• Type: בוליאני
  • true: קלוד קוד דוחס שיחות סרק שעומדות בתנאים
  • false: קלוד קוד לא דוחס בזמן שהסשן בסרק
• Default: true
• Per-session overrides: DISABLE_AUTO_COMPACT מכבה דחיסת סרק יחד עם דחיסה אוטומטית

{
  "idleCompaction": false
}

כדי לכבות או להפעיל דחיסת סרק מתוך סשן טרמינל, מריצים /config ומשנים את השורה Idle compaction. הבחירה נשמרת בהגדרות המשתמש וחלה מיד. השורה דורשת קלוד קוד v2.1.302 או מאוחר יותר. אם מריצים אחת מהגרסאות האלה ו-/config לא מציג את השורה, בודקים את הסיבות האלה:

• Another settings source sets the key: ערך בהגדרות מנוהלות, בדגל --settings, או בקובץ הגדרות פרויקט או הגדרות מקומיות דורס את הגדרות המשתמש. משנים את המפתח במקור הזה
• Feature flags are unavailable on a version before v2.1.314: כשקלוד קוד לא יכול למשוך דגלי תכונות מ-Anthropic, דחיסת סרק לא רצה, ולכן אין מה לכבות

המפתח דורש קלוד קוד v2.1.290 או מאוחר יותר. בגרסה מוקדמת יותר, שמתעלמת מהמפתח הזה, מכבים את autoCompactEnabled כדי לעצור דחיסת סרק.

#שינוי סף דחיסת הסרק

מגדירים את CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS למספר האסימונים שההקשר של שיחה חייב להגיע אליו לפני שדחיסת סרק חלה עליה. משתמשים במספר שלם חיובי. ערכים מתחת ל-100000 מועלים ל-100000, הסף הנמוך ביותר.

כברירת מחדל, שיחה על חלון הקשר של 200K נדחסת אוטומטית לפני שהיא מגיעה ל-200,000 אסימונים. הדוגמה הזו מורידה את הסף ל-150,000 כדי שהשיחות האלה יתאימו:

{
  "env": {
    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "150000"
  }
}

#דחיסת סרק ב-VS Code ובאפליקציית שולחן העבודה

הודעה כמו זו אומרת שקלוד קוד החליף את השיחה הקודמת בסיכום שקלוד עובד ממנו עכשיו:

Compacted using a summary written while you were away · turn off with "idleCompaction": false in settings.json

לא צריך לעשות כלום. כדי לכבות דחיסת סרק, מגדירים את idleCompaction ל-false ב-~/.claude/settings.json במכונה או בהפצת WSL שבה הסשן רץ, או בקובץ הגדרות אחר.

#plansDirectory

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

• Scope: Any file
• Type: מחרוזת, נתיב יחסי לשורש הפרויקט
• Default: לא מוגדר, ולכן קלוד קוד משתמש ב-~/.claude/plans

{
  "plansDirectory": "./plans"
}

קלוד קוד מאחסן תוכניות ב-~/.claude/plans במקום בתיקייה שהוגדרה במקרים כמו אלה:

• Outside the project root: הנתיב נפתר מחוץ לשורש הפרויקט, כמו ש-"../plans" עושה.
• Backslash on macOS, Linux, and WSL: הנתיב שנפתר מכיל לוכסן הפוך, כמו ש-"docs\\plans" בסגנון Windows עושה. כותבים "docs/plans", שפועל גם ב-Windows.

#skillListingBudgetFraction

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

• Scope: Any file
• Type: מספר, שבר גדול מ-0 ולכל היותר 1
• Default: 0.01, ששומר 1% מחלון ההקשר

{
  "skillListingBudgetFraction": 0.02
}

כדי לראות כמה הקשר הרשימה משתמשת ואילו כישורים תורמים הכי הרבה, מריצים /doctor.

#skillListingMaxDescChars

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

• Scope: Any file
• Type: מספר תווים, מספר שלם חיובי
• Default: 1536

{
  "skillListingMaxDescChars": 2048
}

מעלים אותו כדי לשמור תיאורים ארוכים שלמים במחיר של יותר הקשר בכל תור. מורידים אותו כדי להתאים יותר כישורים תחת skillListingBudgetFraction.

#taskOutputMaxChars

[!WARNING]

הוסר ב-v2.1.277, יחד עם כלי TaskOutput שאותו הוא קבע בגודל. הגדרה שלו לא משפיעה על הגרסאות הנוכחיות. קלוד קורא את קובץ הפלט של משימת רקע עם Read במקום.

עד v2.1.276, מגדירים את המפתח הזה למספר התווים מפלט של משימת רקע שקלוד קיבל בשורה כשקרא את המשימה עם הכלי TaskOutput.

#ממשק וטרמינל

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

#askUserQuestionTimeout

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

• היקף: משתמש או מנוהל
• סוג: מחרוזת, אחת מבין "60s", "5m", "10m", או "never"
• ברירת מחדל: "never"

{
  "askUserQuestionTimeout": "5m"
}

מופיע ב-/config בשם Question auto-continue timeout, שכותב את המפתח הזה להגדרות המשתמש. Claude Code מסתיר את השורה כל עוד הגדרות מנוהלות או הדגל --settings מגדירים את המפתח.

#autoContinueAtUsageLimit

אחרי שמגבלת שימוש של claude.ai עוצרת את הסשן, המתינו בסשן הפתוח והמשיכו את המשימה אוטומטית אחרי האיפוס. ראו כיבוי המשך האוטומטי. נדרש Claude Code בגרסה v2.1.234 או חדשה יותר.

• היקף: משתמש או מנוהל. נקרא מהגדרות משתמש, מ---settings ומהגדרות מנוהלות בלבד. כשאף אחד מאלה לא מגדיר את המפתח, קובץ הגדרות של פרויקט או קובץ הגדרות מקומי שמגדיר אותו מכבה את היכולת, במקום שהערך יתעלם.
• סוג: בוליאני
  • true: אחרי שמגבלת שימוש של claude.ai עוצרת את הסשן, Claude Code ממתין בסשן הפתוח וממשיך את המשימה אוטומטית אחרי האיפוס
  • false: Claude Code לא מתחיל את ההמתנה בעצמו. עדיין אפשר להתחיל המתנה בעצמכם מתפריט האפשרויות של מגבלת השימוש
• ברירת מחדל: true

{
  "autoContinueAtUsageLimit": false
}

מופיע ב-/config בשם Continue automatically at usage limit, שכותב את המפתח הזה להגדרות המשתמש. Claude Code מסתיר את השורה כל עוד הגדרות מנוהלות או הדגל --settings מגדירים את המפתח.

#autoScrollEnabled

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: השיחה עוקבת אחרי פלט חדש עד לתחתית
  • false: נשארים במקום שאליו גללתם בזמן ש-Claude ממשיך לעבוד. בקשות הרשאה עדיין מופיעות מתחת לתמליל
• ברירת מחדל: true

{
  "autoScrollEnabled": false
}

מופיע ב-/config בשם Auto-scroll כשרינדור במסך מלא פעיל, שכותב את המפתח הזה להגדרות המשתמש.

#axScreenReader

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

• היקף: משתמש או מנוהל. אפשר גם להגדיר את המפתח בקובץ שמועבר עם --settings. Claude Code מתעלם מהמפתח בהגדרות פרויקט ובהגדרות מקומיות, כך שמאגר לא יכול, וגם הקובץ .claude/settings.local.json שלכם לא יכול, להפעיל או לכבות מצב קורא מסך.
• סוג: בוליאני
  • true: Claude Code מציג טקסט שטוח בלי מסגרות דקורטיביות או אנימציות, באמצעות המרנדר הקלאסי
  • false: Claude Code מציג כרגיל
• ברירת מחדל: לא מוגדר, ולכן מצב קורא מסך כבוי
• עקיפות לכל סשן: --ax-screen-reader גובר על CLAUDE_AX_SCREEN_READER, ושניהם גוברים על המפתח הזה לסשן אחד

{
  "axScreenReader": true
}

#bashEditDiffEnabled

בחרו אם Claude Code מתעד אילו קבצים השתנו במאגר Git בזמן שפקודת Bash רצה. כשהוא מתעד אותם, רואים את ה-diff שלהם בטרמינל אחרי הפקודה, והוקים של PostToolUse ל-Bash מקבלים את רשימת הקבצים שהשתנו.

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

הגדירו את המפתח ל-true כדי לתעד אותם בכל מצב הרשאה. נדרש Claude Code בגרסה v2.1.269 או חדשה יותר.

• היקף: משתמש או מנוהל. ערך true נספר רק כשהוא מגיע מהגדרות המשתמש שלכם, מ-JSON שמועבר עם --settings, או מהגדרות מנוהלות, כך ש-true בקובץ .claude/settings.json או .claude/settings.local.json של מאגר לא יכול להפעיל את התיעוד. ערך false בכל אחד מקבצי המאגר עדיין מכבה את התיעוד, אלא אם קובץ בקדימות גבוהה יותר מגדיר true.
• סוג: בוליאני
• ברירת מחדל: לא מוגדר, ולכן Claude Code מתעד שינויים במצב auto ובמצב bypassPermissions כשהוא מכוון את Claude לערוך קבצים דרך Bash
• עקיפות לכל סשן: CLAUDE_CODE_BASH_EDIT_DIFF גובר על המפתח הזה לסשן אחד

{
  "bashEditDiffEnabled": true
}

#companyAnnouncements

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

• היקף: כל קובץ
• סוג: מערך של מחרוזות
• ברירת מחדל: לא מוגדר, ולכן לא מוצגת הודעה

{
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.example.com"
  ]
}

#defaultShell

בחרו אם Bash או PowerShell מריצים את פקודות המעטפת שאתם מקלידים עם הקידומת ! בתיבת הקלט, אלה ש-Claude Code מריץ ישירות ומוסיף לסשן.

"powershell" פועל רק כשכלי PowerShell פעיל. הכלי פעיל כברירת מחדל ב-Windows בלי Git Bash, וב-Windows עם Git Bash עבור חשבונות claude.ai ו-Console. בסשנים של Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry, וב-macOS, Linux ו-WSL, הגדירו CLAUDE_CODE_USE_POWERSHELL_TOOL=1 כדי להפעיל את הכלי. הגדירו את המשתנה ל-0 כדי לכבות את הכלי.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מבין:
  • "bash": Claude Code מריץ את פקודות ! שלכם ב-Bash
  • "powershell": Claude Code מריץ את פקודות ! שלכם ב-PowerShell
• ברירת מחדל: "bash", או "powershell" ב-Windows כש-Bash לא זמין

{
  "defaultShell": "powershell"
}

אם המעטפת שציינתם לא זמינה, Claude Code משתמש באחרת: "powershell" עובר ל-Bash כשכלי PowerShell כבוי, ו-"bash" עובר ל-PowerShell כש-Bash לא מותקן.

#dialogExpiry

הגדירו את המועד האחרון לדיאלוגים ש-Claude Code מעביר ללקוח מרוחק, כגון מארח Remote Control או SDK, ולדיאלוג האישור של הודעה בין סשנים שמוחזקת. ב-Claude Code v2.1.236 או חדש יותר, אותו מועד אחרון תוחם את בקשת ההסכמה לקרדיטי השימוש של Fable באמצע הסשן, בסשן שאולי אין בו אף אחד ליד הטרמינל. כשלא מגיעה תשובה לפני המועד האחרון, Claude Code מבטל את הדיאלוג וממשיך עם ברירת המחדל של חוסר פעולה. נדרש Claude Code בגרסה v2.1.224 או חדשה יותר.

• היקף: משתמש או מנוהל
• סוג: מחרוזת, אחת מבין "60s", "5m", "10m", או "never", שמבטל את המועד האחרון
• ברירת מחדל: "5m"
• עקיפות לכל סשן: CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS גובר על המפתח הזה לסשן אחד

{
  "dialogExpiry": "10m"
}

בקשות הרשאה ושאלות AskUserQuestion משתמשות בתהליכים משלהן, והמועד האחרון הזה לא חל עליהן. מופיע ב-/config בשם Dialog expiry, שכותב את המפתח הזה להגדרות המשתמש. השורה דורשת Claude Code בגרסה v2.1.232 או חדשה יותר, ו-Claude Code מסתיר אותה כל עוד הגדרות מנוהלות או הדגל --settings מגדירים את המפתח.

#editorMode

בחרו את מצב קיצורי המקשים לשורת הקלט.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מבין:
  • "normal": קיצורי מקשים סטנדרטיים בקלט השורה
  • "vim": עריכה בסגנון vim עם המצבים NORMAL, INSERT ו-VISUAL
• ברירת מחדל: "normal"

{
  "editorMode": "vim"
}

מופיע ב-/config בשם Editor mode, שכותב את המפתח הזה להגדרות המשתמש.

#emojiCompletionEnabled

הציגו הצעות אימוג'י כשמקלידים : ואחריו shortcode בקלט השורה, והחליפו shortcode שהושלם כגון :heart: באימוג'י שלו. הגדירו ל-false כדי לכבות את שניהם.

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מציג הצעות אימוג'י אחרי : ומחליף shortcode שהושלם באימוג'י שלו
  • false: Claude Code לא מציע אימוג'י ולא מחליף shortcodes
• ברירת מחדל: true

{
  "emojiCompletionEnabled": false
}

ראו קודי קיצור לאימוג'י.

#fileSuggestion

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

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

{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}

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

#קלט ופלט של הפקודה

Claude Code מריץ את הפקודה עם אותם משתני סביבה כמו הוקים, כולל CLAUDE_PROJECT_DIR, ומפסיק להמתין אחרי חמש שניות. הפקודה מקבלת JSON ב-stdin עם שדה query שמכיל את מה שהקלדתם עד כה:

{"query": "src/comp"}

הדפיסו נתיבי קבצים מופרדים בשורות חדשות ל-stdout. Claude Code מציג לכל היותר 15:

src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx

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

#!/bin/bash
query=$(cat | jq -r '.query')
# Replace your-repo-file-index with your own file search command
your-repo-file-index --query "$query" | head -20

#footerLinksRegexes

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

• היקף: משתמש או מנוהל
• סוג: מערך של אובייקטים, כל אחד עם type שמוגדר ל-"regex", ביטוי pattern, תבנית url, ו-label אופציונלי. מצייני מקום {name} ב-url וב-label מתמלאים מקבוצות לכידה בעלות שם ב-pattern
• ברירת מחדל: לא מוגדר, ולכן לא מוצגים תגים

הדוגמה הזו מתאימה למפתחות תקלה כגון PROJ-1234 ובונה כל קישור מהמפתח שנלכד:

{
  "footerLinksRegexes": [
    {
      "type": "regex",
      "pattern": "\\b(?<key>PROJ-\\d+)\\b",
      "url": "https://issues.example.com/browse/{key}",
      "label": "{key}"
    }
  ]
}

עם ההגדרה הזו, כש-PROJ-1234 מופיע בתוצאת כלי או בתשובה של Claude, תג PROJ-1234 מופיע בכותרת התחתונה ומקשר אל https://issues.example.com/browse/PROJ-1234.

#מגבלות תג

ה-URL, התווית ומספר התגים של כל רשומה מוגבלים כך:

כשתור מסתיים, Claude Code מתאים את ביטוי ה-pattern של כל רשומה מול פלט התור בשרשור הראשי, ולכן ביטוי רגולרי איטי חוסם את ממשק המשתמש עד שהוא מסתיים. מכמתים מקוננים כגון (a+)+$ יכולים לקחת זמן מעריכי מול קלטים מסוימים ולהקפיא את הסשן, לכן שמרו על כל pattern לינארי והימנעו מקינון של + או *.

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

#keybindingFlavor

[!WARNING]

הוצא משימוש מאז v2.1.261 ואין לו השפעה. מקשי עריכת המילים של השורה תמיד עוקבים אחרי מוסכמות readline, כמו ב-Bash. Claude Code עדיין מקבל את keybindingFlavor, כך שקובץ הגדרות שמגדיר אותו נשאר תקין.

בגרסאות v2.1.238 עד v2.1.260, הגדרה ל-"readline" גרמה ל-Ctrl+W למחוק אחורה עד לרווח הלבן הקודם, במקום רק את המילה הקודמת.

• היקף: כל קובץ
• סוג: מחרוזת, "classic" או "readline"
• ברירת מחדל: לא מוגדר

#maxProseWidth

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

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

{
  "maxProseWidth": 80
}

#prefersReducedMotion

צמצמו או כבו אנימציות ממשק כגון הספינר, אפקט ה-shimmer ואפקטי הבזק. מופיע ב-/config בשם Reduce motion.

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מצמצם או מכבה אנימציות ממשק כגון הספינר, אפקט ה-shimmer ואפקטי הבזק
  • false: זהה למצב לא מוגדר. Claude Code מציג את האנימציות שלו
• ברירת מחדל: false

{
  "prefersReducedMotion": true
}

#promptSuggestionEnabled

הציגו או הסתירו הצעות פרומפט, התחזיות באפור שמופיעות בקלט הפרומפט שלכם. הגדירו ל-false, או כבו את Prompt suggestions ב-/config, כדי להסתיר אותן.

• היקף: כל קובץ
• סוג: בוליאני
  • true: רואים הצעות פרומפט בקלט הפרומפט
  • false: Claude Code מסתיר הצעות פרומפט
• ברירת מחדל: true
• עקיפות לכל סשן: CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION גובר על המפתח הזה לסשן אחד

{
  "promptSuggestionEnabled": false
}

הצעות פרומפט דורשות חשבון claude.ai או Console עם טלמטריה מופעלת. ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Microsoft Foundry, או כשהטלמטריה כבויה, למשל באמצעות DISABLE_TELEMETRY, למפתח הזה אין השפעה ורק CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=1 מפעיל אותן.

#respectGitignore

קבעו אם בורר הקבצים של @ משמיט קבצים שתואמים לדפוסי .gitignore. מופיע ב-/config בשם Respect .gitignore in file picker.

• היקף: כל קובץ. כשאף קובץ הגדרות לא מגדיר אותו, Claude Code חוזר ל-respectGitignore ב-~/.claude.json, שהמתג ב-/config כותב.
• סוג: בוליאני
  • true: בורר הקבצים של @ משמיט קבצים שתואמים לדפוסי .gitignore
  • false: בורר הקבצים של @ כולל קבצים שתואמים לדפוסי .gitignore
• ברירת מחדל: true

{
  "respectGitignore": false
}

#respondToBashCommands

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מוסיף את פלט הפקודה לשיחה ו-Claude עונה עליו
  • false: Claude Code מוסיף את הפלט להקשר בלי תשובה
• ברירת מחדל: true

{
  "respondToBashCommands": false
}

ראו מצב מעטפת עם הקידומת !.

#showClearContextOnPlanAccept

כאשר Claude מסיים תוכנית במצב תוכנית, הוא מציג תפריט אישור. תכנון יכול לצרוך הרבה הקשר, ולכן המפתח הזה מוסיף אפשרות ראשונה לתפריט הזה, Yes, clear context and …, שמאשרת את התוכנית, מנקה את הקשר השיחה, ומתחילה ליישם מתוך התוכנית בלבד. שאר התווית מציין את מצב ההרשאה שבו הסשן ממשיך, ומראה כמה מההקשר שלכם התכנון ניצל.

• היקף: כל קובץ
• סוג: בוליאני
  • true: תפריט אישור התוכנית מקבל אפשרות ראשונה, Yes, clear context and …, שמאשרת את התוכנית ומנקה את הקשר השיחה
  • false: תפריט אישור התוכנית לא מציג אפשרות לניקוי הקשר
• ברירת מחדל: false

{
  "showClearContextOnPlanAccept": true
}

#showTurnDuration

הציגו או הסתירו את הודעת משך התור אחרי כל תשובה, כמו "Cooked for 1m 6s · done 6:05 PM". השעון אחרי "done" מראה מתי התור הסתיים. timeFormat ו-timeZone שולטים בפורמט שלו ובאזור הזמן שלו. מופיע ב-/config בתור Show turn duration.

• היקף: כל קובץ. ערך ב-~/.claude.json מגרסה ישנה יותר חל כאשר אף קובץ הגדרות לא מגדיר אותו.
• סוג: בוליאני
  • true: אתם רואים את הודעת משך התור אחרי כל תשובה
  • false: Claude Code מסתיר את הודעת משך התור
• ברירת מחדל: true

{
  "showTurnDuration": false
}

#spellcheck

סמנו בקו תחתון מילים עם שגיאות כתיב בקלט ההנחיה בזמן ההקלדה, באמצעות בודק איות שאתם מתקינים. Claude Code בודק רק את הטקסט בתיבת הקלט. בדיקת איות בזמן ההקלדה מכסה התקנה של aspell, hunspell או ispell, ומה הבודק מכסה. נדרש Claude Code בגרסה v2.1.235 או חדשה יותר.

• היקף: משתמש או מנוהל. הבלוק מהרמה הגבוהה ביותר שמגדירה אותו חל כמכלול.
• סוג: אובייקט עם enabled (בוליאני), checker ("aspell", "hunspell", "ispell" או "auto"), language (מחרוזת, שמועברת לבודק כשם המילון שלו), ו-color (מחרוזת, שם צבע של מסוף, #rrggbb, rgb(r,g,b), ansi256(n) או ansi:<name>)
• ברירת מחדל: לא מוגדר, ולכן בדיקת האיות כבויה. checker ברירת המחדל שלו היא "auto", הראשון מבין השלושה שנמצא ב-PATH. language ברירת המחדל שלו היא המילון של הבודק עצמו. color ברירת המחדל שלו היא צבע השגיאה של ערכת הנושא

{
  "spellcheck": { "enabled": true, "language": "en_GB" }
}

#spinnerTipsEnabled

בזמן ש-Claude עובד, שורת הספינר עוברת בין טיפים קצרים על יכולות של Claude Code, כמו "Use Plan Mode to prepare for a complex request before making changes. Press Shift+Tab twice to enable." הגדירו את המפתח הזה ל-false כדי להסתיר אותם. מופיע ב-/config בתור Show tips.

• היקף: כל קובץ
• סוג: בוליאני
  • true: אתם רואים טיפים בספינר בזמן ש-Claude עובד
  • false: Claude Code מסתיר טיפי ספינר
• ברירת מחדל: true

{
  "spinnerTipsEnabled": false
}

#spinnerTipsOverride

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

אם תגדירו את spinnerTipsEnabled ל-false, Claude Code מסתיר את כל הטיפים, כולל שלכם.

• היקף: כל קובץ. Claude Code מכבד אובייקטי טיפ, tipsFile, label ו-excludeDefault מהגדרות המשתמש, מדגל --settings ומההגדרות המנוהלות. מהגדרות הפרויקט ומההגדרות המקומיות הוא קורא רק טיפים שהם מחרוזות פשוטות.
• סוג: אובייקט עם השדות tips, tipsFile, label ו-excludeDefault, וכל אחד מהם אופציונלי
• ברירת מחדל: לא מוגדר, ולכן Claude Code מציג רק את הטיפים המובנים

אובייקטי טיפ, tipsFile, label, והכלל בשורת ההיקף שלפיו הגדרות פרויקט והגדרות מקומיות תורמות רק מחרוזות פשוטות, דורשים Claude Code בגרסה v2.1.247 או חדשה יותר.

כל ערך ב-tips הוא מחרוזת פשוטה או אובייקט עם השדות האלה:

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

Claude Code קורא לכל היותר 200 טיפים מתוך tips ו-tipsFile יחד, ומשמיט ערך לא תקין עם אזהרת דיבוג במקום לדחות את קובץ ההגדרות.

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

• tipsFile: נתיב מוחלט או נתיב ~/ לקובץ JSON מקומי שמכיל מערך של אותם ערכים, או אובייקט עם מערך tips, עד 256 KB. Claude Code קורא את הקובץ פעם אחת לכל תהליך, ולכן הוא טוען את העריכות שלכם בהפעלה הבאה. אי אפשר להגדיר אותו דרך הגדרות שמנוהלות בשרת. הטמיעו שם את tips ישירות, או הטמיעו את הנתיב ב-managed-settings.json שעל הדיסק.
• label: הקידומת ש-Claude Code מציג לפני טיפים מהגדרות המשתמש, מ---settings ומההגדרות המנוהלות, עד 40 תווים. ברירת המחדל היא Tip, אותה קידומת כמו הטיפים המובנים, וטיפים מהגדרות הפרויקט ומההגדרות המקומיות תמיד משתמשים בה.
• excludeDefault: הגדירו אותו ל-true כדי להסתיר את הטיפים המובנים ולהציג רק את שלכם. כאשר Claude Code לא מצליח לטעון אף אחד מהטיפים שלכם, למשל כי tipsFile לא קיים או שכל ערך לא תקין, הוא שומר את הסבב המובנה במקום ספינר ריק.

כאשר יותר מקובץ הגדרות אחד מגדיר את המפתח, Claude Code מציג טיפים מכולם, ולוקח את tipsFile, label ו-excludeDefault מזה שבין ההגדרות המנוהלות, דגל --settings והגדרות המשתמש שהוא בעל הקדימות הגבוהה ביותר שמגדיר כל אחד מהם.

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

{
  "spinnerTipsOverride": {
    "label": "Acme tip",
    "tips": [
      "Run /review before opening a PR",
      {
        "id": "gateway-errors",
        "text": "Seeing 5xx errors? Check the gateway status page first",
        "cooldownSessions": 5,
        "priority": 2
      }
    ]
  }
}

כל שדה בדוגמה משנה דבר אחד באופן שבו Claude Code מציג את הטיפים:

• label: Claude Code מציג את שני הטיפים כ-Acme tip: ... במקום Tip: ....
• המחרוזת הפשוטה: Claude Code נותן לה את ברירות המחדל, ולכן היא יכולה להופיע שוב כבר בסשן הבא.
• id: Claude Code משתמש ב-gateway-errors כמפתח להיסטוריית ההצגה של הטיפ השני, ולכן זמן הצינון שלו עדיין חל אחרי שמוסיפים טיפים או מסדרים אותם מחדש.
• cooldownSessions: אחרי ש-Claude Code מציג את הטיפ gateway-errors, הוא לא מציג את הטיפ הזה שוב עד חמישה סשנים לאחר מכן.
• priority: כאשר הטיפ gateway-errors וטיפ אחר לא הוצגו במשך אותו מספר סשנים, למשל כאשר אף אחד מהם עדיין לא הוצג, Claude Code מציג את gateway-errors קודם. למחרוזת הפשוטה יש עדיפות ברירת המחדל, 0.

בזמן ש-Claude עובד, Claude Code מציג את הטיפים שלכם בספינר עם הקידומת שלכם, למשל Acme tip: Run /review before opening a PR.

#spinnerVerbs

בזמן שתור מתבצע, הספינר מציג פועל מתחלף כמו "Accomplishing", "Architecting" או "Baking". השתמשו במפתח הזה כדי להוסיף פעלים משלכם לסבב הזה או להחליף את הרשימה המובנית בשלכם.

• היקף: כל קובץ
• סוג: אובייקט עם מערך מחרוזות verbs ועם mode, אחד מאלה:
  • "append": Claude Code מוסיף את הפעלים שלכם לקבוצה המובנית
  • "replace": Claude Code מציג רק את הפעלים שלכם
• ברירת מחדל: לא מוגדר, ולכן Claude Code משתמש בפעלים המובנים

הדוגמה הזו מוסיפה שני פעלים לקבוצה המובנית:

{
  "spinnerVerbs": {
    "mode": "append",
    "verbs": ["Pondering", "Crafting"]
  }
}

במצב "replace" עם מערך verbs ריק, Claude Code שומר את הפעלים המובנים.

#statusLine

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

• היקף: כל קובץ. כאשר allowManagedHooksOnly מופעל, או כאשר disableAllHooks מוגדר מחוץ להגדרות המנוהלות, רץ רק הערך מההגדרות המנוהלות.
• סוג: אובייקט עם type שמוגדר ל-"command" ומחרוזת command, ובנוסף padding אופציונלי כמספר תווים, refreshInterval כמספר שניות, מינימום 1, ו-hideVimModeIndicator כבוליאני
• ברירת מחדל: לא מוגדר, ולכן אין שורת סטטוס

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

{
  "statusLine": {
    "type": "command",
    "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",
    "padding": 2
  }
}

הדוגמה צריכה ש-jq יהיה מותקן, והיא רצה במעטפת. למקבילות ב-PowerShell וב-Git Bash, ראו הגדרת Windows. להגדרה המלאה, ראו הגדרה ידנית של שורת סטטוס.

#subagentStatusLine

כאשר Claude מריץ סוכני משנה, Claude Code מציג אותם בתצוגת משימות מתחת להנחיה, שורה אחת לכל סוכן משנה שמציגה name · description · token count. המפתח הזה מאפשר להריץ פקודה משלכם כדי לכתוב מחדש את השורות האלה, למשל כדי להציג את שימוש ההקשר של כל סוכן משנה כאחוז. בכל רענון, Claude Code שולח את השורות הגלויות כאובייקט JSON אחד ב-stdin, עם מערך tasks שנושא את id, name, status, model, tokenCount ועוד של כל סוכן משנה, ומחליף את השורה של כל id שאתם כותבים בחזרה כשורת {"id", "content"}. שורות שלא כותבים בחזרה נשארות עם הרינדור המוגדר כברירת מחדל.

• היקף: כל קובץ. כאשר allowManagedHooksOnly מופעל, או כאשר disableAllHooks מוגדר מחוץ להגדרות המנוהלות, רץ רק הערך מההגדרות המנוהלות.
• סוג: אובייקט עם type שמוגדר ל-"command" ומחרוזת command
• ברירת מחדל: לא מוגדר, ולכן Claude Code מרנדר את שורות ברירת המחדל

{
  "subagentStatusLine": {
    "type": "command",
    "command": "jq -c '.tasks[] | {id, content: \"\\(.name): \\(.tokenCount) tokens\"}'"
  }
}

ראו שורות סטטוס של סוכני משנה.

#syntaxHighlightingDisabled

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מכבה את הדגשת התחביר בהפרשים, בבלוקי קוד ובתצוגות מקדימות של קבצים
  • false: Claude Code מדגיש תחביר
• ברירת מחדל: false

{
  "syntaxHighlightingDisabled": true
}

#terminalProgressBarEnabled

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

Claude Code מדווח עליו רק במסופים שתומכים במחוון: ConEmu, Ghostty 1.2.0 או חדש יותר, ו-iTerm2 3.6.6 או חדש יותר. הגדירו את המפתח הזה ל-false כדי ש-Claude Code יפסיק לדווח עליו. מופיע ב-/config בתור Terminal progress bar.

• היקף: כל קובץ. ערך ב-~/.claude.json מגרסה ישנה יותר חל כאשר אף קובץ הגדרות לא מגדיר אותו.
• סוג: בוליאני
  • true: אתם רואים את סרגל ההתקדמות של המסוף במסופים שתומכים בו
  • false: Claude Code מסתיר את סרגל ההתקדמות של המסוף
• ברירת מחדל: true

{
  "terminalProgressBarEnabled": false
}

#terminalTitleFromRename

Claude Code מגדיר את כותרת לשונית המסוף. כברירת מחדל הוא משתמש בכותרת שהוא יוצר מהשיחה, ואחרי שאתם נותנים לסשן שם עם /rename או --name, הלשונית מציגה את השם הזה. הגדירו את המפתח הזה ל-false כדי להשאיר בלשונית את הכותרת שנוצרה גם אחרי שאתם נותנים שם לסשן. השם עצמו עדיין חל, ולכן /resume <name> ובורר הסשנים מוצאים אותו.

• היקף: כל קובץ
• סוג: בוליאני
  • true: כותרת לשונית המסוף מציגה את שם הסשן שהגדרתם
  • false: הלשונית שומרת את הכותרת ש-Claude Code יוצר מהשיחה שלכם
• ברירת מחדל: true

{
  "terminalTitleFromRename": false
}

כדי ש-Claude Code יפסיק לעדכן את כותרת המסוף לגמרי, הגדירו את CLAUDE_CODE_DISABLE_TERMINAL_TITLE ל-1 במקום זאת.

#theme

בחרו את ערכת הצבעים של הממשק. מופיע ב-/config בתור Theme.

• היקף: כל קובץ. ערך ב-~/.claude.json מגרסה ישנה יותר חל כאשר אף קובץ הגדרות לא מגדיר אותו.
• סוג: מחרוזת, אחת מאלה:
  • "auto": תואם לרקע הבהיר או הכהה של המסוף
  • "dark": ערכת הנושא הכהה
  • "light": ערכת הנושא הבהירה
  • "dark-daltonized": ערכת הנושא הכהה עם צבעים שנוחים לעיוורון צבעים
  • "light-daltonized": ערכת הנושא הבהירה עם צבעים שנוחים לעיוורון צבעים
  • "dark-ansi": ערכת הנושא הכהה שמשתמשת רק בלוח צבעי ANSI של המסוף
  • "light-ansi": ערכת הנושא הבהירה שמשתמשת רק בלוח צבעי ANSI של המסוף
  • "custom:<slug>" או "custom:<plugin-name>:<slug>": ערכת נושא מותאמת מ-~/.claude/themes/ או מתוסף
• ברירת מחדל: "dark"

{
  "theme": "light-daltonized"
}

ראו יצירת ערכת נושא מותאמת.

#timeFormat

בחרו איך Claude Code כותב את הזמנים שהוא מציג בממשק, כמו done 6:05 PM בסוף כל הודעת משך תור וחותמות הזמן במציג התמליל. כדי לבחור ערכה מוכנה, הריצו את /config והגדירו את Time format. נדרש Claude Code בגרסה v2.1.257 או חדשה יותר.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מאלה:
  • "auto": זהה למצב לא מוגדר. כל זמן שומר על הפורמט המובנה שלו, שעוקב אחרי ה-locale שלכם בהודעת משך התור
  • "12-hour": שעון של 12 שעות
  • "24-hour": שעון של 24 שעות
  • "24-hour-utc": שעון של 24 שעות ב-UTC עם Z אחרי הדקות, כמו 18:05Z. Claude Code מתעלם מ-timeZone בערכה המוכנה הזו
  • תבנית strftime כמו "%H:%M": Claude Code כותב כל זמן עם התבנית. כל ערך שמכיל % הוא תבנית, וכל ערך אחר מחוץ לערכות המוכנות נחשב כ-"auto"
• ברירת מחדל: "auto"

{
  "timeFormat": "24-hour"
}

/config מציע רק את הערכות המוכנות, ולכן כדי להשתמש בתבנית strftime, הוסיפו את המפתח לקובץ הגדרות. הדוגמה הזו מציגה כל זמן כשעון של 24 שעות בשתי ספרות:

{
  "timeFormat": "%H:%M"
}

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

{
  "timeFormat": "%Y-%m-%d %H:%M"
}

אותם מקומות בממשק מציגים אז זמנים כמו 2026-09-01 18:05.

#timeZone

הצגת השעות בממשק באזור זמן שאינו אזור הזמן של המערכת. הגדר אותו לשם אזור זמן של IANA, למשל "UTC" או "Europe/Dublin". השעות ש-timeFormat שולט בהן מוצגות אז באזור הזה. אם timeFormat הוא "24-hour-utc", השעות נשארות ב-UTC וקלוד קוד מתעלם מהמפתח הזה. ל-/config אין שורה למפתח הזה, ולכן מגדירים אותו בקובץ הגדרות. נדרש Claude Code בגרסה v2.1.257 או חדשה יותר.

• היקף: כל קובץ
• סוג: מחרוזת, שם אזור זמן של IANA. כשקלוד קוד לא מזהה את השם, הוא משתמש באזור הזמן של המערכת
• ברירת מחדל: לא מוגדר, ולכן השעות מוצגות באזור הזמן של המערכת

{
  "timeZone": "Europe/Dublin"
}

#tui

בחירת מציג ממשק המסוף. השתמש ב-"fullscreen" עבור מציג מסך החלופי בלי הבהוב, עם גלילה לאחור וירטואלית, או ב-"default" עבור מציג המסך הראשי הקלאסי. הרצת /tui fullscreen או /tui default כותבת את המפתח הזה עבורך.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מהאפשרויות:
  • "default": מציג המסך הראשי הקלאסי
  • "fullscreen": מציג המסך החלופי בלי הבהוב, עם גלילה לאחור וירטואלית
• ברירת מחדל: לא מוגדר, ולכן קלוד קוד בוחר את המציג עבורך
• עקיפות לכל סשן: CLAUDE_CODE_NO_FLICKER ו-CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN גוברים על המפתח הזה לסשן אחד: CLAUDE_CODE_NO_FLICKER=1 מפעיל fullscreen, ו-CLAUDE_CODE_NO_FLICKER=0 או CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1 מכבים אותו. כששניהם מוגדרים, קלוד קוד מכבה אותו

{
  "tui": "fullscreen"
}

תחת tmux -CC או דרך SSH ל-Windows, קלוד קוד שומר על המציג הקלאסי אלא אם מגדירים CLAUDE_CODE_NO_FLICKER=1. סשנים ברקע שנפתחים מ-תצוגת סוכן תמיד משתמשים במציג fullscreen, בלי קשר להגדרה הזאת.

#verbose

כברירת מחדל, התמליל מקפל כל קריאת כלי לסיכום קצר, למשל הפקודה שקלוד הריץ וספירת שורות של הפלט שלה, ולוחצים על Ctrl+O כדי להעביר את כל התמליל לתצוגה המורחבת כשרוצים את הפרטים. הגדר את המפתח הזה ל-true כדי להציג את הקלט והפלט המלאים של כל קריאת כלי בתוך השורה בזמן שהם מתרחשים, וזה שימושי כשמנפים באג ב-hook, בשרת MCP, או בפקודת מעטפת ארוכה. מופיע ב-/config כ-Verbose output.

• היקף: כל קובץ. ערך ב-~/.claude.json מגרסה ישנה חל כשאף קובץ הגדרות לא מגדיר אותו.
• סוג: בוליאני
  • true: רואים את פלט הכלי המלא
  • false: רואים סיכומים מקוצרים של פלט הכלי
• ברירת מחדל: false
• עקיפות לכל סשן: --verbose גובר על המפתח הזה לסשן אחד

{
  "verbose": true
}

ערך viewMode או בחירת /focus דביקה עוקפים את המפתח הזה בכל סשן.

#viewMode

הגדרת תצוגת התמליל שבה קלוד קוד מתחיל: "default", "verbose", או "focus". כשהוא מוגדר, הוא עוקף גם את בחירת /focus הדביקה וגם את הגדרת verbose.

• היקף: כל קובץ
• סוג: מחרוזת, אחת מהאפשרויות:
  • "default": התמליל הרגיל עם פלט כלי מקוצר
  • "verbose": התמליל עם פלט כלי מלא
  • "focus": רק ההנחיה האחרונה שלך, סיכום של שורה אחת של קריאות כלי עם diffstats של עריכות, והתשובה הסופית. תצוגת focus דורשת את מציג fullscreen
• ברירת מחדל: לא מוגדר, ולכן הגדרת verbose ובחירת /focus האחרונה שלך חלות
• עקיפות לכל סשן: --verbose גובר על המפתח הזה לסשן אחד

{
  "viewMode": "focus"
}

#vimInsertModeRemaps

מיפוי רצפי מקשים של שני תווים במצב INSERT ל-Escape ב-מצב עורך vim. כל מפתח הוא בדיוק שני תווים ניתנים להדפסה שמוקלדים ברצף, ו-"<Esc>" הוא היעד הנתמך היחיד. קלוד קוד מתעלם מרשומות אחרות.

• היקף: משתמש או מנוהל. מאגר לא יכול למפות מחדש את הקשות המקשים שלך.
• סוג: אובייקט שממפה רצף של שני תווים ל-"<Esc>"
• ברירת מחדל: לא מוגדר

{
  "vimInsertModeRemaps": {
    "jj": "<Esc>"
  }
}

אין השפעה אלא אם editorMode הוא "vim". ראה מיפוי מחדש של רצפי מקשים במצב INSERT.

#voice

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

• היקף: כל קובץ
• סוג: אובייקט עם enabled כבוליאני, autoSubmit כבוליאני שחל רק במצב hold, ו-mode, אחת מהאפשרויות:
  • "hold": מחזיקים את מקש ההכתבה בזמן הדיבור ומשחררים אותו כדי לעצור
  • "tap": מקישים על המקש פעם אחת כדי להתחיל הקלטה ושוב כדי לשלוח
• ברירת מחדל: לא מוגדר, ולכן ההכתבה כבויה. כש-enabled הוא true ו-mode לא מוגדר, קלוד קוד משתמש ב-"hold"

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

{
  "voice": {
    "enabled": true,
    "mode": "tap"
  }
}

autoSubmit שולח את ההנחיה כשמשחררים את המקש במצב hold. הכתבה קולית דורשת חשבון claude.ai.

#voiceEnabled

[!WARNING]

הוצא משימוש מאז v2.1.92, כשאובייקט voice החליף אותו. קלוד קוד עדיין קורא אותו כדי שקבצי הגדרות ישנים ימשיכו לעבוד, אבל תצורות חדשות צריכות להגדיר voice.enabled.

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

• היקף: כל קובץ
• סוג: בוליאני
  • true: הכתבה קולית פועלת כשאתה מחובר עם חשבון claude.ai ומדיניות הארגון שלך מתירה קול, אלא אם voice.enabled מוגדר
  • false: הכתבה קולית כבויה, אלא אם voice.enabled מוגדר
• ברירת מחדל: לא מוגדר

{
  "voiceEnabled": true
}

#wheelScrollAccelerationEnabled

האצת מהירות גלילת גלגל העכבר במהלך גלילות מהירות ב-עיבוד fullscreen. הגדר אותו ל-false לקצב גלילה קבוע לכל שנת גלגל.

• היקף: כל קובץ
• סוג: בוליאני
  • true: קלוד קוד מאיץ את מהירות גלילת גלגל העכבר במהלך גלילות מהירות
  • false: קלוד קוד גולל בקצב קבוע לכל שנת גלגל
• ברירת מחדל: true

{
  "wheelScrollAccelerationEnabled": false
}

#Git וייחוס

שליטה בייחוס שקלוד קוד מוסיף לקומיטים ולבקשות משיכה, ובאופן העבודה שלו עם git.

#attribution

התאמה אישית של הייחוס שקלוד קוד מוסיף לקומיטי git ולבקשות משיכה. קומיטים מקבלים git trailer כגון Co-Authored-By כברירת מחדל. תיאורי בקשות משיכה מקבלים טקסט רגיל. הגדר כל חלק בנפרד עם מפתחי המשנה שלמטה.

• היקף: כל קובץ
• סוג: אובייקט עם מחרוזות commit ו-pr ובוליאני sessionUrl, או false כדי להסתיר את כל הייחוס. הערך false דורש Claude Code בגרסה v2.1.281 או חדשה יותר. גרסאות קודמות דוחות אותו ומדלגות על כל קובץ ההגדרות של המשתמש, הפרויקט או המקומי שמכיל אותו
• ברירת מחדל: לא מוגדר, ולכן קלוד קוד משתמש בייחוס הסטנדרטי שמוצג תחת כל מפתח משנה

כדי להסתיר את כל הייחוס, הגדר את attribution ל-false. בקובץ הגדרות שגם גרסאות קודמות קוראות, הגדר את commit ואת pr למחרוזות ריקות ואת sessionUrl ל-false במקום זאת.

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

{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <[email protected]>",
    "pr": "",
    "sessionUrl": false
  }
}

אחרי שמגדירים commit או pr, קלוד קוד מתעלם מההגדרה שיצאה משימוש includeCoAuthoredBy ומשתמש בטקסט ברירת המחדל שלו עבור זה משניהם שהשארת לא מוגדר.

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

#includeCoAuthoredBy

[!WARNING]

הוצא משימוש מאז v2.0.62, כש-attribution החליף אותו. קלוד קוד עדיין קורא אותו, אבל תצורות חדשות צריכות להגדיר attribution.

השתמש ב-attribution במקום זאת, שמחליף את המפתח הזה ומאפשר לשנות או להסתיר בנפרד את ה-trailer של הקומיט, את טקסט בקשת המשיכה, ואת קישור הסשן. קלוד קוד עדיין מכבד includeCoAuthoredBy: false מקבצי הגדרות שקדמו ל-attribution, אבל מתעלם ממנו אחרי שמגדירים attribution.commit או attribution.pr.

• היקף: כל קובץ
• סוג: בוליאני
  • true: אותו דבר כמו לא מוגדר. קלוד קוד מוסיף את ה-trailer של הקומיט ואת טקסט ייחוס בקשת המשיכה
  • false: קלוד קוד משמיט גם את ה-trailer של הקומיט וגם את טקסט ייחוס בקשת המשיכה, אלא אם attribution מגדיר commit או pr, ובמקרה הזה חלים כללי attribution
• ברירת מחדל: true

{
  "includeCoAuthoredBy": false
}

כדי להסתיר את כל הייחוס, ראה attribution.

#includeGitInstructions

קלוד קוד נותן לקלוד שני פריטי הקשר שקשורים ל-git: ההנחיות המובנות שלו לאופן כתיבת קומיטים ובקשות משיכה, בתיאור כלי Bash, ותצלום מצב של git status של המאגר שלך. התצלום מחזיק את הענף הנוכחי, את הענף הראשי, פלט git status, וקומיטים אחרונים. קלוד קוד קורא אותו כששיחה מתחילה.

הגדר את המפתח הזה ל-false כדי להשאיר את שניהם בחוץ, למשל כשמשתמשים בכישורי תהליך עבודה משלך ל-git.

• היקף: כל קובץ
• סוג: בוליאני
  • true: קלוד קוד כולל את הנחיות תהליך העבודה המובנות שלו לקומיט ולבקשת משיכה ואת תצלום מצב git status. סשנים בענן אף פעם לא כוללים את התצלום
  • false: קלוד קוד משאיר את שניהם בחוץ
• ברירת מחדל: true
• עקיפות לכל סשן: CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS גובר על המפתח הזה לסשן אחד

{
  "includeGitInstructions": false
}

אם מחליפים את הנחיית המערכת ב-מצב לא אינטראקטיבי או ב-Agent SDK, הסשן מתחיל בלי התצלום גם כשהמפתח הזה הוא true:

• הרצות -p: מחליפים את ההנחיה כשמעבירים --system-prompt או --system-prompt-file. מחליפים אותה גם כשמריצים סוכן מותאם עם הנחיה משלו, שנבחר עם --agent או עם הגדרת agent. מחוץ ל-מצב bare, כדי לשמור את התצלום, הריצו בלי סוכן מותאם והוסיפו את ההנחיות שלכם עם --append-system-prompt במקום להחליף את ההנחיה.
• Agent SDK: מחליפים את ההנחיה בהנחיית מערכת מותאמת או בסוכן חוט ראשי מותאם. אם לא מגדירים הנחיית מערכת, ה-SDK משתמש בברירת המחדל המינימלית שלו והסשן מתחיל בלי התצלום גם כן. מחוץ ל-מצב bare, כדי לשמור את התצלום, השתמשו ב-preset claude_code בלי agent מותאם.

#prUrlTemplate

הפניית קישורי ה-PR שקלוד קוד מציג, בתג הכותרת התחתונה ובסיכומי תוצאות כלים, לכלי סקירת קוד פנימי במקום github.com. קלוד קוד מחליף את {host}, {owner}, {repo}, {number}, ו-{url} מכתובת ה-PR. קישורי בקשת מיזוג של GitLab בשני המשטחים שומרים על כתובת GitLab שלהם.

• היקף: כל קובץ
• סוג: מחרוזת, תבנית URL שמשתמשת בכל אחד מחמשת מצייני המיקום
• ברירת מחדל: לא מוגדר

{
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}

קלוד קוד מחיל את התבנית רק על הקישורים שהוא עצמו מציג. מספר PR שקלוד כותב בהודעה, למשל #123, נשאר כפי שקלוד כתב אותו. כתובת שאין לה את הצורה /pull/<number> נשארת ללא שינוי.

#attribution.commit

הגדרת טקסט הייחוס שקלוד קוד מוסיף לקומיטי git, כולל כל trailers. הגדר אותו למחרוזת ריקה כדי להסתיר ייחוס קומיט.

• היקף: כל קובץ
• סוג: מחרוזת
• ברירת מחדל: לא מוגדר, ולכן קלוד קוד מוסיף Co-Authored-By: <name> <[email protected]>. השם הוא המודל שבשימוש כשהקומיט נוצר, למשל Claude Sonnet 5. כש-סוכן משנה יוצר את הקומיט, ה-trailer מציין את המודל של סוכן המשנה.
  • כשקלוד קוד מזהה את המודל כמודל Claude אבל לא יכול לאשר את הגרסה המדויקת שלו, הוא כותב Claude לבד.
  • כשהוא לא יכול להתאים את מזהה המודל לאף מודל Claude, למשל מודל של צד שלישי שמוגש דרך ANTHROPIC_BASE_URL מותאם, הוא כותב Claude Code.

הדוגמה הזאת מחליפה את ה-trailer של ברירת המחדל בשורה מותאמת וב-trailer מותאם Co-Authored-By:

{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <[email protected]>"
  }
}

#attribution.pr

הגדרת טקסט הייחוס שקלוד קוד מוסיף לתיאורי בקשות משיכה. הגדר אותו למחרוזת ריקה כדי להסתיר ייחוס בקשת משיכה.

• היקף: כל קובץ
• סוג: מחרוזת
• ברירת מחדל: לא מוגדר, ולכן קלוד קוד מוסיף 🤖 Generated with [Claude Code](https://claude.com/claude-code)

{
  "attribution": {
    "pr": ""
  }
}

#attribution.sessionUrl

בחירה אם קלוד קוד מוסיף את קישור הסשן של claude.ai כשהוא מבצע קומיט או פותח בקשת משיכה מסשן ענן או Remote Control. קלוד קוד מוסיף את הקישור כ-trailer Claude-Session בקומיטים וכקישור בתיאורי בקשות משיכה. הגדר אותו ל-false כדי להשמיט את הקישור.

• היקף: כל קובץ
• סוג: בוליאני
  • true: קלוד קוד מוסיף את קישור הסשן של claude.ai כשהוא מבצע קומיט או פותח בקשת משיכה מסשן ענן או Remote Control
  • false: קלוד קוד משמיט את הקישור
• ברירת מחדל: true

{
  "attribution": {
    "sessionUrl": false
  }
}

#ווים ואוטומציה

רשום ווים, הגבל אילו ווים רצים, ושלוט בזרימות עבודה. לאירועי וו ולמטענים, ראה את מדריך הווים.

#allowedHttpHookUrls

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

• היקף: כל קובץ. מערכים מתמזגים בין קובצי הגדרות.
• סוג: מערך של תבניות URL, כאשר * הוא תו כללי
• ברירת מחדל: לא מוגדר, כך שכל URL מותר

דוגמה זו מתירה כל URL תחת https://hooks.example.com/ וכל URL של http://localhost:

{
  "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}

התאמת שם מארח אינה תלויה ברישיות, ומתייחסת אל hooks.example.com., עם הנקודה הסופית שמסמנת שם תחום מלא, כמו אל hooks.example.com, וכך DNS מתייחס אליהם. רשימת ההיתר חלה על ווים מכל מקור, כולל הגדרות מנוהלות.

באפשרות managedSettings של Agent SDK, Claude Code מתעלם מרשימה שיש בה רשומות, ולכן העבר אותה באפשרות settings של ה-SDK במקום. ראה מה רשימה ריקה עושה בהגדרות הורה.

#allowManagedHooksOnly

הגבל את הרצת הווים לווים שהארגון שלך פורס.

• היקף: Managed
• סוג: בוליאני
  • true: רצים רק ווים מנוהלים, ובנוסף ווי Agent SDK וווים מתוספים שההגדרות המנוהלות שלך מפעילות בכפייה. ראה מה רץ תחת allowManagedHooksOnly
  • false: רצים ווים מכל היקף הגדרות ומכל תוסף
• ברירת מחדל: לא מוגדר, כך שווים מכל היקף הגדרות ומכל תוסף רצים

{
  "allowManagedHooksOnly": true
}

#מה רץ תחת allowManagedHooksOnly

כשמגדירים אותו ל-true, Claude Code משנה אילו ווים ופקודות דמויות וו נטענים:

• ווים מנוהלים וווי SDK רצים: ווים מהגדרות מנוהלות וווים ש-Agent SDK רושם בתהליך
• ווי תוספים שמופעלים בכפייה רצים: ווים מתוספים שההגדרות המנוהלות שלך מפעילות בכפייה דרך enabledPlugins. Claude Code מתאים לפי מזהה plugin@marketplace המלא, כך שתוסף עם אותו שם מ-marketplace אחר נשאר חסום. כך אפשר להפיץ ווים שנבדקו דרך marketplace של הארגון, ולחסום את כל השאר. מוד בתוסף כזה נטען רק כשהוא נחשב של הארגון שלך
• מוניטורים מתוספים אחרים חסומים: מוניטורים של תוסף לא מתחילים אלא אם התוסף מופעל בכפייה. נדרש Claude Code v2.1.310 או חדש יותר
• כל השאר חסום: ווי משתמש, פרויקט ומקומיים, ווים ומודים מתוספים מותקנים אחרים, וווים שמוצהרים ב-frontmatter של סוכן. מודים המובנים ב-Claude Code ממשיכים לרוץ. כדי לחסום רק מודים של משתמשים, הגדר allowManagedModsOnly במקום.
• תוספים שמקורם בפקודה מושבתים: Claude Code גם משבית תוספים עם מקור command, כולל תוספים שמופעלים בכפייה ב-enabledPlugins המנוהל, אלא אם מגדירים disableCommandPluginSources ל-false במפורש
• פקודות headersHelper של marketplace חסומות: Claude Code גם חוסם פקודות headersHelper של marketplace אלא אם disableCommandPluginSources מוגדר במפורש ל-false, למעט marketplace שההגדרות המנוהלות עצמן מצהירות עליו. נדרש Claude Code v2.1.238 או חדש יותר
• שורת סטטוס והצעת קבצים מצטמצמות להגדרות מנוהלות: Claude Code קורא את statusLine, את fileSuggestion ואת subagentStatusLine רק מהגדרות מנוהלות, לפי שערי שורת הסטטוס והצעת הקבצים

הפקודה /goal לא יכולה לרוץ כל עוד המפתח הזה מוגדר, כי היא תלויה בווים.

#disableAllHooks

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

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

{
  "disableAllHooks": true
}

הטווח תלוי באיזה קובץ נושא את המפתח:

• בהגדרות מנוהלות: Claude Code משבית כל וו מוגדר, כולל מנוהלים, וממשיך להריץ את הווים ש-Agent SDK רושם בתהליך
• באפשרות managedSettings של Agent SDK: במכונה שבה מנהל פורס הגדרות מנוהלות, Claude Code מתעלם מהמפתח הזה אלא אם המנהל מאפשר למארח מטמיע להוסיף מדיניות. במקום שהמפתח נכנס לתוקף, ווי משתמש, פרויקט, מקומיים ותוספים נעצרים, וכך גם כל וו באפשרות settings של ה-SDK. ווים מנוהלים של מנהל, ווים של תוספים שמופעלים בכפייה, ו-callbacks של ווי SDK ממשיכים לרוץ. נדרש Claude Code v2.1.309 או חדש יותר.
• בכל קובץ הגדרות אחר: Claude Code משבית ווי משתמש, פרויקט, מקומיים ותוספים. ווים מנוהלים, ווי Agent SDK, וווים מתוספים שמופעלים בכפייה ב-enabledPlugins המנוהל ממשיכים לרוץ

המפתח גם עוצר מודים, שהם תוספים שהקוד שלהם רושם ווים:

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

מודים המובנים ב-Claude Code ממשיכים לרוץ בשני המקרים. לכל אחד יש מתג משלו.

כדי שווי Agent SDK ימשיכו לרוץ כשהגדרות מנוהלות מגדירות את המפתח הזה, נדרש Claude Code v2.1.242 או חדש יותר.

הפקודה /goal לא יכולה לרוץ כל עוד ווים מושבתים, ותפריט /hooks מציג הודעה במקום הווים שלך.

#שערי שורת סטטוס והצעת קבצים

Claude Code מקבל שתי החלטות עבור statusLine, fileSuggestion ו-subagentStatusLine, בסדר הזה:

• כיבוי לגמרי: כשהגדרות מנוהלות מגדירות disableAllHooks, או כשהתיקייה אינה מהימנה לפי אותו כלל אמון סביבת עבודה כמו ווים בקובצי הגדרות
• צמצום להגדרות מנוהלות: כש-allowManagedHooksOnly מוגדר, כש-disableAllHooks הוא true מחוץ להגדרות מנוהלות אחרי ש-קדימות הגדרות חלה, או כשמתחילים את Claude Code עם --safe-mode

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

#disableWorkflows

כבה זרימות עבודה דינמיות ואת פקודות זרימת העבודה המצורפות עבור כל מי שההגדרות שלך מגיעות אליו, כמו ארגון דרך הגדרות מנוהלות. כדי להפעיל או לכבות זרימות עבודה רק עבור עצמך, השתמש ב-enableWorkflows במקום, והמתג Dynamic workflows ב-/config כותב אותו להגדרות המשתמש שלך.

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מכבה זרימות עבודה דינמיות ואת פקודות זרימת העבודה המצורפות עבור כל מי שההגדרות שלך מגיעות אליו
  • false: זהה ללא מוגדר. האם זרימות העבודה פועלות אז נקבע לפי enableWorkflows ולפי ברירת המחדל של התוכנית שלך
• ברירת מחדל: false
• עקיפות לכל סשן: CLAUDE_CODE_DISABLE_WORKFLOWS מכבה זרימות עבודה לסשן אחד. מי מבין השניים שמכבה אותן, השני לא יכול להפעיל אותן מחדש

{
  "disableWorkflows": true
}

#enableWorkflows

הפעל או כבה זרימות עבודה דינמיות עבור עצמך כשברירת המחדל של התוכנית שלך אינה מה שאתה רוצה. מופיע ב-/config בתור Dynamic workflows, שכותב את המפתח הזה להגדרות המשתמש שלך ומסיר אותו שוב כשמחזירים את המתג לברירת המחדל של התוכנית. כדי לכבות זרימות עבודה לכולם מהגדרות מנוהלות, השתמש ב-disableWorkflows במקום.

• היקף: כל קובץ
• סוג: בוליאני
  • true: Claude Code מפעיל עבורך זרימות עבודה דינמיות
  • false: Claude Code מכבה עבורך זרימות עבודה דינמיות
• ברירת מחדל: לא מוגדר, כך שזרימות עבודה פועלות אלא אם אתה בתוכנית Pro, שבה הן כבויות
• עקיפות לכל סשן: CLAUDE_CODE_DISABLE_WORKFLOWS מכבה זרימות עבודה לסשן אחד, ו-true כאן לא יכול להפעיל אותן מחדש כל עוד הוא מוגדר

{
  "enableWorkflows": true
}

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

#hooks

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

• היקף: כל קובץ. ווים מתמזגים בין קבצים במקום להחליף זה את זה, ואי אפשר להסיר ווים מהגדרות מנוהלות מקבצים אחרים.
• סוג: אובייקט שהמפתחות שלו הם אירועי וו. כל ערך הוא מערך של קבוצות { "matcher", "hooks" } שרשומות ה-hooks שלהן הן בעלות type של "command", "prompt", "agent", "http" או "mcp_tool"
• ברירת מחדל: לא מוגדר, כך שאף וו לא רץ