📘 תיעוד 158

הפניה לכלים

הפניה מלאה לכלים ש-Claude Code יכול להשתמש בהם, כולל דרישות הרשאה והתנהגות לכל כלי.

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

כדי לקבוע באילו כלים Claude יכול להשתמש ומתי הוא שואל קודם, הגדר כללי הרשאה בהגדרות שלך, hooks, או רשימת כלים של תת-סוכן. ראה הגדרת כלים עם כללי הרשאה ו-hooks לכל מקום שמקבל שם כלי.

כדי להוסיף כלים מותאמים אישית, חבר שרת MCP. כדי להרחיב את Claude עם תהליכי עבודה לשימוש חוזר שמבוססים על הנחיה, כתוב skill, שרץ דרך כלי Skill הקיים ולא מוסיף רשומת כלי חדשה.

[!NOTE]

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

#הגדרת כלים עם כללי הרשאות ו-hooks

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

• ב-permissions.allow וב-permissions.deny בהגדרות, ובממשק /permissions
• בדגלים --allowedTools ו---disallowedTools של ה-CLI
• באפשרויות allowedTools ו-disallowedTools של Agent SDK
• ב-frontmatter של allowed-tools של skill
• ב-תנאי if של hook

כל אלה מקבלים את אותו פורמט כללים, ToolName(specifier). ה-specifier תלוי בכלי, וכמה כלים חולקים פורמט:

כלים שלא מופיעים כאן, כמו ExitPlanMode או ShareOnboardingGuide, מקבלים רק את שם הכלי לבדו, בלי specifier.

כלל allow מסוג Edit(...) מעניק גם גישת קריאה לאותו נתיב, ולכן אין צורך בכלל Read(...) תואם. כלל deny מסוג Read(...) חוסם גם את הכלים Edit ו-Write על אותו נתיב, כולל יצירת קובץ חדש שם, כי שני הכלים משנים תוכן ש-Claude צריך להיות מסוגל לקרוא בחזרה. עבור הכלי Write, בדיקת ה-deny של Read דורשת Claude Code מגרסה v2.1.228 ואילך.

שדות matcher של hook משתמשים בשמות כלים לבדם, לא בפורמט הכלל עם סוגריים. ראו תבניות matcher לכללי ההתאמה. לשמות השדות שכל כלי מעביר ל-tool_input ב-hooks, ראו את הפניה לקלט PreToolUse.

#התנהגות הכלי Agent

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

• Teammate: כש-agent teams מופעלים, קריאה שנושאת name יכולה להפעיל teammate במקום זאת, שמדווח בחזרה באמצעות הודעות צוות ולא על ידי החזרת תוצאה
• Fork: בכל מקום ש-מצב fork פועל, הכלי יכול להפעיל subagent מסוג fork, שיורש את שיחת ההורה המלאה במקום להתחיל מחדש

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

אילו כלים subagent שאינו fork יכול להשתמש תלוי בשדות tools ו-disallowedTools ב-הגדרת ה-subagent:

• אף שדה לא הוגדר: ה-subagent יורש כל כלי שזמין ל-subagents.
• רק tools: ה-subagent מקבל רק את הכלים שברשימה.
• רק disallowedTools: ה-subagent מקבל כל כלי של ההורה חוץ מהכלים שברשימה.
• שניהם הוגדרו: ל-disallowedTools יש קדימות. כלי שמופיע בשניהם מוסר.

בכל מקרה, הקבוצה שנפתרת מוגבלת ל-כלים שזמינים ל-subagents: כלי שאינו זמין ל-subagents לעולם לא מוענק, גם כשהוא רשום ב-tools. כשהתנאים ברשומת טבלת הכלים של SubagentHandback מתקיימים, Claude Code גם נותן ל-subagent את הכלי הזה, גם אם משאירים אותו מחוץ ל-tools או רושמים אותו ב-disallowedTools.

אם כל רשומה ברשימת tools של subagent נכשלת בהתאמה לכלי שמיש, הכלי Agent בדרך כלל מחזיר שגיאה שמציינת את הרשומות במקום להפעיל את ה-subagent. ראו Agent would be spawned with zero tools להודעה ולאופן תיקון כל רשומה.

הפעלת ה-subagent כשלעצמה לא מבקשת הרשאה. Claude Code בודק את קריאות הכלים של ה-subagent מול כללי ההרשאות שלכם בזמן הריצה.

המקום שבו רואים את בקשות ההרשאה של subagent תלוי בשאלה אם הוא רץ בחזית או ברקע. Claude Code מריץ subagents ברקע כברירת מחדל, מלבד המקרים שרצים בחזית.

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

כדי להגביל למה subagent יכול להגיע מלכתחילה, מצמצמים את השדה tools שלו, למשל על ידי השארת Bash מחוץ לרשימה, או מגדירים כללי deny בהגדרות.

#התנהגות הכלי AskUserQuestion

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

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

#פסק זמן להמשך אוטומטי של שאלה

שאלות נשארות פתוחות עד שעונים עליהן. אם רוצים ששאלה שמשאירים בלי מענה תיסגר בסופו של דבר ותאפשר ל-Claude להמשיך בלעדיכם, מגדירים את ההגדרה askUserQuestionTimeout ל-60s, 5m או 10m, או ב-settings.json של המשתמש או מהשורה Question auto-continue timeout ב-/config.

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

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

#התנהגות כלי Bash

כלי Bash מריץ כל פקודה בתהליך נפרד.

#מה נשמר בין פקודות

• כש-Claude מריץ cd בסשן הראשי, ספריית העבודה החדשה עוברת לפקודות Bash הבאות כל עוד היא נשארת בתוך ספריית הפרויקט או בתוך ספריית עבודה נוספת שהוספת עם --add-dir, /add-dir, או additionalDirectories בהגדרות. זה כולל פקודות ש-Claude מריץ בתגובה להודעות המאוחרות שלך.
  • סשנים של סוכן משנה אף פעם לא מעבירים שינויים בספריית העבודה.
  • אם cd מגיע מחוץ לספריות האלה, Claude Code מאפס לספריית הפרויקט ומוסיף Shell cwd was reset to <dir> לתוצאת הכלי.
  • כדי לבטל את ההעברה הזו כך שכל פקודת Bash תתחיל בספריית הפרויקט, הגדר CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR=1.
• משתני סביבה לא נשמרים. export בפקודה אחת לא יהיה זמין בפקודה הבאה.
• כינויים ופונקציות מעטפת שמוגדרים בקובץ האתחול של המעטפת שלך זמינים. בתחילת הסשן, Claude Code טוען את ~/.zshrc, ~/.bashrc, או ~/.profile לפי המעטפת שלך, לוכד את הכינויים, הפונקציות ואפשרויות המעטפת שנוצרים, ומחיל אותם על כל פקודת Bash.

הפעל את ה-virtualenv או את סביבת conda לפני הפעלת Claude Code. כדי שמשתני סביבה יישמרו בין פקודות Bash, הגדר את CLAUDE_ENV_FILE לסקריפט מעטפת לפני הפעלת Claude Code, או השתמש ב-hook של SessionStart כדי למלא אותו באופן דינמי.

