📘 תיעוד 96

פריסת הגדרות מנוהלות

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

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

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

#פריסת קובץ הגדרות מנוהלות

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

1. כתבו את managed-settings.json

כתבו managed-settings.json שמחזיק את המפתחות שהחלטתם לאכוף, באותה צורת JSON כמו settings.json. טבלת החליטו מה לאכוף מפרטת את המפתחות מאחורי כל בקרה, וכל רשומה בהפניה להגדרות אומרת אם מקור מנוהל יכול להגדיר אותה. הקובץ הזה חוסם שתי קריאות קובץ, מכבה את מצב העקיפה, וגורם ל-Claude Code להתעלם מכללי הרשאות מקבצי משתמש, פרויקט ומקומי ומ---allowedTools:

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./secrets/**)"
    ],
    "disableBypassPermissionsMode": "disable"
  },
  "allowManagedPermissionRulesOnly": true
}

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

2. שימו את הקובץ על כל מחשב

שמרו את הקובץ בשם managed-settings.json בספריית המערכת של מערכת ההפעלה, באמצעות הכלים שכבר שמים קבצים על הצי:

• macOS: /Library/Application Support/ClaudeCode/managed-settings.json
• Linux ו-WSL: /etc/claude-code/managed-settings.json
• Windows: C:\Program Files\ClaudeCode\managed-settings.json

3. אשרו שהמדיניות חלה

על מחשב אחד, הריצו את /status בתוך Claude Code. שורת Setting sources מציגה Enterprise managed settings (file). פרסו לשאר הצי אחרי זה. בדקו שמדיניות בתוקף מכסה מה לבדוק כשהשורה חסרה.

#בחירת מנגנון מסירה

הקובץ בשלבים למעלה הוא אחת מארבע דרכים להביא הגדרות מנוהלות אל מחשב. כל מנגנון נושא את אותם מפתחות מדיניות כמו קובץ settings.json, ולכן הפניה להגדרות חלה על כולם. כמה מפתחות קשורים למקורות מסוימים, ושורת Scope של כל רשומה אומרת אילו:

• בקרי מסירה: policyHelper, wslInheritsWindowsSettings, ו-managedSourcesBehavior
• מפתחות התחברות ל-gateway: forceLoginGatewayUrl, gatewayInternalNetworks, והערך "gateway" של forceLoginMethod

קובץ הגדרות מנוהלות, פרופיל MDM, או מסוף claude.ai מחילים מדיניות אחת על כל מי שהם מגיעים אליו. כדי לתת לקבוצת מפתחים אחת מדיניות אחרת, פרסו קובץ או פרופיל אחר לאותה קבוצה. מסוף claude.ai עדיין לא יכול לכוון לקבוצה, בעוד ש-Claude apps gateway באירוח עצמי מוסר הגדרות מנוהלות לפי קבוצת IdP.

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

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

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

תבניות התחלה ל-Jamf, Iru, Intune ו-Group Policy נמצאות במאגר דוגמאות MDM.

אם לארגון מוחלת תצורת HIPAA, ראו את settings-hipaa.json ואת README-hipaa.md במאגר דוגמאות ההגדרות עבור managed-settings.json מלא יותר עם sandboxing, רשימת רשתות מותרות, הגנות על אישורים, ושמירת נתונים מקומית.

לשרתי MCP מנוהלים, שפורסים לצד כל אחד מאלה דרך managed-mcp.json או מספקים דרך המפתח managedMcpServers, ראו תצורת MCP מנוהלת.

#איפה ומתי מדיניות חלה

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

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

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

• סשנים של Claude Tag: סשנים של Claude Tag רצים בסביבות ענן אבל לא מקבלים הגדרות מנוהלות בשרת. בסביבה באירוח עצמי הם עדיין קוראים את קובץ ההגדרות המנוהלות בתמונת ה-runner. הגדירו את Claude Tag עצמו בהגדרות הניהול של Claude Tag.

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

  • על המחשב של המשתמש: כברירת מחדל, Claude Code בסשן Cowork קורא את מדיניות ה-MDM או ברמת מערכת ההפעלה ואת קובץ ההגדרות המנוהלות על אותו מכשיר, אז פרסו שם את המדיניות.
  • ב-sandbox של VM מלא: כשתצורת Claude Desktop המנוהלת מגדירה requireCoworkFullVmSandbox, Claude Code רץ בתוך מכונה וירטואלית שבה מדיניות ה-MDM של המכשיר וקובץ ההגדרות המנוהלות לא נמצאים.
  • סשני Cowork מרוחקים: אלה רצים על מכונות וירטואליות שמנוהלות על ידי Anthropic, שבהן ל-Claude Code אין מדיניות מכשיר לקרוא.

  בכל מקום שהסשן רץ, claude.ai מחיל בעצמו את הרשימות strictKnownMarketplaces ו-blockedMarketplaces של מסוף הניהול כשמישהו מוסיף שוק ממאגר git ב-claude.ai או מ-Customize ב-Cowork. איך ההגבלות עובדות מתאר את הבדיקה הזו. טבלת כיסוי המשטחים משווה את Cowork למשטחים האחרים.

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

  • שינויים ב-forceRemoteSettingsRefresh, ב-requiredMinimumVersion, ובכמה מפתחות שהמשתמש יכול לערוך נכנסים לתוקף בהפעלת הסשן הבאה.
  • רשומת policyHelper חדשה או שהשתנתה נכנסת לתוקף בהפעלה הבאה. אם הגדרות מנוהלות בשרת מסתירות את ה-helper באותה הפעלה, ה-helper רץ ברגע ששליפה מדווחת שההגדרות האלה הוסרו.

• שינויים שדורשים אישור: חוץ מהעדכונים שממתינים להפעלה הבאה, שינוי מנוהל בשרת להגדרה שדורשת אישור, כמו hook או משתנה env, ממתין שהמפתח יקבל את תיבת הדו-שיח בסשן אינטראקטיבי, וחל על הריצה הנוכחית בסשן שהרחבת IDE או Agent SDK מארחים. שינויים מנוהלים בשרת אחרים חלים בסקר הבא.

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

#איפה כל מנגנון שומר את המדיניות

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

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

• פרופיל תצורה של macOS: תחום ההעדפות המנוהלות com.anthropic.claudecode. השתמשו באותם מפתחות עליונים כמו ב-managed-settings.json, עם הגדרות מקוננות כמילונים ורשימות כמערכי plist.

• רישום HKLM של Windows: ה-JSON כערך REG_SZ או REG_EXPAND_SZ בשם Settings תחת HKLM\SOFTWARE\Policies\ClaudeCode.

• מבוסס קובץ: managed-settings.json, ספריית managed-settings.d/ אופציונלית, ו-managed-mcp.json בספריית המערכת: /Library/Application Support/ClaudeCode/ ב-macOS, /etc/claude-code/ ב-Linux וב-WSL, ו-C:\Program Files\ClaudeCode\ ב-Windows. Claude Code לא קורא את נתיב Windows הישן C:\ProgramData\ClaudeCode\managed-settings.json.

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

• רישום HKCU של Windows: אותו ערך Settings תחת HKCU\SOFTWARE\Policies\ClaudeCode.

#פיצול מדיניות מבוססת קובץ בין צוותים

אם כמה צוותים מחזיקים חלקים של מדיניות אחת, שימו כל חלק בקובץ משלו ב-managed-settings.d/, ליד managed-settings.json באותה ספריית מערכת, במקום לערוך קובץ משותף אחד.

Claude Code ממזג קודם את managed-settings.json, ואז כל קובץ *.json בספרייה לפי סדר אלפביתי. תנו לקבצים קידומות מספריות כדי לשלוט בסדר, למשל 10-telemetry.json ו-20-security.json. Claude Code מתעלם מקבצים מוסתרים ומקבצים שלא מסתיימים ב-.json.

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

• ערכים בודדים, כמו "model": "opus" או "cleanupPeriodDays": 7: הערך של הקובץ המאוחר מחליף את הקודם
• רשימות, כמו permissions.deny או sandbox.network.allowedDomains: שתי הרשימות מתאחדות, כשכפילויות מוסרות
• בלוקים מקוננים, כמו env או sandbox: שני הבלוקים מתמזגים מפתח אחר מפתח, וכל מפתח בפנים עוקב אחרי אותם כללים
• fallbackModel: השרשרת המאוחרת מחליפה את הקודמת בשלמותה
• extraKnownMarketplaces ו-managedMcpServers: רשומה מאוחרת עם אותו שם מחליפה את הקודמת בשלמותה
• modelPicker: המערך המאוחר מחליף את הקודם בשלמותו

#איך Claude Code משלב מקורות מנוהלים

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

• "first-wins", ברירת המחדל: Claude Code משתמש במקור בעל הדירוג הגבוה ביותר שמספק לפחות מפתח מדיניות אחד ומתעלם מהשאר במקום למזג אותם, מלבד המפתחות במפתחות שנקראים מכל מקור מנהל. Claude Code לא מציג אזהרה למקורות שהוא מדלג עליהם; /status מציין את המקור שבו השתמש ואת אלה שדילג עליהם.
• "merge": Claude Code מחיל כל מקור מנהל שמספק מפתח מדיניות ומשלב אותם לפי סוג המפתח: ברוב המפתחות חל הערך של המקור בעל הדירוג הגבוה יותר, רשימות מתאחדות, ונעילות מקבלות את הערך המחמיר ביותר. שילוב כל מקור מנוהל מציין איפה להגדיר את המפתח ואיך כל סוג מפתח משתלב. דורש Claude Code v2.1.242 או חדש יותר.

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

• מפתח מדיניות: כל מפתח הגדרות מלבד שני מפתחות הבקרה, wslInheritsWindowsSettings ו-managedSourcesBehavior. קובץ הגדרות מנוהלות או מדיניות MDM שמכילים רק אותם לא נספרים, ו-Claude Code עובר למקור הבא.
• מקור מנהל: אחד משלושת המקורות הראשונים למטה. רישום HKCU ניתן לכתיבה על ידי המשתמש ואינו כזה.

Claude Code בודק את המקורות בסדר הזה, העדיפות הגבוהה ביותר תחילה:

1. הגדרות מרוחקות, שמסופקות מ-claude.ai כהגדרות מנוהלות בשרת או על ידי שער יישומי Claude. Claude Code מביא את המקור הזה רק כשההפעלה מאמתת מול ה-API של Anthropic ישירות עם אישור מתאים, נכנסת לשער עם /login, או רצה בלשונית Code של Claude Desktop מאחורי שער שמגיש את הגדרות ההפעלה הזו. אצל ספקים אחרים, או כש-ANTHROPIC_BASE_URL מצביע למקום שאינו ה-API של Anthropic, הוא מתחיל במקור הבא
2. מדיניות MDM או ברמת מערכת ההפעלה: ה-plist של macOS או מפתח הרישום HKLM
3. קבצי הגדרות מנוהלות, managed-settings.d/*.json ו-managed-settings.json שממוזגים יחד
4. רישום HKCU, ב-Windows, וב-WSL ברגע שרישום HKLM או קובץ ההגדרות המנוהלות של Windows מפעיל את wslInheritsWindowsSettings וגם ערך HKCU מגדיר אותו. Claude Code קורא אותו רק כשאין מסמך מנהל נוכח מעליו ואין הגדרות הורה שמספק המארח שמספקות מפתח מגביל

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

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

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

• הוא מגדיר מפתח מדיניות כלשהו לערך שאינו null, גם ערך ש-Claude Code לא יכול לקרוא
• הוא ערך HKLM, קובץ הגדרות מנוהלות, או ספריית managed-settings.d שקיימים אבל אי אפשר לקרוא אותם

ב-WSL, גם /etc/claude-code ניתן לכתיבה על ידי המשתמש, והרשומה wslInheritsWindowsSettings אומרת מתי מסמכי Windows עומדים מעליו.

#מפתחות שנקראים מכל מקור מנהל

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

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

המפתחות חוצי המקורות כוללים:

• sandbox.network.allowManagedDomainsOnly ו-sandbox.filesystem.allowManagedReadPathsOnly: ערך true בכל מקור מנהל מפעיל את הנעילה. בזמן שנעילה פעילה, Claude Code מאחד את רשימת ההיתר שהיא נועלת, sandbox.network.allowedDomains יחד עם כללי היתר WebFetch(domain:...), או sandbox.filesystem.allowRead, על פני כל מקור מנהל. בלי הנעילה, Claude Code מתייחס לרשימת ההיתר כמו לכל מפתח אחר, כך שתחת "first-wins" רשימת ההיתר של מקור מנהל שלא נבחר מתעלמים ממנה

• allowAllClaudeAiMcps

• allowManagedMcpServersOnly: ערך true בכל מקור מנהל מפעיל את נעילת רשימת ההיתר של MCP. בזמן שהנעילה פעילה, רשימת allowedMcpServers המנוהלת מגיעה מהמקור המנהל בעל הדירוג הגבוה ביותר שמגדיר אחת. רשימה מנוהלת בשרת מחליפה את הרשימה של מקור נמוך יותר במקום להשתלב איתה.

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

  בלי הנעילה, Claude Code קורא את allowedMcpServers מהמקור המנוהל שהוא מחיל, כך שתחת "first-wins" הרשימה של מקור מנהל שלא נבחר מתעלמים ממנה. דורש Claude Code v2.1.273 או חדש יותר

• deniedMcpServers ו-disableClaudeAiConnectors: רשומה או ערך true בכל מקור מנהל חלים. דורש Claude Code v2.1.273 או חדש יותר

• נתיבי הקבצים הבינאריים של ה-sandbox, sandbox.bwrapPath ו-sandbox.socatPath

• הקובץ הבינארי ripgrep של ה-sandbox, sandbox.ripgrep

• sandbox.filesystem.disabled ו-sandbox.network.strictAllowlist

• useAutoModeDuringPlan, syncClaudeAiSkills, ו-syncClaudeAiPlugins, שבהם ערך false מכל מקור מנהל מכבה את ההתנהגות. כל מפתח יכול רק לשלול:

  • ערך false בהגדרות המשתמש או המקומיות של המפתח מכבה אותה גם כן
  • עבור useAutoModeDuringPlan, ערך false בקובץ משתמש או מקומי שהמפתח משאיר בחוץ עם אפשרות כמו --setting-sources לא נספר. התעלמות מקובץ שהושאר בחוץ דורשת Claude Code v2.1.314 או חדש יותר

• enableArtifact, שבו ערך false מכל מקור מנהל מכבה את כלי Artifact. ערך false בהגדרות המשתמש, הפרויקט או המקומיות של המפתח מכבה אותו גם כן, ואין מקור שמפעיל אותו בחזרה. ראו אילו ערכים ברמה נמוכה יותר עדיין נספרים. דורש Claude Code v2.1.242 או חדש יותר

• maxEffortLevel, שבו חל התקרה הנמוכה ביותר בכל מקור מנהל. אם מפתח מגדיר תקרה נמוכה יותר בהגדרות שלו או עם --settings, Claude Code מחיל את זו. אין מקור שיכול להעלות את התקרה. דורש Claude Code v2.1.267 או חדש יותר

• ביטול הצטרפות ל-commit-trailer ב-attribution, או ב-includeCoAuthoredBy שיצא משימוש, מכל שכבה

• forceRemoteSettingsRefresh

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

ל-allowedProviders יש כלל משלו: הערת ה-Scope ברשומה שלו אומרת איך רשימה שהוגדרה על המכונה משתלבת עם רשימה מנוהלת בשרת. דורש Claude Code v2.1.285 או חדש יותר.

כשמקור מנהל מגדיר את allowManagedMcpServersOnly או רשימת allowedMcpServers והערך הזה אינו זה שבתוקף, /status ו-claude doctor מציינים את המקור ואת המפתח.

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

במכונה עם מדיניות MDM או קובץ הגדרות מנוהלות, Claude Code לוקח את מפתחות ההתחברות מהמדיניות או מהקובץ, גם עבור מפתח שהגדרות מרוחקות מגדירות גם כן. הגדרות מקונסולת הניהול של claude.ai הן הגדרות מרוחקות, לכן הגדירו מפתחות התחברות כמו forceLoginOrgUUID במדיניות ה-MDM או בקובץ.

אם למכונה יש גם מדיניות MDM וגם קובץ הגדרות מנוהלות, השתמשו במדיניות ה-MDM. כשהמדיניות הזו מגדירה מפתח מדיניות כלשהו, Claude Code מתעלם ממפתחות התחברות בקובץ, גם תחת managedSourcesBehavior: "merge".

מפתחות ההתחברות הם:

• forceLoginOrgUUID ו-forceLoginMethod שמוגדר ל-"claudeai" או ל-"console": אם המדיניות או הקובץ משמיטים אחד מהמפתחות, חל הערך בהגדרות המרוחקות. עד שכל לקוח מריץ v2.1.299 או חדש יותר, הגדירו את המפתחות גם בהגדרות מנוהלות בשרת מ-claude.ai
• מפתחות ההתחברות לשער: Claude Code לא משתמש בערך בהגדרות מרוחקות עבור הכניסה לשער

#שילוב כל מקור מנוהל

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

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

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

כדי לאשר אילו מקורות השתלבו במכונה, קראו את שורת Setting sources ב-/status. הסעיף הזה אומר מה כל תווית אומרת.

#חישוב המדיניות עם תוכנית עזר

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

• אובייקט managedSettings שנפלט הוא ההגדרות המנוהלות היחידות להפעלה, כולל עבור המפתחות שהוא אחרת קורא מכל מקור מנהל, מלבד forceRemoteSettingsRefresh, שיש לו כלל הפעלה משלו

לגבי אילו הרצות עזר נכשלות, ומה Claude Code עושה כשאחת נכשלת, ראו כשלי עזר.

#לאפשר למארח שמטמיע להוסיף מדיניות

כשאפליקציה אחרת מפעילה את Claude Code, כמו Claude Desktop, הרחבת IDE, או אפליקציית Agent SDK, המארח הזה יכול להעביר הגדרות מנוהלות משלו דרך אפשרות ה-SDK managedSettings. Claude Code מכנה אותן הגדרות הורה.

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

כדי ש-Claude Code ימזג הגדרות הורה לצד מקור מנהל, הגדירו את parentSettingsBehavior ל-"merge" במקור המנוהל בעל העדיפות הגבוהה ביותר. Claude Code קורא את המפתח מהמקור הזה בלבד.

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

policyHelper יכול לכבות מיזוג הורה בלי קשר למפתח הזה. הרשומה שלו אומרת מתי.

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

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

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

  ב-Claude Code מגרסה v2.1.273 ואילך, בזמן ש-allowManagedMcpServersOnly פועל, רשימת allowedMcpServers מהמקור המנהל בדירוג הגבוה ביותר שמגדיר אחת חלה וחוסמת את זו של ההורה, כמפתח בין מקורות. הרשימה של ההורה חלה רק כשאף מקור מנהל לא מגדיר אחת. הרשומה managedSourcesBehavior אומרת איזה מקור מספק כל מפתח תחת "merge". לפני v2.1.223, ערך במקור מנהל כלשהו חסם את זה של ההורה

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

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

• עבור allowedProviders, רשימה במקור המנוהל שנבחר חוסמת רשימה שמסופקת על ידי ההורה, ותחת ההצטרפות "merge" של managedSourcesBehavior רשימה במקור מנהל כלשהו עושה זאת. נדרש Claude Code מגרסה v2.1.285 ואילך

• blockedMarketplaces שמסופק על ידי ההורה חל בנוסף לכל רשימת חסימה שמקור מנוהל מגדיר. נדרש Claude Code מגרסה v2.1.282 ואילך

#שמירה על גישה לתיקיות Cowork כשרק כללים מנוהלים חלים

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

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

{
  "allowManagedPermissionRulesOnly": true,
  "permissions": {
    "allow": [
      "Edit(~/CoworkProjects/**)"
    ]
  }
}

אחרי פריסת המדיניות, Claude יכול לשמור קבצים תחת התיקייה הזו בסשן Cowork חדש. כללי Read ו-Edit מכסים את תחביר הנתיב, כולל הצורה // לנתיבים מוחלטים.

#מה מפתח יכול לשנות

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

• המודל לסשן: model מנוהל הוא ברירת מחדל, לא נעילה. --model ו-ANTHROPIC_MODEL עדיין בוחרים את המודל לסשן הזה, אז פרסו את availableModels כדי להגביל את הבחירה.
• חלון הכיווץ האוטומטי לסשן: autoCompactWindow מנוהל הוא גם ברירת מחדל. הדגל --autocompact והמשתנה CLAUDE_CODE_AUTO_COMPACT_WINDOW עדיין מגדירים את חלון הכיווץ האוטומטי לסשן הזה.
• זכויות מנהל מקומיות: מפתח שהוא מנהל במכונה יכול לערוך את המקור המנוהל עצמו, ולכן כלי MDM יכולים לפרוס מחדש את הפרופיל או הקובץ לפי לוח זמנים, ולכן קיימים רישום HKLM ותחום ההעדפות המנוהלות של macOS.
• המטמון המנוהל מהשרת: הגדרות מנוהלות מהשרת מגיעות משרתי Anthropic, ועריכה של המטמון המקומי נמשכת רק עד השליפה המוצלחת הבאה.
• כלים אחרים: הגדרות מנוהלות מחייבות את Claude Code בלבד. מפתח שקורא ל-API מכלי אחר אינו כפוף להן.

#בדיקה שמדיניות בתוקף

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

#קריאת המקור ב-/status

במכונה של המפתח, הריצו /status בתוך Claude Code וקראו את השורה Setting sources. כשמקור מנוהל בתוקף, השורה מפרטת Enterprise managed settings עם המקור ש-Claude Code בחר בסוגריים:

• (remote): הגדרות מנוהלות בשרת מ-claude.ai או משער (gateway)
• (plist) או (HKLM): מדיניות MDM או של מערכת ההפעלה
• (file), (drop-ins), או (file + drop-ins): managed-settings.json, ספריית ה-drop-in, או שניהם
• (remote + file, merged), או רשימה אחרת שמסתיימת ב-, merged: הארגון שלכם מרכיב כל מקור מנוהל, ו-Claude Code מיזג את המקורות שברשימה לתוך המדיניות. מקור נמוך יותר עדיין יכול לספק משתני env בלי להופיע ברשימה. נדרש Claude Code v2.1.242 או חדש יותר
• (HKCU): חלופת הרישום שניתנת לכתיבה על ידי המשתמש
• (parent process): מארח מטמיע סיפק הגדרות מגבילות
• (helper): policyHelper שהוגדר על ידי מקור ה-MDM או הקובץ שנבחר

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

כשהמדיניות לא חלה, שורת Setting sources אומרת לכם איזו משתי הבעיות יש לכם:

• השורה חסרה: Claude Code לא מצא מקור מנוהל שמספק מפתח מדיניות.

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

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

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

#איתור רשומות ש-Claude Code השמיט

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

Claude Code מחמיר יותר עם ה-managedSettings ש-policyHelper פולט: הוא מבצע אותם תיקוני רשומות, אבל כל הפרת סכמה ששורדת מכשילה את כל ריצת ה-helper, ובהפעלה Claude Code מסרב להתחיל, כמו helper שיוצא עם קוד שאינו אפס.

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

• קובץ הגדרות מנוהלות או קובץ drop-in: הקובץ אינו JSON תקין, או שהרמה העליונה שלו אינה אובייקט
• plist של MDM: plutil של macOS מדווח שה-plist פגום, או שהתוכן המומר שלו אינו אובייקט JSON
• ערך רישום HKLM: הערך Settings אינו מחרוזת, ריק, או שאינו מכיל אובייקט JSON

שלושה מצבי מקור לא גורמים לסירוב הזה:

• קובץ, פרופיל או ערך רישום חסר אינו כשל. Claude Code רץ בלי המקור הזה.
• קובץ הגדרות מנוהלות ריק נחשב כ-{}.
• ערך פגום במפתח הרישום HKCU שניתן לכתיבה על ידי המשתמש אף פעם לא חוסם הפעלה. Claude Code מדווח עליו כהודעה ב-/status וב-claude doctor.

כשקובץ הגדרות מנוהלות, קובץ drop-in, ספריית managed-settings.d/, פרופיל MDM, או ערך רישום HKLM קיים אבל אי אפשר לקרוא אותו, ואין מקור מנהל שמספק מדיניות, מה שקורה תלוי בסיבה לכישלון הקריאה:

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

כדי למצוא רשומה שהושמטה, חפשו באחד משלושה מקומות:

• סשנים אינטראקטיביים מציגים תיבת דו שיח בהפעלה שמפרטת את הרשומות הלא תקינות.
• הרצות לא אינטראקטיביות עם -p מדפיסות סיכום ל-stderr.
• claude doctor מפרט כל רשומה לא תקינה עם המקור והשדה שלה.

#מפתחות שנכשלים סגור

כשמקור מנוהל מגדיר מפתח ברמה העליונה שיש לו ערך מגביל יחיד, כמו allowManagedPermissionRulesOnly, disableAutoMode, או skipDangerousModePermissionPrompt, למשהו ש-Claude Code לא יכול לקרוא, המפתח נקרא כערך הזה עד שתתקנו אותו. הדוח אומר שהמפתח was present but invalid ומציין את הערך ש-Claude Code מתייחס אליו. למפתח בתוך sandbox, ראו ערכים לא תקינים בתוך sandbox.

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

• null מסיר את המפתח.
• disableAllHooks לא תקין, גם בוליאני במרכאות, מושמט עם אזהרה, כי אכיפת true גם תפרוק את ה-hooks שההגדרות המנוהלות שלכם עצמכם מפריסות.
• לכל מפתח בוליאני אחר שהכלל מכסה, המחרוזת "true" או "false" נקראת כבוליאני הזה, עם הודעה ב-/status שמבקשת להסיר את המרכאות.

Claude Code מתקן את הבלוקים permissions, autoMode, worktree ו-attribution לפי שדה, במקום להשמיט אותם בשלמותם:

• נעילה בתוך אחד מהם, כמו permissions.disableBypassPermissionsMode, נקראת כערך המגביל שלה.
• permissions.defaultMode לא תקין נקרא כ-default.
• כל עוד רשימת deny או ask ב-permissions לא ניתנת לקריאה בכלל, Claude Code מונע את allow ואת additionalDirectories, כך שההענקות אף פעם לא חלות בלי ההגבלות שנכתבו לידן. הדוח מציין כל הענקה שנמנעה ואת הרשימה שלא ניתן היה לקרוא.
• ב-autoMode, רשימת soft_deny או hard_deny שלא ניתנת לקריאה, או שאיבדה רשומה לא תקינה, מונעת את allow ואת environment באותו אופן.

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

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

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

החלופות של שני המפתחות האלה ושל allowedChannelPlugins דורשות Claude Code v2.1.267 או חדש יותר. גרסאות מוקדמות יותר משמיטות את כל המפתח כשהערך שלו או רשומה כלשהי לא תקינים. החלופות של strictKnownMarketplaces ושל blockedMarketplaces דורשות Claude Code v2.1.277 או חדש יותר. גרסאות מוקדמות יותר משמיטות את כל המפתח כשהערך שלו או רשומה כלשהי לא תקינים. החלופות של strictPluginOnlyCustomization ושל enabledPlugins דורשות Claude Code v2.1.282 או חדש יותר.

requiredMinimumVersion ו-requiredMaximumVersion נכשלים פתוח בכוונה: ערך לא תקין מושמט במקום להיאכף.

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

#ערכים לא תקינים בתוך sandbox

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

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

• אם הגדרתם מפתח בוליאני ל-"true" או "false" במרכאות, הערך נחשב כבוליאני הזה. במקום אזהרה, /status מציג הודעה שמבקשת להסיר את המרכאות.
• אם failIfUnavailable לא תקין, Claude Code משמיט את הערך במקום להתייחס אליו כ-true, כך שערך שלא ניתן לקריאה אף פעם לא עוצר סשנים מלהתחיל בכל הצי.
• Claude Code מתייחס לכל בוליאני לא תקין אחר כערך ששומר את ה-sandbox המחמיר ביותר עד שתתקנו אותו. מפתח שמפעיל את ה-sandbox או אחת מההגבלות שלו, כמו enabled או network.allowManagedDomainsOnly, נחשב כ-true. מפתח שמרכך אותו, כמו allowUnsandboxedCommands, נחשב כ-false.
• ברשימה מחוץ ל-credentials, כמו excludedCommands או network.allowedDomains, Claude Code משמיט רשומה לא תקינה ושומר את שאר הרשימה. רשימה שאינה מערך, או שאין בה רשומה תקינה, לא חלה בכלל.
• כל עוד network.deniedDomains או רשומה כלשהי בתוכו לא תקינים, Claude Code גם מונע את network.allowedDomains, כך שרשימת ההיתר המנוהלת לא מעניקה כלום עד שתתקנו את רשימת הדחייה.
• כל עוד filesystem.denyRead, filesystem.denyWrite, או רשומה כלשהי באחד מהם לא תקינים, Claude Code גם מונע את filesystem.allowRead ואת filesystem.allowWrite עד שתתקנו את רשימת הדחייה.

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

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

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

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

[!NOTE]

בתוכניות Team ו-Enterprise, בעלים מפעיל או מכבה את Remote Control ואת סשנים בענן לכל הארגון בהגדרות הניהול של Claude Code. כשבעלים מכבה את Remote Control, גם סשנים שכבר מחוברים ומריצים Claude Code v2.1.286 או חדש יותר מתנתקים. כל אחד מהם מתנתק בפעם הבאה שהוא מרענן את מדיניות הארגון, בערך פעם בשעה. למה שקורה בסשנים האלה, ראו Remote Control was turned off by your organization's policy.

אפשר בנוסף לכבות את Remote Control לכל מכשיר באמצעות ההגדרה disableRemoteControl. לסשנים בענן אין מפתח הגדרות מנוהלות לכל מכשיר.

כדי לבדוק אם הגדרות הארגון האלה הגיעו למכונה נתונה, הריצו שם claude doctor וקראו את השורה Organization policy, שאומרת מאיפה Claude Code טען את המדיניות או למה הוא לא טען אותה. דורש Claude Code v2.1.261 או חדש יותר. בסשן פעיל, /status מציג את אותה שורה כשהמדיניות לא נטענה.

#כיבוי טלמטריה עבור הארגון

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

{
  "env": {
    "DISABLE_TELEMETRY": "1"
  }
}

Claude Code מחיל ערך 1 בלי להציג למשתמש את תיבת האישור.

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

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

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

#ראו גם

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