#מגבלות זמן פלט

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

שני משתני סביבה שולטים במה ש-Claude מקבל לפקודה שרצה בחזית:

• BASH_DEFAULT_TIMEOUT_MS: ברירת המחדל כש-Claude לא מעביר timeout, שתי דקות מיד עם ההתקנה
• BASH_MAX_TIMEOUT_MS: יחד עם ברירת המחדל, קובע את התקרה שמגבילה כל מה ש-Claude מבקש. התקרה בפועל היא הגדול מבין השניים, עשר דקות מיד עם ההתקנה

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

#מגבלות פלט

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

פקודה שיוצאת עם 1 נחשבת לתוצאה תקינה של כלי Bash רק כש-Claude Code מזהה את קוד היציאה 1 כתוצאה תמימה של הפקודה הזו: grep, rg, egrep, fgrep, find, diff, test, ו-[, וגם git diff ו-git grep. כל פקודה אחרת שיוצאת עם 1 נחשבת לכישלון, גם כשיציאה 1 היא תוצאה מידעית תמימה: אין התאמות ל-pgrep ול-jq -e, קבצים שנבדלים ב-cmp.

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

כדי לשנות כמה מתוצאה תקינה Claude מקבל בשורה, הגדר במקום זאת את ההגדרה bashOutputMaxChars, עד 128,000 תווים. היא קובעת יחד את תקרת השורה ואת חלון הקריאה חזרה, ואז Claude Code מתעלם מ-BASH_MAX_OUTPUT_LENGTH. נדרש Claude Code גרסה v2.1.261 או חדשה יותר.

#פקודות רקע

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

#מתי פקודת רקע נעצרת

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

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

#מגבלת זמן לפקודות רקע

בסשן שרץ בלי השגחה, כמו ריצה עם הדגל -p, אפליקציית Agent SDK, עבודת CI, או סשן בענן, לפקודות Bash ו-PowerShell ברקע יש מגבלת זמן. לסשן מקומי שאתה עובד בו ממסוף, מאפליקציית שולחן העבודה, או מהרחבת VS Code אין מגבלת זמן על פקודות רקע.

מגבלת הזמן דורשת Claude Code גרסה v2.1.285 או חדשה יותר. לפני v2.1.288 היא חלה בכל סשן.

מגבלת הזמן נספרת מהרגע שהפקודה נכנסת לרקע:

• פקודה ש-Claude מתחיל ברקע מקבלת 30 דקות, או את ה-timeout ש-Claude מעביר עם run_in_background, עד מקסימום של שעתיים
• פקודה שמתחילה בחזית ואז עוברת לרקע, למשל ב-timeout שלה, מקבלת 30 דקות מהמעבר

בריצה עם הדגל -p שההנחיה שלה מועברת כטקסט ולא עם --input-format stream-json, שתי ברירות המחדל הן 10 דקות במקום 30, כי הריצה מחכה לפקודות רקע אחרי התוצאה שלה.

כשפקודת רקע מגיעה למגבלת הזמן שלה, Claude Code עוצר אותה ואומר ל-Claude למה, ו-Claude יכול להתחיל את הפקודה שוב עם timeout ארוך יותר אם העבודה עדיין צריכה אותה. הודעת העצירה היא Background command "<description>" was stopped after reaching its background time limit.

#העלאת מגבלת הזמן לפקודות רקע

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

• הגדר את BASH_DEFAULT_TIMEOUT_MS מעל 1800000 כדי להחליף את ברירת המחדל של 30 דקות בערך הזה, גם לפקודות ש-Claude מתחיל בלי timeout וגם לפקודות שעברו. בריצת -p שההנחיה שלה מועברת כטקסט, כל ערך מעל 600000 מחליף את ברירת המחדל של 10 דקות
• הגדר את BASH_MAX_TIMEOUT_MS מעל 7200000 כדי להעלות את המקסימום של שעתיים לערך הזה. הגדרת BASH_DEFAULT_TIMEOUT_MS מעל 7200000 מעלה את המקסימום באותו אופן

#פקודות חזית שעוברות לרקע

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

הגדרת CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1 או ריצה ב-מצב bare מבטלת מעבר אוטומטי לרקע, כך שפקודה שמגיעה ל-timeout שלה נעצרת במקום זאת.

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

• כשה-timeout מפעיל את המעבר, התוצאה מדווחת על כך במפורש: Command did not complete within its 120s timeout and was moved to the background, כשהשניות תואמות ל-timeout שחל, ואחריו מזהה המשימה והנתיב של הקובץ שהפלט נכתב אליו.
• cd, pushd, popd, או chdir בתוך פקודה שהועברה לרקע אף פעם לא עוברים הלאה: התוצאה מציינת Session cwd remains <dir>; directory changes made by the backgrounded command do not apply to subsequent commands., כך ש-Claude לא פועל לפי שינוי ספרייה שלא קרה.

#מגבלת זיכרון ב-Linux וב-WSL

ב-Linux וב-WSL, הגדר את CLAUDE_CODE_TOOL_MEMORY_LIMIT לגודל כמו 4G כדי להגביל את הזיכרון שפקודות של הכלים Bash, PowerShell ו-Monitor יכולות להשתמש בו, כך שבנייה שיצאה משליטה לא תוכל לקחת את הזיכרון ששאר הסשן צריך. נדרש Claude Code גרסה v2.1.233 או חדשה יותר. לפני v2.1.246, פקודות כלי Monitor רצו מחוץ למגבלה.

• כתוב את הגודל כמספר בתים או עם סיומת K, M, G, או T. הגדר 0, off, false, no, או none כדי לכבות את המגבלה. Claude Code מתעלם מכל ערך אחר שהוא לא יכול לקרוא כגודל, כמו 4e9.
• Claude Code סופר את כל פקודות Bash, PowerShell ו-Monitor של סשן מול המגבלה האחת, לא כל פקודה בפני עצמה.
• Claude Code מחיל את המגבלה עם cgroup של זיכרון. כשהוא לא יכול להקים את ה-cgroup, הפקודות רצות בלי מגבלה, ולוג הדיבוג מ-claude --debug אומר למה.
• אחרי שהתהליך הראשון ש-Claude Code מתחיל הפעיל את המגבלה, או כיבה אותה בגלל ערך כיבוי או הקמת cgroup שנכשלה, Claude Code מחזיק את התוצאה הזו עד שתפעיל מחדש. כדי להחיל ערך שהשתנה או הוסר, או הקמה שתוקנה, הפעל את claude שוב.
• כשפקודות לא יכולות להישאר מתחת למגבלה, הקרנל הורג פקודה, ושום דבר בתוצאה שלה לא מציין את המגבלה.

Claude Code יכול גם לספור סוגים אחרים של תהליכים שהוא מתחיל מול אותה מגבלה. הגדר את CLAUDE_CODE_TOOL_MEMORY_CGROUP_EXCLUDE לרשימה מופרדת בפסיקים של הסוגים לפטור מהמגבלה. Claude Code מחיל את המגבלה על כל סוג שאינו ברשימה שלך. הגדר אותו ל-none כדי להגביל כל סוג, או ל-all-new כדי להגביל רק פקודות של הכלים Bash, PowerShell ו-Monitor. נדרש Claude Code גרסה v2.1.246 או חדשה יותר. הסוגים שאפשר לציין:

• mcp: שרתי MCP מקומיים
• lsp: שרתי שפה
• hooks: פקודות hook
• plugin: פקודות שתוספים מריצים
• helper: פקודות העזר של Claude Code עצמו, כמו git
• agent: תהליכי Claude Code ילדים, כמו חברי צוות סוכן

בכל מה שתציין, הכללים האלה חלים:

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

#התנהגות כלי Edit

כלי Edit מבצע החלפת מחרוזת מדויקת. הוא מקבל old_string ו-new_string ומחליף את הראשון בשני. הוא לא משתמש ב-regex או בהתאמה מעורפלת.

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

• קריאה לפני עריכה: Claude קורא את הקובץ בשיחה הנוכחית לפני שהוא עורך אותו, וקריאה שנקטעה עם הודעת PARTIAL view לא נחשבת. Claude Opus 4.6, Claude Haiku 4.5, ומודלים ישנים יותר תמיד דורשים את הקריאה. מודלים חדשים יותר יכולים לערוך קובץ שלא נקרא כשקריאתו לא הייתה צריכה בקשת הרשאה וכלי Read זמין.
• התאמה: old_string חייב להופיע בקובץ בדיוק כפי שנכתב. תו אחד של רווח לבן או הבדל בהזחה מספיק כדי להחטיא.
• ייחודיות: old_string חייב להופיע בדיוק פעם אחת. כשהוא מופיע יותר מפעם אחת, Claude או מספק מחרוזת ארוכה יותר עם מספיק הקשר מסביב כדי לקבע מופע אחד, או מגדיר replace_all: true כדי להחליף את כולם.

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

Claude יכול גם לערוך קובץ בלי Read נפרד אחרי שצפה בו עם פקודת Bash כמו cat או grep. הפקודות האלה הן cat, nl, bat, batcat, head, tail, sed -n 'X,Yp', grep, egrep, fgrep, ו-rg, כל אחת רצה על קובץ אחד בלי צינורות או הפניות. אם הפקודה לא הדפיסה שום טקסט מהקובץ, כמו כשחיפוש לא מוצא כלום, בדיקת הקריאה לפני עריכה עדיין חלה.

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

#קבצים שאינם UTF-8

Claude לא יכול להשתמש ב-NotebookEdit על קובץ שאינו UTF-8 תקין. אותו דבר לגבי Edit, אלא אם הקובץ מתחיל בסימן סדר בתים UTF-16 little-endian. כש-Claude מנסה, הכלי דוחה את השינוי ומשאיר את הקובץ ללא שינוי. קבצים שנדחים כוללים טקסט שאינו ASCII שנשמר בקידוד ישן כמו Windows-1252 או Shift-JIS, קבצים בינאריים, ו-UTF-8 עם רצף בתים לא תקין.

הכלים דוחים כי הם שומרים את כל הקובץ בחזרה כ-UTF-8, מה שהיה מחליף כל בית שהם לא יכולים לפענח בתו ההחלפה U+FFFD. במקום זאת, השגיאה ש-Claude מקבל אומרת לו לבצע את השינוי עם פקודת מעטפת ששומרת על הקידוד של הקובץ, או לשאול אותך על המרה ל-UTF-8 קודם.

Claude עדיין יכול להחליף קובץ כזה עם Write, אלא אם התוכן החדש מכיל U+FFFD, התו ש-Read מראה ל-Claude במקום בתים שהוא לא יכול לפענח. השמירה הזו מונעת מ-Claude לכתוב בחזרה את הטקסט המעוות שהוא קרא. כש-Write כן מחליף את הקובץ, הוא שומר את התוכן החדש כ-UTF-8, כך שהקידוד המקורי של הקובץ אובד.

#התנהגות הכלי EndConversation

הכלי EndConversation מסיים את הסשן הנוכחי. Claude משתמש בו רק בשני מצבים:

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

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

אחרי ש Claude מסיים סשן אינטראקטיבי, הסשן ננעל. פרומפטים חדשים ורוב הפקודות מחזירים Claude ended this conversation. Start a new session (or /clear) to continue., ורק /clear, /resume, /help, /exit ו /feedback עדיין רצים. Claude Code רושם את הסיום בתמליל הסשן, כך שחידוש סשן שנגמר מחזיר את הנעילה. היסטוריית הסשן לא נמחקת.

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

הכלי אף פעם לא מבקש הרשאה, והוקים של PreToolUse לא רצים עבורו. כל עוד נשאר כלי אחר, גם אי אפשר לחסום אותו: כללי deny ו ask שמציינים את EndConversation אינם משפיעים, וגם --disallowedTools וגם רשימת --tools לא יכולים להסיר אותו. הפטור מכוון: הכלי לא עושה דבר מלבד לסיים את השיחה, אף פעם לא קורא או משנה קבצים או נתונים, ואמצעי הגנה מהסוג הזה תקף רק אם הסשן שעליו הוא חל לא יכול לכבות אותו. כשכללי ה deny שלך מסירים כל כלי אחר וגם תואמים ל EndConversation, כמו ש "*" עושה, Claude Code מסיר גם אותו במקום להשאיר אותו ככלי היחיד, אלא אם כלל allow מציין את EndConversation במפורש. רשימת deny שמסירה כל כלי אחר בלי להתאים ל EndConversation משאירה אותו במקום.

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

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

• מודל: המודל של הסשן הוא Claude Opus 4.8, Claude Sonnet 5, Claude Fable 5, או גרסה מאוחרת יותר של אחת מהמשפחות האלה.
• משטח: סשן מסוף אינטראקטיבי, כולל סשן claude במסוף המשולב של IDE, וכך התוסף של JetBrains מריץ אותו. משטחים אחרים לא כוללים את הכלי, כגון:
  • ריצות -p לא אינטראקטיביות
  • סשנים דרך חבילות TypeScript ו Python של Agent SDK
  • לוח ההרחבה של VS Code, שמאגד CLI משלו
  • GitHub Actions
  • סשנים בענן
• מצב הפעלה: לא סשן --bare. מצב bare טוען רק כלי מעטפת וקבצים, כך שהכלי אף פעם לא נרשם שם.
• ספק: לא זמין ב Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, או Microsoft Foundry, או בסשנים שמחוברים דרך שער ענן.

#התנהגות הכלי EnterWorktree

הכלי EnterWorktree יוצר git worktree מבודד ועובר אליו. בהינתן path, הוא עובר ל worktree קיים במקום ליצור חדש.

• אילו worktrees יכול path לציין: בכניסה הראשונה היעד יכול להיות worktree של המאגר הנוכחי. במאגר שמחזיק מאגרים אחרים, הוא יכול גם להיות worktree של מאגר מקונן בתוכו.
• מתי מוצגת בקשה: path מחוץ ל .claude/worktrees/ מבקש את האישור שלך לפני הכניסה, כי הוא מעביר את ספריית העבודה של הסשן ואת גישת הכתיבה למיקום הזה. יצירת worktree חדש ונתיבים תחת .claude/worktrees/ לא מבקשים. לפני v2.1.206, Claude נכנס לנתיבים מחוץ ל .claude/worktrees/ בלי בקשה.
• מתוך worktree: מתוך סשן worktree, רק צורת ה path זמינה והיעד חייב להיות תחת .claude/worktrees/ של מאגר הסשן. אותו דבר חל על סוכן משנה עם ספריית עבודה נעוצה, כגון isolation: worktree.
• כשהכלי חסר: ברגע ש permissions.blockWritesOutsideWorkingDirectories פועל, Claude Code מסיר את EnterWorktree ואת ExitWorktree או מסרב לקריאות אליהם. כדי להמשיך לעבוד ב worktrees, ראה ל Claude אין כלי EnterWorktree.

#התנהגות הכלי Glob

הכלי Glob מוצא קבצים לפי תבנית שם. ב Windows, הוא חלק מקבוצת הכלים ברירת המחדל. ב macOS, Linux ו WSL, Claude Code משאיר את Glob ואת Grep מחוץ לקבוצת הכלים ברירת המחדל, ו Claude מחפש עם find ו grep דרך הכלי Bash במקום זאת. במעטפת של Claude שתי הפקודות האלה מריצות גרסאות מוטמעות של bfs ו ugrep, והחיפושים מגיעים להוקים ולכללי ההרשאה שלך כקריאות Bash.

ב macOS, Linux ו WSL, אתה מקבל את הכלים Glob ו Grep בחזרה במקרים האלה:

• אתה מציין Glob או Grep ב --tools או --allowedTools כשאתה מתחיל את הסשן, או באפשרויות המקבילות של Agent SDK. עם --tools אתה מקבל את אלה שאתה מציין, וציון אחד מהכלים ב --allowedTools מחזיר את שניהם. כלל allow בקובץ הגדרות לא משפיע כך.
• כלל deny של הרשאות, הדגל --disallowedTools, או --restricted מסיר את Bash מהסשן.
• סוכן משנה מציין Glob או Grep בשדה tools שלו ומשאיר בחוץ את Bash. הכלים שצוינו חוזרים עבור אותו סוכן משנה בלבד, או עבור כל הסשן כשהוא רץ כסוכן הסשן הראשי דרך --agent או הגדרת agent.

Glob תומך בתחביר glob רגיל כולל ** להתאמת ספריות רקורסיבית:

• **/*.js מתאים לכל קבצי .js בכל עומק
• src/**/*.ts מתאים לכל קבצי .ts תחת src/
• *.{json,yaml} מתאים לקבצי .json ו .yaml בספרייה הנוכחית

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

Glob לא מכבד את .gitignore כברירת מחדל, כך שהוא מוצא קבצים שב gitignore לצד קבצים במעקב. זה שונה מ Grep, שמדלג על קבצים שב gitignore. כדי ש Glob יכבד את .gitignore, הגדר CLAUDE_CODE_GLOB_NO_IGNORE=false לפני הפעלת Claude Code.

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

ערך pattern או path שמכיל בית null מחזיר שגיאה שמבקשת מ Claude להסיר אותו.

#התנהגות הכלי Grep

הכלי Grep מחפש תוכן קבצים לפי תבניות. במקום ש Glob מוצא קבצים לפי שם, Grep מוצא שורות בתוכם. ב macOS, Linux ו WSL, Grep נעדר כברירת מחדל באותם תנאים כמו Glob. ראה התנהגות הכלי Glob לגבי מתי שני הכלים זמינים.

Grep בנוי על ripgrep ומשתמש בתחביר הביטויים הרגולריים של ripgrep, לא ב grep של POSIX. תבניות שכוללות מטא תווים של ביטוי רגולרי צריכות escaping. לדוגמה, מציאת interface{} בקוד Go דורשת את התבנית interface\{\}.

תבנית, glob, או סוג קובץ ש ripgrep דוחה מחזירים שגיאה שכוללת את האבחון של ripgrep, כך ש Claude יכול לתקן את הקלט ולחפש שוב. לפני v2.1.208, Claude Code דיווח על קלט שנדחה כ No files found במקום כשגיאה, גם כשהטקסט שחיפשו היה קיים בקבצי היעד.

שלושה מצבי פלט שולטים במה שחוזר:

• files_with_matches: נתיבי קבצים בלבד, בלי תוכן שורות. זו ברירת המחדל.
• content: שורות תואמות עם קובץ ומספר שורה. כשפרמטר offset של הכלי מצביע מעבר להתאמה האחרונה של תבנית שיש לה התאמות, Grep מחזיר No entries at this offset, כך ש Claude מרחיב או מאפס את ה offset במקום להסיק שהתבנית לא תואמת.
• count: מספר התאמות לכל קובץ, ואחריו סה"כ על פני כל הקבצים התואמים. הסה"כ מכסה כל התאמה גם כשפרמטרי head_limit או offset של הכלי מקצצים את הרשומות לכל קובץ שמוצגות.

Claude יכול לתחום תוצאות לפי קובץ עם פרמטר glob, כגון **/*.tsx, או לפי שפה עם פרמטר type, כגון py או rust. כברירת מחדל, תבניות תואמות בתוך שורה אחת. Claude יכול להגדיר multiline: true כדי להתאים מעבר לגבולות שורה.

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

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

#התנהגות הכלי LSP

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

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

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

Claude Code מחזיר תוצאת שגיאה לכל קריאת LSP על קובץ שאת שרת השפה שלו הוא לא יכול להפעיל.

#הכלי Monitor

הכלי Monitor מאפשר ל Claude לצפות במשהו ברקע ולהגיב כשהוא משתנה, בלי להשהות את השיחה. בקש מ Claude:

• לעקוב אחרי קובץ לוג ולסמן שגיאות כשהן מופיעות
• לדגום PR או משימת CI ולדווח כשהסטטוס שלה משתנה
• לצפות בספרייה לשינויי קבצים
• לעקוב אחרי פלט מכל סקריפט ארוך שאתה מפנה אותו אליו
• להתחבר להזנת WebSocket ולדווח על כל הודעה כשהיא מגיעה

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

אתה ממשיך לעבוד באותו סשן ו Claude מתערב כשמגיע אירוע.

לכל מעקב ש Claude מתחיל יש מועד סיום: 5 דקות כברירת מחדל, לכל היותר 30 דקות, ולכל היותר 10 דקות בריצה לא אינטראקטיבית שניתנת לה פרומפט יחיד עם -p.

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

עצור monitor בבקשה מ Claude לבטל אותו או בסיום הסשן. כשאתה עוצר סוכן משנה שהתחיל monitors, לדוגמה מ /tasks, ה monitors האלה נעצרים איתו.

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

למקור WebSocket יש בקשת אישור משלו, שעליה המסווג גם מחליט במצב auto.

Monitor צריך גרסת מינימום או Git Bash במקרים האלה:

• גרסת מינימום: ב Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, או Microsoft Foundry, או כש DISABLE_TELEMETRY או CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC מוגדרים, Monitor דורש Claude Code v2.1.310 או מאוחר יותר. הדרישה חלה כששליפת דגלי תכונה כבויה
• Windows: הכלי זמין רק כשGit Bash מותקן

תוספים יכולים להצהיר על monitors שמתחילים אוטומטית כשהתוסף פעיל, במקום לבקש מ Claude להתחיל אותם. ראה monitors של תוספים.

#מקור WebSocket

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

• הודעות טקסט: כל אחת הופכת לאירוע אחד, גם כשההודעה משתרעת על כמה שורות.
• הודעות בינאריות: לא מועברות הלאה. Claude מקבל שורת מציין מקום כגון [binary frame, 512 bytes] במקום.
• הודעות גדולות מ 1 MiB: המעקב נגמר, אז הירשם להזנה מסוננת כשיש כזו.
• סגירת socket: המעקב נגמר ו Claude מקבל את קוד הסגירה.

מעקב WebSocket מקבל קלט ws במקום command, וקריאת Monitor אחת לא יכולה לשלב את השניים. לקלט ws יש שני שדות:

מועד הסיום timeout_ms חל גם על מעקב WebSocket: המעקב נגמר במועד הסיום, ו TaskStop מבטל אותו מוקדם.

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

Claude Code דוחה כתובות שמצביעות על כתובת פרטית, link-local, או cloud-metadata, כולל שמות מארח שנפתרים לאחת כזו. הוא גם דוחה מארחים ב sandbox.network.deniedDomains, וכש allowManagedDomainsOnly מוגדר בהגדרות מנוהלות, כל מארח מחוץ לרשימת ההיתר המנוהלת.

#התנהגות הכלי NotebookEdit

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

שלושה מצבי עריכה שולטים במה שקורה לתא היעד:

• replace: דריסת המקור של התא. זו ברירת המחדל.
• insert: הוספת תא חדש אחרי היעד. בלי cell_id, התא החדש נכנס בתחילת המחברת. דורש cell_type מוגדר ל code או markdown.
• delete: הסרת תא היעד.

NotebookEdit מסרב לקובץ מחברת שלא מפוענח כ UTF-8, לפי אותו כלל כמו Edit, ולא כותב דבר.

כללי הרשאה משתמשים בתבנית הנתיב Edit(...). כלל כמו Edit(notebooks/**) מכסה קריאות NotebookEdit על קבצים באותה ספרייה.

#כלי PowerShell

כלי PowerShell מאפשר לקלוד להריץ פקודות PowerShell באופן מקורי. ב-Windows, הפקודות רצות ב-PowerShell במקום לעבור דרך Git Bash. האופן שבו הכלי זמין תלוי בפלטפורמה:

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

הוקי PreToolUse מקבלים את מחרוזת הפקודה של הכלי ב-tool_input.command, עם אותם שדות כמו כלי Bash.

התאימו Bash|PowerShell בהוקים שבודקים פקודות מעטפת. הקטע על קלט הוק PowerShell מסביר למה התאמה ל-Bash בלבד לא מספיקה.

#הפעלת כלי PowerShell

הגדירו CLAUDE_CODE_USE_POWERSHELL_TOOL=1 בסביבה או ב-settings.json:

{
  "env": {
    "CLAUDE_CODE_USE_POWERSHELL_TOOL": "1"
  }
}

ב-Windows, הגדירו את המשתנה ל-0 כדי לכבות את הכלי. ב-Linux, macOS ו-WSL, הכלי דורש PowerShell 7 או חדש יותר: התקינו pwsh וודאו שהוא ב-PATH.

ב-Windows, Claude Code מזהה אוטומטית את pwsh.exe עבור PowerShell 7+ עם נפילה חזרה ל-powershell.exe עבור PowerShell 5.1. כשהכלי מופעל, קלוד מתייחס ל-PowerShell כמעטפת הראשית. כלי Bash נשאר זמין לסקריפטים של POSIX כש-Git Bash מותקן.

Claude Code מפעיל את PowerShell עם -ExecutionPolicy Bypass בהיקף התהליך בלבד, כך שסקריפטים של .ps1 וייבוא מודולים עובדים בהתקנות Windows ברירת מחדל בלי לשנות את מדיניות המכונה. עקיפה בהיקף התהליך לא דורסת Group Policy מסוג MachinePolicy או UserPolicy, ולכן מדיניות ארגונית עדיין חלה. כדי לכבד את מדיניות הביצוע האפקטיבית של המכונה במקום זאת, הגדירו CLAUDE_CODE_POWERSHELL_RESPECT_EXECUTION_POLICY=1.

#כללי דחייה של Bash מכבים גם את כלי PowerShell

ב-Windows עם Git Bash מותקן, דחיית Bash מכבה גם את כלי PowerShell לסשן. זה חל על כללים מוגדרים בהיקף כמו Bash(git push *) וגם על Bash לבדו, ועל כללים מאחד מקובצי ההגדרות או מ---disallowedTools. Claude Code עושה זאת כי כלל Bash לא מגביל את כלי PowerShell, שיש לו כללי הרשאה משלו. אם PowerShell נשאר פעיל, קלוד יכול להריץ שם את מה שהכלל דוחה ב-Bash.

כדי להשאיר את כלי PowerShell פעיל לצד כלל דחייה של Bash, עשו אחד מאלה:

• הגדירו CLAUDE_CODE_USE_POWERSHELL_TOOL=1 בסביבה או בבלוק env של קובץ הגדרות, כמו שמוצג ב-הפעלת כלי PowerShell.
• הוסיפו כלל הרשאה מוגדר בהיקף ל-PowerShell לקובץ הגדרות, למשל כלל דחייה PowerShell(git push *).

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

#בחירת מעטפת בהגדרות, בהוקים וב-skills

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

• "defaultShell": "powershell" ב-settings.json: מנתב פקודות ! אינטראקטיביות דרך PowerShell. דורש שכלי PowerShell יהיה מופעל.
• "shell": "powershell" ב-הוקי פקודה בודדים: מריץ את ההוק הזה ב-PowerShell. הוקים מפעילים את PowerShell ישירות, ולכן זה עובד בלי תלות ב-CLAUDE_CODE_USE_POWERSHELL_TOOL.
• shell: powershell ב-frontmatter של skill: מריץ בלוקים של !`command` ב-PowerShell. דורש שכלי PowerShell יהיה מופעל.

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

פקודות PowerShell מקבלות גם את המשתנים שהוקים משמרים דרך CLAUDE_ENV_FILE, בתנאים שב-משתנים שנשמרים בפקודות PowerShell. דורש Claude Code v2.1.296 או חדש יותר.

#קוד יציאה 1 מחיפושים ומ-git diff ב-PowerShell

אם חיפוש grep או rg שלא מוצא התאמות מציג Error: Exit code 1 כשקלוד מריץ אותו בכלי PowerShell, החיפוש לא נכשל. אין צורך לעשות דבר. השגיאה יכולה להופיע כשהחיפוש הוא חלק מפקודה ארוכה יותר. לדוגמה, כש-rg יוצא עם קוד 1, rg foo | Out-Null מציג את השגיאה ו-rg foo לא.

כלי PowerShell יכול לספור קוד יציאה 1 כתוצאה רגילה מ-grep, rg, egrep, fgrep, findstr, git grep ו-git diff. החיפושים משתמשים בקוד יציאה 1 כדי לדווח שאין התאמות. מ-git diff, קוד יציאה 1 אומר שהקבצים שונים. פקודה שמציגה את השגיאה כשקלוד מריץ אותה נחשבת כנכשלת ב-skill עם shell: powershell.

#קידוד וקודי יציאה ב-Windows

• הפניה מחדש עם > ו->> כותבת קבצי UTF-8 ב-PowerShell 5.1
• Claude Code מקודד טקסט שמועבר בצינור לקלט הסטנדרטי של פקודה מקורית כ-UTF-8
• Claude Code לוכד פלט שגיאה בלי רצפי מילוט של ANSI
• פקודה שתהליך הילד שלה ממתין לקלט סטנדרטי מקבלת סוף קובץ במקום להיתקע
• אם where.exe לא מוצא התאמה, או fc.exe או diff.exe מוצאים שהקבצים שונים, התוצאה יכולה להציג Error: Exit code 1 אף שהפקודה לא נכשלה. אין צורך לעשות דבר.
• אם קוד יציאה של robocopy מ-1 עד 7 מוצג כשגיאה, ההעתקה לא נכשלה ואין צורך לעשות דבר. robocopy יוצא עם קוד 0 עד 7 כדי לדווח על תוצאה, למשל קבצים שהועתקו, ועם 8 או גבוה יותר כשהוא נכשל.

#מגבלות תצוגה מקדימה

לכלי PowerShell יש את המגבלות הידועות הבאות במהלך התצוגה המקדימה:

• פרופילי PowerShell לא נטענים
• ב-Windows, sandboxing לא נתמך

#התנהגות כלי Read

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

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

Read מטפל בכמה סוגי קבצים מעבר לטקסט רגיל:

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

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

  Read מסרב לקובץ תמונה גדול מ-128 MB עם שגיאה שאומרת לקלוד לשנות את גודל התמונה או לייצא עותק קטן יותר, ואז לקרוא את העותק הזה. אם קלוד עוצר בשגיאה במקום לעשות זאת, ראו File is too large to read as an image.

• PDF: קלוד קורא קבצי .pdf קצרים בשלמותם. ל-PDF ארוכים מ-10 עמודים, הוא קורא בטווחים עם פרמטר pages, למשל "1-5", עד 20 עמודים בכל פעם. קריאות טווח עמודים מרנדרות עמודים עם pdftoppm מ-poppler-utils, אז התקינו אותו עם brew install poppler ב-macOS או apt-get install poppler-utils ב-Debian וב-Ubuntu. ב-Windows ובפלטפורמות אחרות, התקינו בניית poppler שמציבה את pdftoppm ב-PATH. בלי זה, קריאת טווח עמודים נכשלת עם pdftoppm is not installed.

• מחברות Jupyter: קבצי .ipynb מחזירים את כל התאים עם הפלטים שלהם, כולל קוד, markdown והמחשות. מחברת שהתאים שלה מגיעים ליותר מ-256 KB, או יותר מ-מגבלת הטוקנים, מחזירה שגיאה במקום. Claude Code מסרב לקרוא קובץ מחברת מעל 100 MB. השגיאה אומרת לקלוד איך לקרוא חלק מהמחברת במקום, למשל פרוסה של תאים, עם פקודת מעטפת.

Read קורא רק קבצים, לא ספריות. קלוד מציג את תוכן הספרייה עם פקודת מעטפת כמו ls.

Read מסרב לקובץ שהסיומת שלו נחשבת בינארית, למשל .xlsx, .parquet, .heic או .zip. קלוד ממשיך לעבוד אחרי סירוב: השגיאה מציעה skill לסוג הקובץ אם יש כזה, או פקודת מעטפת או סקריפט שקוראים את הפורמט. אם אתם מזכירים עם @ קובץ ש-Read מסרב לו, קלוד מקבל את נתיב הקובץ אבל לא את התוכן שלו.

#קבצים גדולים

קלוד יכול לקרוא קובץ טקסט גדול ממה שקריאת Read אחת מחזירה. כברירת מחדל קריאה אחת מחזירה לכל היותר 25,000 טוקנים, או את הערך שהגדרתם ב-CLAUDE_CODE_FILE_READ_MAX_OUTPUT_TOKENS, ומסרבת לקובץ שלם מעל 256 KB, ולכן קלוד קורא קובץ גדול יותר בעמודים עם offset ו-limit. ב-Claude Code v2.1.296 או חדש יותר הוא יכול במקום זאת לקרוא את כל הקובץ, או טווח שורות ארוך, בקריאה אחת על ידי הגדרת allow_large: true כשהוא צריך, למשל כי ביקשתם את כל הקובץ. הקריאה הזו מותאמת למקום שנשאר ב-חלון ההקשר של הסשן במקום למגבלות ברירת המחדל. תמונות, PDF ומחברות שומרים על המגבלות שלהם.

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

• קובץ שלם מעל מגבלת הטוקנים: העמוד הראשון של הקובץ, עם הודעת PARTIAL view שאומרת כמה מהקובץ הוא קיבל ואיך לקרוא עוד עם offset ו-limit
• קובץ שלם מעל 256 KB, או קריאה עם offset או limit מעל מגבלת הטוקנים: שגיאה שאומרת לו לקרוא חלק עם offset ו-limit, או לחפש תוכן ספציפי עם Grep במקום

#התנהגות כלי SendFeedback

משוב שקלוד ניסח הוא דוח משוב על Claude Code שקלוד כותב עבורכם. הוא דורש Claude Code v2.1.238 או חדש יותר. Claude Code שומר כל טיוטה במכונה שלכם תחת ~/.claude/feedback/drafts/, ושום דבר לא מגיע ל-Anthropic עד שאתם שולחים אותו. קלוד מנסח טיוטה עם כלי SendFeedback כש:

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

#מה רואים כשקלוד מנסח טיוטה

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

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

#עיון ועריכה של טיוטה

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

• לערוך את הכותרת, התחום והפרטים
• להגדיר את Send transcript ל-yes או no. כשתמליל הסשן שבו קלוד הכניס את הטיוטה לתור עדיין זמין, הוא מתחיל ב-yes, ששולח את השיחה הזו ל-Anthropic. no שולח רק את הדוח
• לשלוח את הטיוטה, למחוק אותה, או להשאיר אותה בתור להמשך

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

#שליחת טיוטה

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

הדוח כולל:

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

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

ב-ארגונים עם Zero Data Retention, ובארגונים שבהם חלה הגדרת HIPAA, Claude Code משאיר את כלי SendFeedback מחוץ לסשנים. אם סשן בארגון עם Zero Data Retention עדיין מציע את הכלי, הטיוטות נשארות במכונה, והשליחה נכשלת עם Feedback collection is not available for organizations with custom data retention policies.

#מחיקה או שמירה של טיוטה

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

#כיבוי משוב שקלוד ניסח

הגדירו את Claude-drafted feedback ל-off ב-/config, שכותב את ההגדרה feedbackDrafts, או הגדירו CLAUDE_CODE_SEND_FEEDBACK=0 לסשן אחד. עם אחד מאלה, קלוד לא יכול להכניס טיוטות לתור. כדי להשאיר ניסוח פעיל בלי כרטיסים, הגדירו את feedbackDrafts ל-quiet במקום. מנהלים יכולים להגדיר את feedbackDrafts ב-הגדרות מנוהלות, שגוברות על ההגדרה שלכם.

#סשנים בלי משוב שקלוד ניסח

Claude Code כולל את הכלי בסשני מסוף אינטראקטיביים במכונה שלכם שמשתמשים ב-Claude API ולא בספק ענן. הוא משאיר את הכלי מחוץ ל:

• הרצות -p לא אינטראקטיביות וסשנים של Agent SDK, שאין בהם מסך לעיון בתור
• סשני ענן, שלא יכולים לכתוב לתור במכונה שלכם
• סשנים ב-Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, או Microsoft Foundry
• סשנים שבהם הגדרתם CLAUDE_CODE_SEND_FEEDBACK=0 או DISABLE_FEEDBACK_COMMAND=1, הגדרתם את CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC לכל ערך לא ריק, או כיביתם שליפת דגלי תכונות
• ארגונים שכיבו משוב על המוצר, ארגונים עם Zero Data Retention, וארגונים שבהם חלה הגדרת HIPAA

#זמינות כלי המשימות

כלי מעקב המשימות, TaskCreate, TaskGet, TaskUpdate, TaskList ו-TodoWrite, זמינים כברירת מחדל רק ב-Opus 4.7, ב-Sonnet 4.6, ב-Haiku 4.5 ובמודלים מוקדמים יותר. בכל מקום שהכלים זמינים, מקבלים את ארבעת כלי ה-Task, או את TodoWrite במקומם כשמגדירים CLAUDE_CODE_ENABLE_TASKS=0.

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

כדי להשתמש בכלים האלה במודל שאין לו אותם כברירת מחדל, עושים אחד מהבאים:

• מייצאים את CLAUDE_CODE_ENABLE_TODO_TOOLS=1 לפני שמפעילים את Claude Code, למשל CLAUDE_CODE_ENABLE_TODO_TOOLS=1 claude. אז Claude Code מספק את אותם כלים בכל מודל ובכל ספק
• מציינים אחד מהכלים ב---allowedTools, למשל claude --allowedTools TaskCreate
• מפרטים את הכלים ב---tools, מה שמגביל את הכלים המובנים של הסשן לאלה שהוא מציין. כוללים את הכלים הרצויים לצד שאר הכלים המובנים שבשימוש
• ב-Agent SDK, האפשרויות allowedTools ו-tools פועלות באותו אופן כמו שני הדגלים

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

ערכת ברירת המחדל שמתוארת כאן חלה ב-Claude Code v2.1.268 ואילך.

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

לסוכן משנה יש את כלי מעקב המשימות רק כשלסשן יש אותם, בכל מודל שעליו רץ סוכן המשנה. לחבר צוות בצוות סוכנים שרץ בתוך התהליך יש את כלי מעקב המשימות כשלסשן יש אותם. חבר צוות ב-split-pane הוא תהליך Claude Code נפרד שיורש את רשימת --tools ואת כללי ה-deny, לא את --allowedTools, לכן בודקים מה הוגדר:

• אין רשימת --tools ואין כלל deny, ו-CLAUDE_CODE_ENABLE_TODO_TOOLS לא מוגדר עבור חבר הצוות: לחבר הצוות יש את כלי מעקב המשימות שיש למודל שלו כברירת מחדל.
• CLAUDE_CODE_ENABLE_TODO_TOOLS מיוצא במעטפת: Claude Code מעביר לחבר הצוות סט קבוע של משתני סביבה שלא כולל את המשתנה שיוצא. כדי להגדיר אותו גם עבור חבר הצוות, מתחילים את הסשן בהרצת claude --settings '{"env":{"CLAUDE_CODE_ENABLE_TODO_TOOLS":"1"}}' במעטפת. חבר הצוות מקבל גם את ערך ה---settings.
• --tools שמציין את כלי מעקב המשימות: לחבר הצוות יש אותם בכל מודל.
• כלי מעקב משימות חסר מ---tools או מצוין בכלל deny: לחבר הצוות אין את הכלי הזה.

בלי כלי ה-Task, סוכן מתאם עם הצוות שלו באמצעות הודעות במקום רשימת המשימות המשותפת.

#התנהגות הכלי WebFetch

WebFetch מקבל URL ופרומפט שמתאר מה לחלץ. הוא שולף את הדף וממיר את התגובה ל-Markdown כשהשרת מחזיר HTML. ברוב השליפות הוא מריץ אחר כך את הפרומפט על התוכן בקריאת מודל נפרדת, ו-Claude מקבל את תוצאת הקריאה הזו ולא את הדף הגולמי. שלב ההמרה אינו ניתן להגדרה.

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

כמה התנהגויות מעצבות את התגובה ש-Claude מקבל:

• WebFetch מסרב ל-localhost ולכל שם מארח אחר בלי נקודה, למשל שם אינטראנט חשוף, לפני שליחת בקשה. השגיאה שהוא מחזיר אומרת ל-Claude להגיע לשרתים מקומיים באמצעות curl דרך Bash.
• כתובות URL ב-HTTP משודרגות אוטומטית ל-HTTPS.
• WebFetch קורא עד 100,000 תווים מתוכן הדף בכל קריאה. ב-Claude Code v2.1.290 ואילך, התוצאה עבור דף ארוך יותר אומרת ל-Claude כמה לא נקרא, כדי ש-Claude יוכל לשלוף את החלק הבא.
• WebFetch שומר כל תגובה במטמון ל-15 דקות כברירת מחדל, ולכן שליפות חוזרות של אותו URL חוזרות במהירות. ב-Claude Code v2.1.233 ואילך, מגדירים את CLAUDE_CODE_WEBFETCH_CACHE_TTL_MS כדי לשנות כמה זמן WebFetch שומר כל תגובה.
• דף שההורדה שלו לא הסתיימה בתוך חמש דקות, כולל כל הפניה ש-WebFetch עוקב אחריה, נכשל עם שגיאת דדליין. ב-Claude Code v2.1.268 ואילך, מגדירים את CLAUDE_CODE_WEBFETCH_DEADLINE_MS כדי לשנות את המגבלה, או ל-0 כדי להסיר אותה.
• כש-URL מפנה למארח אחר, WebFetch מחזיר תוצאת טקסט שמציינת את ה-URL המקורי ואת יעד ההפניה, במקום לעקוב אחרי ההפניה. אחר כך Claude שולף את ה-URL החדש בקריאת WebFetch שנייה.
• כששלב החילוץ נתקל ב-API בעומס, Claude Code מנסה שוב עם backoff. שליפה שעדיין נכשלת מחזירה תוצאת שגיאה.

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

• Yes: מאשר את השליפה הזו בלבד. קריאת WebFetch הבאה מבקשת שוב, גם עבור אותו דומיין.
• Yes, and don't ask again for <domain>: מאשר את השליפה ושומר כלל allow מסוג WebFetch(domain:...) עבור הדומיין הזה בקובץ .claude/settings.local.json של המאגר. ראו איך אישורים שנשמרו נשארים. כשהארגון מגדיר allowManagedPermissionRulesOnly, Claude Code מסתיר את האפשרות הזו.
• No, and tell Claude what to do differently: דוחה את השליפה.

כדי להתיר דומיין מראש בלי בקשה, מוסיפים כלל allow כמו WebFetch(domain:example.com). WebFetch(domain:*) מתיר כל דומיין. מצבי ההרשאה auto ו-bypassPermissions מתוך מצבי ההרשאה מדלגים על הבקשה, למעט דומיין שכלל ask מפורש תואם לו.

כלל WebFetch(domain:...) מפורש ב-deny, ב-ask או ב-allow גובר על הסט שאושר מראש, כך שאפשר לחסום דומיין שאושר מראש או לדרוש בקשה עבורו.

כשה-URL הוא קישור ל-artifact של claude.ai, Claude Code יכול גם לבקש אישור לקרוא את ה-artifact עצמו. למקרים שבהם הוא מבקש, ראו קריאת artifact ששותף איתך.

WebFetch מגדיר כותרת User-Agent שמתחילה ב-Claude-User, וכותרת Accept שמעדיפה Markdown על פני HTML, כדי ששרתים שתומכים במשא ומתן על תוכן יוכלו להחזיר Markdown ישירות.

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

#זמינות WebFetch

ב-Claude Code v2.1.285 ואילך, מגדירים את CLAUDE_CODE_DISABLE_WEB_FETCH ל-1 כדי לכבות את WebFetch.

אם נכנסים עם חשבון claude.ai מסוג Team או Enterprise ולא מתחברים דרך שער LLM, WebFetch תלוי גם במדיניות הארגון, ש-Claude Code מבקש מ-api.anthropic.com כשסשן מתחיל. כך גם בסשן ש-Claude Code לא יכול לקבוע את התוכנית שלו, למשל סשן שרץ תחת אסימון claude.ai שאפליקציה אחרת סיפקה.

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

#התנהגות הכלי WebSearch

WebSearch מריץ שאילתה מול צד השרת של חיפוש האינטרנט של Anthropic ומחזיר כותרות תוצאה וכתובות URL. הוא לא שולף את דפי התוצאות. כדי לקרוא דף ש-Claude מוצא בתוצאות החיפוש, הוא ממשיך עם WebFetch.

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

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

כללי ההרשאה של WebSearch לא מקבלים מציין. רשומת WebSearch חשופה ב-allow או ב-deny היא הצורה היחידה.

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

[!NOTE]

WebSearch זמין ב-Claude API, ב-Claude Platform on AWS וב-Microsoft Foundry. ב-Agent Platform של Google Cloud הוא עובד עם Opus 4, Sonnet 4, Haiku 4.5 ומודלים מאוחרים יותר. Amazon Bedrock לא חושף את כלי חיפוש האינטרנט בצד השרת.

#מגבלת חיפוש בסשן

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

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

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

• העלאת התקרה: מגדירים את משתנה הסביבה CLAUDE_CODE_MAX_WEB_SEARCHES_PER_SESSION למספר שלם חיובי, למשל 500. אפשר להעלות את התקרה, אבל אי אפשר לכבות אותה.
• המתנה למילוי מחדש: ב-Claude Code v2.1.290 ואילך, המגבלה של סשן מסוף אינטראקטיבי מתמלאת מחדש בקצב של כ-100 קריאות בשעה. כדי לשנות את הקצב, מגדירים את CLAUDE_CODE_WEB_SEARCH_REFILLS_PER_HOUR למספר קריאות בשעה, למשל 50.
• התחלת שיחה חדשה: הרצת /clear בשורת Claude Code מאפסת גם את המונה. אם עבודה שעדיין יכולה להפעיל סוכני משנה שורדת את הניקוי, למשל תהליך עבודה שרץ, המונה עובר הלאה.

במצב לא אינטראקטיבי עם -p וב-Agent SDK, המגבלה חלה לכל תור, לא לכל סשן. תור נמשך מהודעה שנשלחת עד ש-Claude מסיים להגיב. המגבלה מתאפסת כששולחים את ההודעה הבאה אחרי זה, או כשמתחילים הרצת claude -p חדשה, גם עם --continue או --resume. לעוד חיפושים, מעלים את CLAUDE_CODE_MAX_WEB_SEARCHES_PER_SESSION או מגדירים קצב מילוי מחדש עם CLAUDE_CODE_WEB_SEARCH_REFILLS_PER_HOUR.

#התנהגות הכלי Write

הכלי Write יוצר קובץ חדש או דורס קובץ קיים עם התוכן המלא שסופק. הוא לא מצרף ולא ממזג. Write גם דורס קובץ קיים שהבתים שלו לא ניתנים לפענוח ושומר את התוכן החדש כ-UTF-8, כפי שמתואר תחת קבצים שאינם UTF-8.

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

• Claude Opus 4.6, Claude Haiku 4.5 ומודלים ישנים יותר תמיד דורשים את הקריאה, ולכן Write לקובץ קיים שלא נקרא נכשל עם שגיאה.
• מודלים חדשים יותר יכולים לדרוס קובץ שהם לא קראו בסשן הזה באותם תנאים כמו קריאה לפני עריכה: הקריאה שלו לא הייתה דורשת בקשת הרשאה, והכלי Read זמין.
• מחברות Jupyter, וקבצים ש-Claude קרא רק חלקית עם הודעת PARTIAL view, דורשים את הקריאה בכל מודל.

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

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

לשינויים חלקיים בקובץ קיים, Claude משתמש ב-Edit במקום ב-Write.

#בדיקה אילו כלים זמינים

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

What tools do you have access to?

Claude נותן סיכום שיחתי. לשמות מדויקים של כלי MCP, מריצים /mcp.

[!NOTE]

כלי היועץ הוא כלי שרת שה-API מריץ, ולא כלי ש-Claude Code מממש. אין לו שם שאפשר להפנות אליו בכללי הרשאה או במתאמי hook.

#ראו גם

• שרתי MCP: הוספת כלים מותאמים על ידי חיבור שרתים חיצוניים
• הרשאות: מערכת ההרשאות, תחביר כללים, ודפוסים ספציפיים לכלי
• סוכני משנה: הגדרת גישה לכלים עבור סוכני משנה
• Hooks: הרצת פקודות מותאמות לפני ביצוע כלי או אחריו