📘 תיעוד 42

ניהול כמה סוכנים עם תצוגת סוכנים

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

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

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

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

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

[!NOTE]

תצוגת סוכנים נמצאת ב-research preview. הממשק וקיצורי המקלדת עשויים להשתנות ככל שהיכולת מתפתחת.

#התחלה מהירה

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

1. פתיחת תצוגת סוכנים

מהמעטפת, הריצו:

claude agents

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

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

2. שיגור סשן

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

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

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

3. הצצה ותשובה

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

4. התחברות וניתוק

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

5. הכנסת סשן קיים

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

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

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

• רמז: הכותרת התחתונה מציגה ← for agents למשך עשר שניות אחרי שהסשן נפתח. לחיצה על ← עדיין עובדת אחרי שהרמז נעלם
• ספירת המתנה: בזמן שסשני רקע ממתינים לקלט שלכם, אותו מקום סופר אותם, למשל ← 2 agents, או ← 99+ agents כשיותר מ-99 ממתינים. הספירה מתרעננת בערך כל עשר שניות בזמן שהטרמינל בפוקוס, ומיד כשהפוקוס חוזר
• ספירת סיום: כשסשני רקע מסתיימים בהצלחה בזמן שאף אחד לא ממתין לקלט, הכותרת התחתונה מציגה לזמן קצר כמה הסתיימו, למשל ← 2 done עבור שניים

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

#פתיחת תצוגת סוכנים כברירת מחדל

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

1. הפעלת ההגדרה

בסשן claude רגיל, הריצו /config והפעילו את Open agents view by default. כדי לדלג על התפריט, הגדירו את המפתח defaultToAgentsView ישירות:

/config defaultToAgentsView=true

2. הפעלת Claude Code

צאו מהסשן, ואז הריצו claude בלי ארגומנטים:

claude

תצוגת הסוכנים נפתחת במקום שיחה חדשה.

כדי להתחיל סשן רגיל בזמן שההגדרה פועלת, העבירו הנחיה: claude "fix the login test". כדי לכבות את ההגדרה, הריצו /config defaultToAgentsView=false בסשן רגיל או בסשן שהתחברתם אליו מתצוגת הסוכנים.

#מעקב אחרי סשנים עם תצוגת סוכנים

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

השם נצבע בצבע שהוגדר על ידי /color באותו סשן, כולל כשמעבירים סשן לרקע עם ← או /background.

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

claude agents --cwd ~/projects/my-app

זה מציג רק סשנים שהתחילו תחת הספרייה הזו. זה עדיין מציג סשן שעבר ל-worktree תחת ~/projects/my-app/.claude/worktrees/.

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

Pinned
  ✽ clawd walk cycle          Drawing the walk-cycle sprite frames          3m

Ready for review
  ∙ jump physics              Opened PR with collision fix                 #2048  2h

Needs input
  ✻ power-up design           double jump or wall climb?                    1m

Working
  ✽ collision detection       Adding swept-AABB checks to CollisionSystem   2m
  ✢ playtest level 3          all checkpoints cleared ×12                in 4m

Completed
  ✻ title screen              menu, options, and credits done               9m
  ∙ sound effects             14 SFX exported to assets/audio               4h
  … 6 more

#קריאת מצב הסשן

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

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

התווית #N או !N שיכולה להופיע בקצה הימני של שורה היא קישור ל-pull request או merge request של הסשן, והיא לא חלק מאייקון המצב.

כותרת לשונית הטרמינל מציגה את ספירת הממתינים לקלט בזמן שתצוגת הסוכנים פתוחה: 2 awaiting input · claude agents כשסשנים צריכים קלט, או claude agents כשאף אחד לא צריך.

כדי לקרוא את מצב הסשן מסקריפט או מתוכנית אחרת, השתמשו ב-claude agents --json ולא בקבצים תחת ~/.claude/jobs/.

בזמן שתצוגת הסוכנים פתוחה, Claude Code שולח גם התראה דרך ערוץ התראות הטרמינל שהגדרתם, כשסשן רקע מקומי מתחיל להזדקק לקלט שלכם, מסתיים, או נכשל. סשנים שרצים לפי לוח זמנים, כמו סשני /loop, מודיעים רק כשהם צריכים את הקלט שלכם. ההתראות משתמשות באותה הגדרת preferredNotifChannel כמו שאר Claude Code, ומפעילות את hook בשם Notification עם הסוג agent_needs_input או agent_completed.

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

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

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

#סיכומי שורה

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

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

כשהרשימה מקובצת לפי ספרייה, הסיכום נפתח במצב הסשן כמילה צבעונית, למשל Needs input · double jump or wall climb?. בקיבוץ ברירת המחדל לפי מצב, כותרת הקבוצה כבר מציינת את המצב, ולכן השורה מציגה רק את הסיכום.

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

#סטטוס pull request

כשסשן פותח pull request, Claude Code מוסיף תווית בקצה הימני של השורה, מקושרת ל-pull request:

• Claude Code כותב את התווית כ-#1234 עבור pull request, וכ-!1234 עבור merge request של GitLab.
• Claude Code פולט את הקישור גם כשהוא לא מזהה תמיכה בהיפר-קישורים, למשל מעל SSH או tmux. הגדירו FORCE_HYPERLINK=0 כדי להציג את התווית כטקסט רגיל.
• אחרי ששולחים המשך לסשן, Claude Code שומר את התווית בזמן שהשורה חוזרת להתקדמות חיה.

סשן שעובד על pull request קיים מקושר אליו באותו אופן. Claude Code מוצא את ה-pull request בצורה שונה לפי הפקודה ש-Claude מריץ:

• כש-Claude עורך, מגיב, סוגר, או מסמן pull request כמוכן עם gh, Claude Code מקשר את ה-pull request שהפלט של הפקודה עצמה מציין. פקודת gh שהפלט שנלכד ממנה לא מציין pull request לא יוצרת קישור. gh pr merge הוא המקרה הנפוץ, כי הוא מדפיס את התוצאה רק לטרמינל אינטראקטיבי.
• כש-Claude מוציא pull request עם gh pr checkout או דוחף לענף, Claude Code מחפש את הענף עם gh pr view ומקשר את ה-pull request הפתוח שלו.
• ה-pull request לא חייב להתקיים כבר כש-Claude דוחף: Claude Code מנסה שוב את חיפוש הענף אחרי עד חמש פקודות git, gh, glab, או curl מאוחרות יותר שרצות באותה ספרייה, כך ש-pull request שנוצר אחרי הדחיפה, כולל אחד ש-Claude יוצר דרך GitHub REST API, מקושר כשניסיון חוזר מוצא אותו.

כשסשן מקושר ליותר מ-pull request אחד, התווית מציגה ספירה, למשל 3 PRs, בצבע של ה-pull request הפתוח שהכי צריך תשומת לב. פתחו את לוח ההצצה כדי לראות את כולם.

מספר ה-pull request נצבע לפי הסטטוס שלו:

עבור משימה שמסתיימת ב-pull request, בדקו את התווית הזו עבור התוצאה: סקרו ומזגו את ה-pull request כשהמספר שלו הופך לירוק.

#הצצה ומענה

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

• סשן שממתין לך: השאלה המדויקת שהוא שואל, מעל שדה התשובה
• סשן שהסתיים: התוצאה שלו
• סשן שעובד: משפט הסטטוס המלא שלו

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

• שורה כמו waiting 3m: כמה זמן הסשן ממתין לך. הגיל בקצה הימני של השורה הוא מספר אחר: הוא סופר מהרגע שהסשן התחיל
• safe mode · customizations are off: הסשן הזה רץ עם ההתאמות האישיות שלך כבויות כי הפעלת אותו מהמעטפת עם claude --bg --safe-mode. אפשר להשאיר אותו כמו שהוא. כדי להמשיך את השיחה עם ההתאמות האישיות חזרה, הרץ claude stop <id> ואז claude --resume, שניהם במעטפת שלך

רוב הזמן לוח ההצצה מספיק ואין צורך לפתוח את התמליל המלא.

הקלד תשובה בלוח ההצצה ולחץ Enter כדי לשלוח אותה לסשן הזה. הוסף ! בתחילת תשובה כדי לשלוח פקודת Bash במקום. מה שקורה לתשובה תלוי בסשן ובמה שאתה שולח:

• סשן שעובד: /model, /effort, /rename ו-/usage רצים מיד. תשובות אחרות מצטרפות לתור ההודעות של הסשן במקום לקטוע את התשובה, ונכנסות לתוקף כשקלט שבתור נכנס לתוקף. פקודות אחרות ממתינות לסיום הסבב, גם כאלה שרצות ברגע שמקלידים אותן בהנחיה של הסשן עצמו
• תשובה שהיא בדיוק /stop: עוצרת את הסשן מיד במקום להימסר אליו, בין אם הסשן עובד ובין אם הוא ממתין לך
• משימת מעטפת: התשובה, כולל /stop, עוברת לטרמינל של הפקודה כקלט שהוקלד

כשהסשן ממתין לך, איך עונים מלוח ההצצה תלוי במה שהוא ממתין לו:

• שאלה עם אפשרויות מוגדרות מראש: הלוח מציג את האפשרויות לפי מספר. כששדה התשובה ריק, לחץ על המספר של אפשרות כדי למלא אותו, ואז Enter כדי לשלוח, או הקלד תשובה משלך במקום
• שאלה בלי אפשרויות מוגדרות מראש: הקלד את התשובה. כשהשדה הריק מציג תשובה מוצעת, לחץ Tab כדי למלא אותה וערוך אותה לפני השליחה
• בקשת הרשאה או תיבת דו שיח אחרת, כמו בקשת ארגז חול או בקשת קלט של שרת MCP: תשובה לא עונה על זה. ההודעה ממתינה בתור. כדי לענות לתיבת הדו שיח, הצמד עם →

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

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

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

השתמש ב-↑ וב-↓ כדי להציץ בסשנים סמוכים בלי לסגור את הלוח, או ב-→ כדי להצמיד.

#הצמדה לסשן

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

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

בזמן שאתה מוצמד, /install-github-app ורשימת ההגדרות של /mcp עובדות כרגיל, כי אדם בטרמינל יכול להשלים את תיבות הדו שיח שלהן. כשאף אחד לא מוצמד, הפקודות האלה לא יכולות לפתוח את תיבות הדו שיח שלהן, ולכן הסשן מופיע תחת Needs input בתצוגת הסוכנים עם שורה כמו open this session to manage MCP servers, ותשובת התמליל אומרת את אותו דבר. הצמד והרץ את הפקודה שוב כדי להמשיך. שורת ה-needs-input מתנקה כשמצמידים. /mcp reconnect <server>, /mcp enable ו-/mcp disable עובדות בלי הצמדה כך או כך.

סשנים מוצמדים תמיד מוצגים במצב מסך מלא, בלי קשר להגדרת tui שלך, כי לסשן רקע אין scrollback של טרמינל לצרף אליו. גלול עם PgUp, PgDn, או גלגלת העכבר, ולחץ Ctrl+O למצב תמליל. הגלילה המקורית של הטרמינל ומצב ההעתקה של tmux מציגים רק את אזור התצוגה הנוכחי, כמו כשמריצים כל יישום במסך מלא.

סשן מוצמד לא מדווח את הסטטוס שלו לטרמינל שלך.

לחץ ← על הנחיה ריקה, או הרץ /exit, כדי להתנתק ולחזור לתצוגת הסוכנים, בין אם פתחת את הסשן מתצוגת הסוכנים ובין אם עם claude attach <id> מהמעטפת.

← גם מנתק בזמן ששכבת העל של /btw פתוחה. נדרש Claude Code v2.1.257 או חדש יותר. שאלת צד שעדיין עונה ממשיכה לרוץ בזמן שאתה לא שם. בפעם הבאה שמצמידים, שכבת העל נפתחת מחדש איתה, או עם התשובה שלה.

ב-Windows, אם לוחצים ← בתוך בערך חצי שנייה מההצמדה, Claude Code מציג Ambiguous ←, press again to detach, כי בחלון הזמן הזה הטרמינל יכול למסור שוב לחיצה מלפני שהצמדת. לחץ ← שוב כדי להתנתק.

Ctrl+Z גם מנתק אבל חוזר למקום שממנו התחלת: תצוגת הסוכנים אם הצמדת משם, או המעטפת אם הרצת claude attach. השתמש ב-Ctrl+Z כשתיבת דו שיח במיקוד ולא מגיבה ל-←.

Ctrl+C שומר על התנהגות הקטיעה הרגילה שלו בזמן הצמדה: הוא מבטל תשובה שרצה או פקודת מעטפת ! במקום לנתק. לחיצה על Ctrl+C פעמיים על הנחיה ריקה מנתקת.

התנתקות אף פעם לא עוצרת סשן רקע: ←, Ctrl+Z, /exit, ו-Ctrl+C כפול או Ctrl+D כפול כולם משאירים אותו רץ. אם מתנתקים בזמן ש-/loop ממתין לאיטרציה הבאה שלו, הלולאה ממשיכה לרוץ והאיטרציה הזו מתחילה בזמן המתוכנן בלעדיך. כדי לעצור את הלולאה לפני שמתנתקים, ראה עצירת לולאה. כדי לסיים סשן מתוכו, הרץ /stop.

#מעבר בין סשנים בלי לצאת מהטרמינל

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

אם לוחצים ← מיד אחרי שמוחקים את שארית הטקסט של ההנחיה או עוברים בהיסטוריית ההנחיות, Claude Code מבקש אישור: הלחיצה הראשונה מציגה Press ← again to open agents, או Press ← again to go back to agents בסשן מוצמד, והלחיצה השנייה מבצעת את המעבר.

כש-← מעביר סשן חזית לרקע, תצוגת הסוכנים מציגה Your conversation moved to the background מעל הרשימה, עם השורה של הסשן הזה כבר נבחרת. משם:

• לחץ Enter כדי לפתוח מחדש את השיחה.
• לחץ Esc כדי לבטל את המעבר ולחזור לשיחה. אם Esc מציג Still starting , try again in a moment, סשן הרקע עדיין לא מוכן, אז לחץ Esc שוב בעוד רגע.
• לחץ Ctrl+C פעמיים כדי לצאת למעטפת.

כש-Claude Code לא יכול לפתוח מחדש את השיחה, הוא יוצא ומדפיס פקודת claude --resume שמחדשת אותה.

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

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

אם כלי רץ כשלוחצים ←, Claude Code ממתין שהוא יסתיים לפני המעבר לרקע, ו-Claude ממשיך את התשובה בסשן הרקע. לחץ ← שוב כדי לעבור לרקע מיד במקום להמתין. כשעבודה ברקע שכבר בתנועה לא יכולה לעבור לסשן הרקע, Claude Code מציג קודם את תיבת הדו שיח Background this session?, כמו עם /background.

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

• סוכני משנה בחזית עדיין רצים: Claude Code ממשיך להמתין כדי שהעבודה של סוכני המשנה בחזית ש-Claude התחיל תעבור, ומציג Still backgrounding after the current tool. לחץ ← שוב כדי לעבור לרקע בלי להמתין, וזה מפעיל מחדש את סוכני המשנה האלה מההתחלה.
• בקשת הרשאה או שאלה ממתינה לתשובה שלך: בזמן שבקשת הרשאה או שאלה ש-Claude שאל ממתינה, Claude Code ממשיך להמתין ומציג Still backgrounding after the current tool , a question is waiting for your answer. אם התשובה שלך מאפשרת לסבב להמשיך, כמו Yes בבקשת הרשאה, Claude Code מעביר את הסשן לרקע כשהכלי הנוכחי מסתיים.
• אתה מקליד בשדה ההנחיה: Claude Code מבטל את המעבר, כי טקסט שלא נשלח נשאר בתיבת הקלט של הטרמינל ולא יעבור לסשן הרקע. הוא מציג Backgrounding cancelled , you have unsent text in the input. Send it or clear it, then press ← again. Claude ממשיך לעבוד בחזית.
• אתה עוצר את הסבב: Claude Code מבטל את המעבר ומציג Backgrounding cancelled , the turn was stopped. לדוגמה, הסבב נעצר כשקוטעים את Claude עם Esc או בוחרים No בלי הערה בבקשת הרשאה מהשיחה הראשית, או לוחצים Esc על שאלה ש-Claude שואל שם. לחץ ← שוב כדי להעביר את הסשן לרקע.
• הודעה בתור לא יכולה לעבור: הודעות שהכנסת לתור בזמן ש-Claude עבד עוברות לסשן הרקע עם השיחה. כשאחת מהן לא יכולה, הסשן נשאר בחזית ו-Claude Code מציג הודעה כמו Cannot open agents , 1 queued message can't move to the background. Press ← again once Claude has read it.

כש-Claude Code מעביר את הסשן לרקע, אחרי בערך עשר שניות או אחרי שלוחצים ← שוב, הוא עוצר פקודת מעטפת ש-Claude עדיין מריץ בחזית. Claude Code לא מציג את תיבת הדו שיח Background this session? עבור הפקודה הזו. בסשן הרקע, ל-Claude אין תיעוד שהפקודה התחילה, ולכן Claude עשוי להריץ את הפקודה שוב. כדי להשאיר את הפקודה רצה כשהסשן עובר, לחץ Ctrl+B כדי להפוך אותה לפקודת רקע בזמן ש-Claude Code עדיין ממתין.

לחיצה על ← יוצרת את השורה של הסשן גם כשלשיחה עדיין אין הודעות, כך ש-→ עדיין חוזר אליה.

אפשר לכבות את הקיצור הזה עבור סשני חזית עם ההגדרה leftArrowOpensAgents ב-/config.

#הנחיות שנשלחות כשהסשן עובר לרקע

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

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

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

#סידור הרשימה

תצוגת הסוכנים מקבצת סשנים כך שאלה שצריכים קלט נמצאים למעלה, עם Ready for review ו-Needs input מעל Working ו-Completed. שמות הקבוצות האלה לא מתאימים אחד לאחד למצבים שלמעלה: סשן עובר ל-Ready for review כשיש לו בקשת משיכה פתוחה שצריכה סקירה או שיש לה בדיקות שנכשלות, ו-Completed אוסף יחד סשנים שהסתיימו, נכשלו ונעצרו.

לחץ Ctrl+S כדי לקבץ לפי תיקייה במקום. הבחירה שלך נשמרת בין הרצות.

בתוך קבוצה:

• לחץ Ctrl+T כדי לנעוץ סשן למעלה ולהשאיר את התהליך שלו רץ בזמן שהוא לא פעיל
• לחץ Shift+↑ או Shift+↓ כדי לשנות את סדר הסשנים
• לחץ Ctrl+R כדי לשנות שם של סשן
• לחץ Enter על כותרת קבוצה כדי לכווץ אותה, חוץ מבזמן שמסנן פעיל, ואז כל קבוצה נשארת פתוחה
• לחץ Ctrl+X כדי לעצור סשן ו-Ctrl+X שוב בתוך שתי שניות כדי למחוק אותו מהרשימה, או Esc כדי לבטל את האישור בלי למחוק. הלחיצה השנייה מוחקת את הסשן גם כשניסיון העצירה נכשל, למשל כי שירות הרקע לא מגיב. במקרה הזה האישור נשאר פעיל לעוד שתי שניות, והמחיקה מסיימת את התהליך של הסשן עצמו

לחיצה על Ctrl+X בכותרת קבוצה מוחקת כל סשן בקבוצה הזו אחרי אישור. חוץ מהמקרים שנשמרים ומכוסים במה מחיקת סשן מסירה, מחיקה מסירה את הסשן מהרשימה. worktree ש-Claude יצר עבורו מוסר, נשמר, או נשאר במקום לפי איך שמוחקים ומה ה-worktree מכיל. תמליל השיחה נשאר במחשב המקומי, זמין דרך claude --resume.

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

#החזרת סשן קודם

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

/resume נכשל עם isn't available in agent view כאשר:

• /resume מציין מזהה או מונח חיפוש
• התצוגה מוגבלת עם --cwd
• התצוגה הופעלה עם --safe-mode
• התצוגה נפתחה עם דגל כמו --permission-mode או --settings

אם הקלדת משהו אחרי /resume, הקלד מחדש בלעדיו. אם השתמשת באחד מהדגלים האלה, הרץ claude agents במעטפת בלעדיו, ואז הקלד /resume לבד.

#סינון סשנים

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

כדי לשלב מסננים, התחל ב-a:, s:, n:, או o: והוסף עוד, מופרדים ברווחים. הרשימה מציגה את הסשנים שתואמים את כולם. לדוגמה, s:blocked a:reviewer מציג את סשני reviewer שממתינים לך.

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

#קיצורי מקלדת

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

הקיצורים שיש להם פעולה בהקשר Agents עוקבים אחרי keybindings.json שלך. כך גם Ctrl+G, דרך הקישור chat:externalEditor בהקשר Chat.

#שיגור סוכנים חדשים

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

#שיגור סוכן מתצוגת הסוכנים

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

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

הדבק תמונה בהנחיה כדי לצרף צילום מסך או תרשים למשימה.

טקסט מודבק שארוך מ-800 תווים, או יותר משלוש שורות, מתקפל למציין מקום [Pasted text #N] כדי שהקלט יישאר בשורה אחת. הטקסט המלא נשלח כשמשגרים. כדי לבדוק או לערוך את הטקסט המקופל לפני השיגור, הדבק שוב את אותו טקסט והמציין מקום נפתח בחזרה לתוך הקלט.

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

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

• /exit ו-/quit סוגרים את תצוגת הסוכנים
• /logout מנתק אותך
• /model, /effort ו-/fast קובעים עם מה הסשנים שתשגר בהמשך יתחילו. /effort ו-/fast דורשים Claude Code גרסה v2.1.299 או חדשה יותר.
• /login פותח את תיבת ההתחברות כדי שאפשר להתחבר שוב בלי להתחבר לסשן
• /resume לבדו, או הכינוי /continue שלו, פותח בורר של סשני העבר של המאגר כדי להחזיר אחד כסשן רקע

מיומנויות, פקודות משלך, ופקודות מובנות שמרחיבות הנחיה כמו /init נשלחות לסשן רקע חדש כהנחיה הראשונה שלו. הרמז isn't available in agent view אומר שהפקודה המובנית שהזנת לא רצה. כדי להריץ אותה, התחבר לסשן והזן אותה שם. כל מה שהקלדת נשאר בקלט ליד הרמז כדי שאפשר לערוך אותו.

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

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

#שיגור לתיקייה מסוימת

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

• פתח claude agents באותה תיקייה.

• פתח claude agents בתיקיית אב ואזכר מאגר ילד עם @<repo> בהנחיה. הקלדת @ מציגה את היעדים האלה:

  • מאגרי Git ברמה אחת מתחת לתיקיית ההפעלה
  • עצי העבודה של git הרשומים של המאגר שממנו הפעלת, שנמצאים בתוך עץ התיקיות שלו, כמו אלה ש-Claude יוצר תחת .claude/worktrees/, עם תווית של הענף שנמשך בהם. עצי עבודה שנוספו מחוץ למאגר, למשל עם git worktree add ../feature, אינם מופיעים ברשימה
  • כל תיקייה שכבר יש לה סשן ברשימה

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

• מהמעטפת, בצע cd לתיקייה והרץ claude --bg "<prompt>".

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

#שליחה או העתקה של סשן לרקע

שתי פקודות מעבירות עבודה מהסשן שבו אתה נמצא לרקע: /background שולחת את השיחה הנוכחית לשם ומשחררת את המסוף, ו-/fork שולחת עותק בזמן שאתה ממשיך לעבוד במקום שבו אתה נמצא.

#שליחת הסשן לרקע

הרץ /background או את הכינוי /bg שלו כדי להעביר את השיחה הנוכחית לסשן רקע. העבר הנחיה כמו /bg run the test suite and fix any failures כדי לתת הוראה נוספת אחת קודם. אם Claude מגיב כשאתה מריץ /bg, התשובה ממשיכה בסשן הרקע.

אם יוצאים מסשן בזמן שסוגים מסוימים של עבודת רקע רצים, כמו תת-סוכנים או תהליכי עבודה, תיבת דו-שיח Background work is running מזהירה שהעבודה נעצרת. בחר Move to background and exit כדי להעביר את הסשן לרקע באותו אופן ש-/background עושה ולחזור למעטפת. האפשרות אינה מוצגת כשתצוגת הסוכנים כבויה.

אם לסשן רקע ברשימה כבר יש את שם השיחה, Claude Code ממספר את שם השורה החדשה, למשל my-session (2), ומשאיר את שם השורה הקיימת כפי שהוא. כדי לשנות את שם השורה החדשה, בחר אותה בתצוגת הסוכנים ולחץ Ctrl+R.

#העתקת הסשן עם /fork

הרץ /fork כדי להעתיק את השיחה הנוכחית לסשן רקע חדש בזמן שהמקור ממשיך לרוץ. העותק מתחיל עם כל מה שבשיחה עד לאותה נקודה. ראה את הסעיפים למטה לגבי המקום שבו העותק רץ. הוא גם מעביר את המודל, מצב ההרשאות, רמת המאמץ, וכל תיקייה או הענקות הרשאה מסוג "don't ask again" שהוספת במהלך הסשן. העותק מופיע כשורה משלו בתצוגת הסוכנים.

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

כשתצוגת הסוכנים כבויה, /fork מתחיל תת-סוכן מפוצל במקום להעתיק את הסשן.

#מתן הנחיה לעותק ופתיחת הסשן שלו

העבר הנחיה כמו /fork open a draft pull request with the work so far והעותק מתחיל לעבוד עליה מיד. בלי הנחיה העותק ממתין להוראה הראשונה שלו: בחר את השורה שלו ב-claude agents ולחץ Space כדי לשלוח אחת, או הרץ claude attach <id>. השורה הנבחרת מציגה space to send it a prompt בזמן שהיא ממתינה.

אישור ה-/fork הוא שורה אחת שמציגה את מצב העותק, למשל session running, את שם השורה שלו בתצוגת הסוכנים, ואת מזהה הסשן עבור claude attach. לחץ על השם כדי לעבור אל העותק: הסשן הזה עובר לרקע, כמו לחיצה על ←, ותצוגת הסוכנים פותחת את הסשן של העותק.

#איפה העותק רץ

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

המקום שבו העותק מתחיל תלוי במקום שבו הסשן הנוכחי רץ:

• כמו כל סשן ששוגר, העותק עובר לעץ עבודה משלו לפני עריכת קבצים. במקרה הזה האישור אינו מציין איפה העותק רץ.
• כשהסשן שלך עבר לעץ העבודה המקושר שלו אחרי שהתחיל, העותק מתחיל בחזרה במקום שבו הסשן היה לפני המעבר, וכל עוד הוא אינו עורך במקום, הוא מבצע את שינויי הקוד בעץ עבודה משלו שם. כשעץ העבודה שלך נמשך על ענף, ההוראה הזו גם אומרת לעותק שהמשימה שלו נשענת על העבודה שלך לבסס את הענף החדש שלו על שלך, כי הענף שלך נשאר נמשך בעץ העבודה שלך. האישור מסתיים ב-runs in the origin tree.
• כשהפעלת את הסשן בתוך עץ עבודה מקושר של מאגר שיש לו עץ עבודה ראשי, העותק מתחיל באותו עץ עבודה ראשי, עם אותו כלל של עץ עבודה משלו אבל בלי הוראת ענף. גם כאן האישור מסתיים ב-runs in the origin tree.
• לסשן שהופעל בתוך עץ עבודה של פריסת מאגר חשוף אין עץ עבודה ראשי לחזור אליו, ולכן העותק נשאר במקום שבו הוא נמצא, והאישור מסתיים ב-edits this checkout. אותו ציון מופיע כשבידוד עץ העבודה כבוי בסשן שאינו בתוך עץ עבודה מקושר, כי אז העותק עורך את הקבצים הפתוחים אצלך.

#סשנים שאי אפשר לפצל

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

#מה עובר כשמעבירים לרקע

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

• עובר: פקודות מעטפת ברקע שרצות, תת-סוכנים שהועברו לרקע, משימות מתוזמנות שיצרת עם /loop, ותשובות אוטומטיות של Claude להערות על artifact ממשיכים לרוץ בסשן הרקע. תת-סוכן עובר יחד עם כל מה שהוא התחיל, ולכן הוא עובר רק כשכל העבודה הזו יכולה לעבור גם היא.
• ממשיך רק כש-Claude מפעיל מחדש: תהליך עבודה דינמי שרץ. אם תהליך העבודה לא המשיך כשבודקים את סשן הרקע, בקש מ-Claude להפעיל אותו מחדש.
• נעצר: עבודה שאי אפשר להעביר לסשן הרקע, כמו מוניטור שרץ. כשעבודה כזו רצה, Claude Code מציג את תיבת הדו-שיח Background this session? כדי לאשר לפני שהעבודה נעצרת. תת-סוכן ברקע שבבעלותו מוניטור נעצר יחד עם המוניטור.

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

דגלי הגדרה מההפעלה המקורית עוברים לסשן שהועבר לרקע, ולכן שרתי ה-MCP, ההגדרות ומודל הגיבוי שלו נשארים בתוקף:

• --mcp-config ו---strict-mcp-config
• --settings
• --setting-sources
• --add-dir
• --plugin-dir
• --fallback-model
• --allow-dangerously-skip-permissions

תיקיות שהוספת במהלך הסשן עם /add-dir עוברות גם הן. העברה של --allow-dangerously-skip-permissions משאירה את bypassPermissions נגיש בסשן שהועבר לרקע, אבל אינה מעניקה דבר חדש: המצב עדיין צריך שקבלת כתב הוויתור על העקיפה שלך תהיה רשומה.

#תהליכי עבודה דינמיים כשמעבירים לרקע

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

כש-Claude מפעיל מחדש את תהליך העבודה, כל תת-סוכן שלו שעדיין רץ כשהעברת את הסשן לרקע מתחיל מחדש ומוציא שוב את הטוקנים שלו. אם לוחצים ← או מריצים /background בזמן שאחד מהם עדיין רץ, תיבת הדו-שיח Background this session? אומרת כמה. כדי לתת להם לסיים קודם, בחר Stay.

#שיגור סוכן מהמעטפת

העבירו --bg או את הצורה הארוכה --background כדי להתחיל סשן שעובר ישר לרקע:

claude --bg "investigate the flaky SettingsChangeDetector test"

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

אם מריצים claude --bg ממסוף בתיקייה שעדיין לא נתתם בה אמון, תיבת הדו-שיח של אמון בסביבת העבודה מופיעה קודם, והסשן מתחיל אחרי שמאשרים. אם דוחים, Claude Code יוצא בלי להתחיל סשן. במקום שבו לא יכולה להופיע תיבת דו-שיח, למשל בסקריפט, הפקודה יוצאת עם שגיאת Workspace not trusted.

כדי להריץ תת-סוכן מוגדר, למשל code-reviewer, כסוכן הראשי של הסשן, שלבו --bg עם --agent:

claude --agent code-reviewer --bg "address review comments on PR 1234"

אם השם לא תואם לאף אחד מתת-הסוכנים, ההפעלה נכשלת: Claude Code מדפיס אזהרת no agent named ועדיין מדווח שהסשן עבר לרקע, אבל הסשן יוצא מיד עם שגיאת --agent '<name>' not found.

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

כדי להמשיך שיחה קיימת ברקע, העבירו את מזהה הסשן המלא עם --resume:

claude --resume 1f0e2c9a-6d0b-4c11-9f39-2a77c1d4e8b5 --bg "pick up where you left off and finish the migration"

ב-Claude Code גרסה v2.1.257 ואילך, Claude Code או ממשיך את הסשן תחת אותו מזהה, או מתחיל עותק תחת מזהה חדש ומדפיס שורת note: שמסבירה למה לא היה אפשר להמשיך במקום. כשהסשן ממשיך במקום, claude agents מציג עבורו שורה אחת.

כשמשלבים --bg עם --continue, עם --resume בלי ערך, או עם --resume עם שם או נתיב קובץ, Claude Code תמיד מתחיל עותק כזה. הוסיפו --fork-session כדי להתחיל עותק בכוונה, בלי ההערה.

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

claude --bg --name "flaky-test-fix" "investigate the flaky SettingsChangeDetector test"

אחרי המעבר לרקע, Claude מדפיס את המזהה הקצר של הסשן ואת הפקודות לניהול שלו. כשהשירות שמארח סשנים ברקע עדיין לא רץ, --bg עשוי קודם להדפיס Starting background service… מעל הפלט הזה. כשמעבירים --name, השם מופיע אחרי המזהה הקצר:

backgrounded · 7c5dcf5d · flaky-test-fix
  claude agents             list sessions
  claude attach 7c5dcf5d    open in this terminal
  claude logs 7c5dcf5d      show recent output
  claude stop 7c5dcf5d      stop this session

#פרומפטים שמכילים --bg

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

claude --bg "find out why --bg sessions are slow to start on this machine"

Claude Code קורא ארגומנט שלם כדגל רק במקום שבו דגל יכול לעמוד: לפני מפריד -- חשוף, ולא במקום שבו דגל אחר מצפה לערך שלו. שימו את הדגל ראשון, כמו ב-claude --bg "<prompt>".

כשהמיקום דו-משמעי, למשל אחרי רצף של דגלים קצרים משולבים, Claude Code לא מתחיל כלום. הוא יוצא עם Couldn't tell whether --bg is a flag or text here.

#הרצת פקודת מעטפת

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

claude --bg --exec 'pytest -x'

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

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

כדי לראות את הפלט, התחברו לשורה, לחצו Space כדי להציץ בלי להתחבר, או הריצו claude logs <id> מהמעטפת. הפלט שנלכד נשאר בזיכרון ולא נכתב לדיסק. השורה והפלט שלה מתנקים אוטומטית בערך חמש דקות אחרי שהפקודה יוצאת, אז קראו אותו לפני כן אם צריך את התוצאה.

#איך עריכות קבצים מבודדות

כשמשגרים סשן רקע מתצוגת הסוכנים או מתחילים אחד עם claude --bg, הסשן מתחיל בתיקיית העבודה. לפני עריכת קבצים, Claude מעביר את הסשן ל-git worktree מבודד תחת .claude/worktrees/, כך שסשנים מקבילים יכולים לקרוא את אותו checkout אבל כל אחד כותב לשלו. ברגע שהסשן נמצא ב-worktree שלו, Claude Code אוכף בידוד worktree לסשן ולכל תת-סוכן שהוא מפעיל.

Claude מדלג על ה-worktree במקרים האלה:

• העברתם סשן שכבר היה פתוח לרקע עם ← או /background. הסשן הזה ממשיך לערוך קבצים במקום שבו כבר עבד
• הסשן כבר נמצא בתוך git worktree מקושר, בין ש-Claude יצר אותו תחת .claude/worktrees/ ובין שאתם יצרתם אותו עם git worktree add במקום אחר
• הקובץ ש-Claude עורך נמצא בתוך git worktree מקושר, למשל כזה שהסשן או תת-הסוכן שלו יצרו עם git worktree add
• תיקיית העבודה אינה מאגר git ולא מוגדר hook של WorktreeCreate
• הכתיבה היא מחוץ לתיקיית העבודה

כדי לכבות בידוד worktree במאגר שבו git worktrees לא מעשיים, הגדירו worktree.bgIsolation ל-"none". סשני רקע אז עורכים את עותק העבודה ישירות בלי לעבור קודם ל-worktree. הוסיפו את ההגדרה ל-.claude/settings.json של הפרויקט:

{
  "worktree": {
    "bgIsolation": "none"
  }
}

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

כשה-hook נכשל בתיקייה שאינה מאגר git, Claude מדלג על בידוד בתיקייה הזו ועורך את תיקיית העבודה במקום. בתוך מאגר git, סשן ש-Claude מעביר ל-worktree לפני עריכה לא יכול להשתמש בכלים Edit, Write או NotebookEdit על ה-checkout המשותף עד שהמעבר הזה מתרחש.

כדי למצוא את נתיב ה-worktree של סשן, התחברו ובדקו את תיקיית העבודה שלו.

תת-סוכן שסשן הרקע מפעיל יורש את תיקיית העבודה של הסשן. ברגע שהסשן נמצא ב-worktree, עריכות הקבצים של תת-הסוכן נוחתות ב-worktree הזה ולא בעותק העבודה. כדי לתת לתת-סוכן worktree נפרד משלו, הגדירו isolation: worktree ב-frontmatter שלו או העבירו isolation: "worktree" בעת ההפעלה.

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

• Commit and push: Claude מבצע commit בלי לשאול, ודוחף את הענף כשלמאגר יש remote.
• Draft pull request: Claude פותח אחד כשהמשימה דורשת זאת, ותווית #N מופיעה על השורה.
• Never: דחיפה ל-main או ל-master, force-push, ומיזוג.
• Your git instructions take precedence: אם המשימה, CLAUDE.md, או הזיכרון אומרים שאתם מטפלים ב-commit או בדחיפה בעצמכם, Claude משאיר את git לכם.

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

בכל משימה, Claude מסיים את העבודה עם דוח שאומר מה הוא עשה ואיפה העבודה נמצאת: נתיב, ענף, pull request, או התשובה עצמה.

#מה מחיקת סשן מסירה

מחקו סשן עם Ctrl+X פעמיים בתצוגת הסוכנים או עם claude rm. חוץ מהמקרים שנשמרים למטה, הסשן יוצא מהרשימה. התמליל שלו נשאר במחשב דרך claude --resume, וההסרה שורדת הפעלות מחדש של ה-supervisor.

מה קורה ל-worktree ש-Claude יצר עבור הסשן:

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

• claude rm שומר אותו, יחד עם שורת הסשן, כשיש בו שינויים שלא בוצע להם commit.

• לא תצוגת הסוכנים ולא claude rm מסירים worktree שסשן רץ אחר משתמש בו או נעל אותו, ומחיקה חוזרת לא משנה זאת. Claude Code שומר את ה-worktree ואת הסשן, ומציין את התיקייה שנשמרה ואת הסיבה. בתצוגת הסוכנים, שורת הסשן מציגה not deleted. סגרו את הסשן האחר, ואז מחקו שוב.

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

  Commits על remote לא חוסמים את המחיקה. גם commits על העותק המקומי של ענף ברירת המחדל של ה-remote origin לא חוסמים, כל עוד הענף הזה מסומן כ-checked out ב-checkout הראשי, תיקיית המאגר עצמה ולא worktree.

  אחרי הסירוב הזה, בוחרים:

  • כדי לשמור את ה-commits, דחפו אותם, או מזגו אותם לענף ברירת המחדל הזה, ואז מחקו את הסשן שוב.
  • כדי לזרוק אותם, מחקו את הסשן שוב בלי לדחוף: לחצו Ctrl+X פעמיים על השורה שלו בתצוגת הסוכנים, או הריצו את הפקודה claude rm <id> --discard-unpushed שהסירוב הדפיס. זה מסיר את הסשן ואת ה-worktree יחד עם הענף שלו, וזורק את ה-commits שלא נדחפו וכל שינוי שלא בוצע לו commit.

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

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

• worktree ש-git כבר לא מזהה, למשל אחרי git worktree prune, לא חוסם את המחיקה. Claude Code מוחק את הסשן ומשאיר את התיקייה בדיסק.

• כש-git או ה-hook WorktreeRemove נכשלים בהסרת ה-worktree, Claude Code שומר את ה-worktree ואת הסשן, וההודעה מציינת את הסיבה. עבור hook, ההודעה אומרת איך הוא הסתיים, למשל exited 1, ומצטטת את תחילת ה-stderr שלו. ההודעה גם אומרת מה מהבאים לעשות בהמשך:

  • מחקו את הסשן שוב כדי להסיר את התיקייה בכל מקרה, על ידי לחיצה על Ctrl+X פעמיים על השורה שלו בתצוגת הסוכנים או הרצה של הפקודה claude rm <id> --force-remove-worktree <worktree-id> שהסירוב של claude rm הדפיס. הענף של ה-worktree נשאר במאגר.

    Claude Code מציע זאת רק כשהוא יכול לאשר את כל אלה:

    • התיקייה היא אחד מ-worktrees המקושרים של המאגר תחת .claude/worktrees/
    • לא ל-worktree ולא ל-submodule שנמצא ב-checkout יש שינויים שלא בוצע להם commit לקבצים במעקב
    • אף רשומה של סשן אחר לא מציינת אותו

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

  • תקנו את מה שעומד בדרך, למשל ביצוע commit או stash לשינויים שלא בוצע להם commit, הוצאת מאגר git נפרד מה-worktree, סגירת מה שמשתמש בתיקייה, או תיקון ה-hook, ואז מחקו את הסשן שוב.

  • הסירו את התיקייה בעצמכם, ואז מחקו את הסשן שוב.

worktree שיצרתם בעצמכם והתחלתם את הסשן בתוכו נשאר במקום בכל מקרה.

סשן שתיקיית ה-worktree שלו לא שייכת לאף מאגר git, כי המאגר נמחק או כי hook של WorktreeCreate יצר את התיקייה במקום אחר, עדיין אפשר למחוק. כל עוד נשארים קבצים בתיקייה:

• תצוגת הסוכנים מבקשת את אותה לחיצה כפולה על Ctrl+X לפני שזורקים אותם. עבור תיקייה שנוצרה על ידי hook היא מריצה את ה-hook WorktreeRemove במקום, ובלי אחד כזה היא מסרבת למחיקה ושומרת את הסשן.
• claude rm שומר את הסשן ואת ה-worktree, ומציין את הסיבה.

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

#הגדרת המודל, רמת המאמץ, ומצב מהיר

בתצוגת הסוכנים, הקלידו /model, /effort, או /fast בקלט השיגור ולחצו Enter, והסשנים שתשגרו אחר כך יתחילו עם מה שהגדרתם. הבחירה נשארת עם חלון תצוגת הסוכנים הזה ולא נשמרת בקובץ הגדרות. /effort ו-/fast דורשים Claude Code גרסה v2.1.299 ואילך, וכך גם /model שהוקלד בלי כלום אחריו.

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

• Model: /model <name>, למשל /model opus
• Effort level: /effort עם low, medium, high, xhigh, או max, למשל /effort high. כדי להתחיל סשנים ב-ultracode, פתחו את תצוגת הסוכנים מהמעטפת עם claude agents --effort ultracode. קלט השיגור לא מקבל /effort ultracode
• Fast mode: /fast on או /fast off. הסשן מתחיל במצב מהיר רק אם מצב מהיר זמין לכם והמודל שלו תומך במצב מהיר. במודל שלא תומך, הסשן מתחיל עם מצב מהיר כבוי, אז קודם השתמשו ב-/model כדי לבחור אחד מהמודלים שתומכים במצב מהיר. הרמז מתחת לקלט, לא הכותרת, מאשר אם סשנים חדשים מקבלים מצב מהיר.

כדי לבטל בחירה, תנו default כערך, למשל /effort default.

הדוגמה הבאה משגרת סשן אחד על Opus ואת הבא על Sonnet:

/model opus
refactor auth
/model sonnet
run the test suite

כל סשן רקע יכול לרוץ על מודל אחר. כדי לעקוף זאת לסשן אחד:

• מהמעטפת, העבירו --model עם claude --bg.
• התחברו לסשן רץ והריצו /model כדי להחליף. בחירה מהבורר, או /model <name> שהוקלד, נשמרת כברירת המחדל שלכם לסשנים חדשים אלא אם לוחצים s בבורר להחלפה לסשן הזה בלבד. החלפה לסשן בלבד נשמרת אם הסשן מופעל מחדש.
• שגרו תת-סוכן שמגדיר model ב-frontmatter שלו, על ידי התחלת הפרומפט בשם שלו או אזכור @name. כל עוד בחירת /model בקלט השיגור חלה, ה-model של תת-הסוכן לא בשימוש, אז הזינו שם /model default. אם הפעלתם עם claude agents --model, גם שלו לא בשימוש, אז הריצו claude agents במעטפת בלי --model.

#מצב הרשאות, מודל ומאמץ

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

#הגדרות וספק

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

סשן ברקע רץ גם עם ה-PATH של המעטפת שממנה שיגרת אותו, כך שהפקודות שהוא מריץ מוצאות את אותם כלים שהטרמינל שלך מוצא. הוא שומר גם את בחירת ספק הענן של אותה מעטפת, כמו CLAUDE_CODE_USE_BEDROCK או CLAUDE_CODE_USE_VERTEX, יחד עם כינויי ANTHROPIC_DEFAULT_*_MODEL שלה וכל דריסת CLAUDE_CODE_EXTRA_BODY שייצאת שם.

#שער LLM

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

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

• העברת את הסשן שלך לרקע עם ← או /background
• שיגרת סשן אל הספרייה שבה אתה נמצא
• הערת סשן שנעצר בספרייה שבה אתה נמצא על ידי התחברות אליו או מענה לו
• הפעלת מחדש סשן בספרייה שבה אתה נמצא עם claude respawn

Claude Code מעביר שער שנמצא לפני ספק ענן. אם המעטפת שממנה אתה משגר בוחרת את הספק ומייצאת את נקודת הקצה של השער שלו עם דגל עקיפת האימות, Claude Code מעביר את צמד נקודת הקצה והדגל לסשן בתנאים שחלים על ANTHROPIC_BASE_URL, יחד עם ANTHROPIC_CUSTOM_HEADERS. לדוגמה, ייצא CLAUDE_CODE_USE_VERTEX=1 עם ANTHROPIC_VERTEX_BASE_URL ו-CLAUDE_CODE_SKIP_VERTEX_AUTH=1, ו-Claude Code מעביר את נקודת הקצה והדגל האלה.

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

#מצב הרשאות

• הועבר לרקע עם /bg או ←: Claude Code שומר את מצב ההרשאות שבו הסשן היה, כך שמצב שעברת אליו, acceptEdits או auto, נשאר שם אחרי הניתוק
• שוגר מ-claude agents שהופעל במעטפת, או עם claude --bg: הסשן החדש מתחיל כמו שסשן claude חדש באותה ספרייה היה מתחיל, אלא אם שיגרת אותו מתצוגת סוכנים שפתחת עם ברירות מחדל לשיגור. באיזה מצב הרשאות סשן מתחיל מפרט את הסדר

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

1. permissions.defaultMode של ספריית היעד. auto ו-bypassPermissions נכנסים לתוקף רק מהגדרות מנוהלות, מקובץ --settings, או מ-~/.claude/settings.json. Claude Code מסרב ל-defaultMode מ-.claude/settings.json או מ-.claude/settings.local.json של הפרויקט שבוחר מצב מתירני יותר מהמצב שבו היה הסשן שממנו באת.

2. מצב ההרשאות של הסשן שממנו באת.

   אם הסשן הזה היה במצב bypassPermissions, הסשן החדש יכול להתחיל במצב Manual במקום, עם ההודעה Bypass permissions was requested at launch and ignored. זה קורה כשהסכמתך להצהרת הוויתור על העקיפה נמצאת רק ב-.claude/settings.local.json או בקובץ --settings. המשך במצב Manual, או הוסף את ההסכמה הזו ל-~/.claude/settings.json.

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

סדר ההיתר הוא plan, אחר כך Manual ו-dontAsk, אחר כך acceptEdits ו-auto, שכל אחד מהם נחשב מתירני יותר מהאחר, ואחר כך bypassPermissions.

#ברירות מחדל לשיגור

כדי לקבוע ברירות מחדל לכל סשן שאתה משגר מתצוגת הסוכנים, העבר אחד מבין --permission-mode, --model, --effort או --agent בפתיחה:

claude agents --permission-mode plan --model opus --effort high

--effort כאן מקבל את אותם ערכים כמו דגל --effort ברמה העליונה, כולל ultracode.

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

claude agents מקבל גם את --dangerously-skip-permissions כקיצור ל---permission-mode bypassPermissions, ואת --allow-dangerously-skip-permissions כדי להפוך את bypassPermissions לזמין במחזור Shift+Tab של כל סשן ששוגר בלי להתחיל במצב הזה. שניהם תואמים לדגלי ה-CLI ברמה העליונה.

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

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

סשן ברקע שהתחיל במצב bypassPermissions צריך שההסכמה להצהרת הוויתור על העקיפה תהיה רשומה, כי המצב הזה מאפשר לסשן שאינך צופה בו לפעול בלי אישור. העברת --dangerously-skip-permissions או --permission-mode bypassPermissions ל-claude agents מציגה את אותה הצהרה כשלא הסכמת לה קודם, וההסכמה מחילה את bypassPermissions על הסשנים שאתה מפעיל מהתצוגה. העברת --allow-dangerously-skip-permissions מציגה גם היא את אותה הצהרה, וההסכמה הופכת את bypassPermissions לזמין במחזור Shift+Tab של הסשנים האלה בלי להתחיל אותם בו.

#מה נשמר בין הפעלות מחדש

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

אם הסשן לקח את המאמץ מההגדרות שלך ולא מ---effort או /effort, Claude Code קורא את ההגדרות שלך שוב בכל פעם שהוא מפעיל תהליך לסשן. אחרי שתערוך את המאמץ השמור ב-settings.json, השינוי מגיע לסשנים שאתה מעביר לרקע עם ← או /bg, ולהפעלות המחדש המאוחרות שלהם. המאמץ השמור הוא המפתח effortLevel או רשומת modelSettings.

Claude Code שומר גם שם שקבעת עם /rename או Ctrl+R מעבר להפעלה מחדש הזו, כך שעדיין אפשר להריץ claude --resume <name> כדי להגיע לסשן.

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

#הגדרות, תוספים ושרתי MCP

תצוגת הסוכנים מקבלת את אותם דגלי תצורה כמו claude לטעינת הגדרות, תוספים, שרתי MCP וספריות נוספות. תצוגת הסוכנים מחילה את --settings, --setting-sources ו---plugin-dir על עצמה ומעבירה כל דגל תצורה לסשנים שאתה משגר ממנה, כך שתוסף או שרת MCP שטענת כך זמין בסשנים האלה.

חזור על --add-dir, --plugin-dir או --mcp-config פעם אחת לכל ערך. claude agents אינו תומך בצורה המופרדת ברווחים, כמו --add-dir a b c.

אפשר למקם את --settings, --setting-sources ו---plugin-dir לפני או אחרי agents. שמור את --add-dir ואת --mcp-config אחרי agents: אם תמקם אחד מהם לפני agents, claude agents --json נכשל עם שגיאת unknown option.

הדוגמה הבאה פותחת את תצוגת הסוכנים עם דריסת הגדרות וספרייה נוספת אחת:

claude agents --settings ./ci-settings.json --add-dir ../shared-lib

--settings מקבל נתיב קובץ או מחרוזת JSON מוטמעת. נתיב קובץ חייב להצביע על קובץ קיים. Claude Code יוצא עם שגיאת Settings file not found אם הוא אינו מצביע.

#ניהול סשנים מהמעטפת

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

claude attach ו-claude logs יכולים לקבל חלק משם הסשן במקום המזהה, כמו ב-claude logs "auth refactor". claude attach פותח סשן לפי שם רק בזמן שהתהליך שלו רץ, לכן העבר את המזהה כדי להפעיל מחדש סשן שנעצר. העברת שם דורשת Claude Code גרסה v2.1.290 או מאוחרת יותר.

#הצגת סשנים כ-JSON

claude agents --json מדפיס סשנים פעילים כמערך JSON ויוצא: כל סשן חי, ועוד סשני ברקע שעדיין עובדים או חסומים גם כשהתהליך שלהם יצא. הוסף --all כדי לכלול גם סשני ברקע שהושלמו, ו---cwd <path> כדי להגביל את הרשימה לסשנים שהופעלו תחת הספרייה הזו.

כל רשומה מתארת סשן אחד:

#קריאת מצב הסשן מסקריפט

claude agents --json היא הדרך הנתמכת לקרוא מצב סשן מחוץ ל-Claude Code, למשל משורת מצב, ממתזמן, או מסשן Claude אחר שמפקח על עבודה ברקע. דגום את claude agents --json --all, שממשיך לרשום סשנים שהתהליך שלהם יצא, וקרא את state, status ו-waitingFor של כל רשומה.

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

הקבצים תחת ~/.claude/jobs/<id>/ אינם ממשק יציב. ערכים שסשן או תוכנית אחרת כותבים אל state, detail, tempo או needs מוחלפים בעדכון הבא.

אם אתה רוצה שסשן ידווח על התקדמות במילים שלו, תן לו לכתוב קובץ משלו, למשל תחת $CLAUDE_JOB_DIR/tmp, במקום לערוך את state.json.

#איך מתארחים סשנים ברקע

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

כדי לבדוק באיזה סוג סשן אתה נמצא, הרץ את /status. השורה Session kind מציגה background job · attached או background job · unattended בסשן ברקע, לפי אם טרמינל מחובר, ו-interactive בכל סשן אחר.

#תהליך המפקח

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

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

• עובד, מושהה על בקשת הרשאה או על תיבת דו שיח אחרת, או מחובר: התהליך ממשיך לרוץ. תת סוכן, תהליך עבודה או מוניטור שרצים נחשבים לעבודה, וכך גם משימה מתוזמנת בהיקף הסשן שממתינה, למשל התעוררות של /loop.
• הסתיים או ממתין להודעה הבאה שלך, ולא מחובר בערך שעה: המפקח עוצר את התהליך כדי לפנות משאבים. סשן שסיים את התור שלו בשאלה אליך נחשב לממתין להודעה הבאה שלך. השיחה נשארת על הדיסק, ובפעם הבאה שמתחברים או עונים, הסשן ממשיך מהמקום שבו עצר. הצמד סשן עם Ctrl+T כדי שהתהליך שלו ימשיך לרוץ.
• יצא באופן לא צפוי בזמן שהמפקח רץ: המפקח מפעיל את התהליך מחדש. סיום סשן ששלחת לרקע בעצמך עם ← או /background, למשל עם kill, מסמן אותו כעצור במקום להפעיל אותו מחדש. לסשנים שהסתיימו בכיבוי, ראה סשנים מופיעים כנכשלים או כעצורים אחרי כיבוי.
• אחרי עדכון אוטומטי: המפקח מפעיל את עצמו מחדש על הגרסה החדשה ומעביר סשנים במצב המתנה ברקע. סשנים שעובדים, ממתינים לך, או מחוברים לא נקטעים.
• המפקח עצמו נעצר, למשל כי התהליך שלו הסתיים מחוץ ל-Claude Code: ב-macOS וב-Linux הסשנים שלך נעצרים אלא אם מפקח חדש מתחבר בתוך בערך דקה. כדי להפעיל אחד, הרץ claude agents במעטפת. אחרי הדקה הזו, ראה השארת סשנים רצים אחרי שהמפקח נעצר.

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

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

#השארת סשנים רצים אחרי שהמפקח נעצר

אם agent view מדפיס את ההודעה הזו ביציאה, אין מפקח שרץ:

Background sessions still running will stop in about a minute. Run 'claude agents' to keep them.

הרץ claude agents במעטפת בתוך אותה דקה כדי להפעיל מפקח חדש ולהשאיר את הסשנים רצים.

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

#איפה נשמר המצב

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

לכל סשן ברקע מוגדר משתנה הסביבה CLAUDE_JOB_DIR לספריית ~/.claude/jobs/<id> שלו, כך שפקודות מעטפת שהסשן מריץ יכולות לכתוב קבצים זמניים אל $CLAUDE_JOB_DIR/tmp בלי להתנגש עם סשנים מקבילים.

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

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

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

#כיבוי agent view

כדי לכבות סוכני רקע ואת agent view לגמרי, הגדר את ההגדרה disableAgentView בהגדרות ל-true או הגדר את משתנה הסביבה CLAUDE_CODE_DISABLE_AGENT_VIEW. מנהלים יכולים לאכוף זאת דרך הגדרות מנוהלות.

#פתרון בעיות

#claude agents מציג subagents במקום לפתוח את תצוגת הסוכנים

אם claude agents מדפיס ספירה ואחריה את ה-subagents שהגדרת ואז יוצא, תצוגת הסוכנים לא זמינה בסביבה שלך. הרץ claude update כדי להתקין את הגרסה האחרונה.

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

#תצוגת הסוכנים נפתחת בלי סשנים

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

#העברה לרקע מציגה תיבת דו-שיח Background this session?

כשאתה לוחץ ← כדי להעביר סשן לרקע, תיבת דו-שיח Background this session? אומרת שלסשן יש עבודת רקע שנמצאת בעיצומה, והיא תיעצר, תופרע, או תמשיך לרוץ בלי השגחה:

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

הרץ /tasks כדי לראות כל מה שרץ, ואז אשר להעביר לרקע בכל זאת או בחר Stay כדי לתת לעבודה להסתיים קודם. ראה מה עובר כשמעבירים לרקע לגבי אילו סוגי עבודה עוברים ואילו Claude Code עוצר.

#השיחה אומרת שסוכן רקע was carried into this session and not resumed

ההודעה הזו מציינת בשם subagent רקע שאינו רץ בסשן הזה.

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

#הנחיה נדחית כי היא קצרה מדי

שדה הקלט לשיגור מצפה לתיאור משימה, לא לפתיח שיחתי. הנחיה קצרה מארבעה תווים נדחית עם רמז Too short כדי שהקשה מקרית לא תתחיל סשן. תאר מה אתה רוצה שהסשן יעשה, למשל investigate the flaky checkout test.

#סשנים מוצגים כנכשלים או כעצורים אחרי כיבוי

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

• בתוך 48 שעות, הסשן מוצג כנכשל. צרף אותו או השב לו והוא מתחיל מחדש מהשיחה השמורה שלו. כדי לחזור לעבודה שהופסקה, שלח לו תשובה שמבקשת להמשיך.
• אחרי 48 שעות, למשל אחרי שהמחשב היה כבוי ימים, הסשן מוצג כעצור עם ended while the background service was off. לחץ Enter על השורה והכותרת התחתונה מציגה Press enter again to resume this session (it ended while the background service was off), or ctrl+x to delete it. לחץ Enter על אותה שורה שוב כדי לחדש את השיחה השמורה שלו. תשובה, או claude attach <id>, מחדשת אותו בלי הנחיית הכותרת התחתונה הזו.

כשניקוי תמלילים הסיר את השיחה השמורה של סשן עצור, Claude Code מסרב לפתוח את השורה: ההודעה אומרת שאין מה לחדש. claude rm <id> מוחק את השורה, חוץ מהמקרים שנשמרים שתוארו למעלה, ו-claude respawn <id> מריץ שוב את ההנחיה המקורית שלו. ראה השיחה השמורה של הסשן הזה כבר לא על הדיסק.

שינה לבדה לא עוצרת סשנים. הסשנים נשמרים לאורך שינה וה-supervisor מתחבר אליהם מחדש עם ההשכמה.

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

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

• מסוף שבו חידשת את השיחה, למשל עם claude --resume או /resume: השורה מציגה Open in a terminal עם רמז להמשיך שם, ופתיחת השורה מציגה Can't open , this session is running in another terminal. המשך באותו מסוף, או צא ממנו ופתח את השורה שוב.
• תהליך Claude Code לא אינטראקטיבי אחר, למשל תהליך סשן רקע לאותה שיחה שעדיין לא יצא: פתיחת השורה מציגה This conversation is already open in another running Claude session. השתמש בתהליך הזה, או המתן עד שיצא ופתח את השורה שוב.

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

#פתיחת סשן אומרת שאין לו תמליל שמור

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

• claude attach מדפיס This session has no saved transcript.
• תצוגת הסוכנים מציגה Press enter again to restart this session fresh מתחת לרשימה.

לחץ Enter על אותה שורה שוב כדי להפעיל מחדש את הסשן עם שיחה ריקה, או הרץ claude respawn <id> מהמעטפת.

ראה את הפניית השגיאות לפרטים.

#מארח המסוף מת או שהסשן הפסיק להגיב

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

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

#סשן נכשל לפני ההתחלה עם הערה possibly low memory

כשתהליך של סשן רקע יוצא לפני שהוא מסיים להתחיל והמארח דל בזיכרון, הסטטוס של השורה מציין בשם את היציאה ומוסיף possibly low memory , free some up and retry.

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

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

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

אם צירוף, הצצה, או claude logs מדווחים ששירות הרקע לא הגיב, תהליך ה-supervisor כנראה נתקע. עצור אותו ותן ל-claude agents הבא להתחיל אחד חדש. כדי להשאיר את סשני הרקע רצים לאורך ההפעלה מחדש, העבר --keep-workers:

claude daemon stop --any --keep-workers

אחר כך, הרץ claude agents במעטפת שלך כדי להתחיל supervisor חדש. ב-macOS וב-Linux, עשה זאת בתוך כדקה מסיום הישן, או שהסשנים נעצרים בלי supervisor. אם ראית stopped אבל אותה שגיאה חוזרת, ואתה ב-macOS או ב-Linux עם Claude Code ישן מ-v2.1.300, הרץ claude update, ואז את שתי הפקודות שוב.

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

#שיגור נכשל עם Could not resolve authentication method

אם שיגור רקע נכשל עם Could not resolve authentication method בזמן שסשנים אינטראקטיביים מאמתים כרגיל, ה-worker שקיבל את השיגור לא קלט אישורים. סשני רקע מקבלים את האישורים שלהם מה-supervisor, אז השגיאה הזו אומרת שלא היה אישור שמור זמין לתהליך ה-supervisor עצמו. אשר שהרצת /login או שהגדרת מפתח API, ואז עצור את ה-supervisor:

claude daemon stop --any --keep-workers

בתוך כדקה, הרץ claude agents או claude --bg במעטפת שלך כדי להתחיל supervisor חדש שקורא את האישורים השמורים שלך. אם אתה מאמת עם משתנה סביבה כמו ANTHROPIC_API_KEY ולא עם /login, הרץ את הפקודה הבאה הזו ממעטפת שבה המשתנה מוגדר.

ראה את הפניית השגיאות לרשימה המלאה של הסיבות והתיקונים.

#סשן רקע מציג No LLM gateway

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

אתה רואה את ההודעה, למשל, אחרי שאתה משגר לתוך מאגר עם @<repo> או מעיר סשן עצור על ידי הרצת claude attach מתיקייה אחרת. כדי לתת לסשן את ה-gateway שלך, בחר את התיקון שמתאים למקום שבו ה-gateway שלך מוגדר:

• ייצאת את ה-gateway במסוף שלך: במסוף שבו ייצאת את משתני ה-gateway, cd לתיקייה שההודעה מציינת והרץ את פקודת claude respawn <id> של ההודעה.
  • ה-gateway מגיע לסשן רק כשה-supervisor עצמו הופעל ממעטפת שייצאה את אותו gateway. אם ה-supervisor לא הופעל כך, הפעל אותו מחדש מהמסוף שבו הרצת את פקודת ה-respawn, כפי ששיגור נכשל עם Could not resolve authentication method מתאר, ואז הרץ את הפקודה הזו שוב.
• השתמשת בתצוגת הסוכנים בפרויקט שההגדרות שלו קובעות את ה-gateway: שים את ANTHROPIC_BASE_URL ואת האישור שלו בבלוק env של קובץ הגדרות. השתמש ב-~/.claude/settings.json, או ב-.claude/settings.local.json בפרויקט של הסשן עצמו, ושניהם נקראים על ידי סשן אחרי respawn. אחר כך הרץ claude respawn <id> במעטפת שלך מכל תיקייה כדי להפעיל מחדש את הסשן הזה על ה-gateway.

#סשני רקע לא יכולים לקרוא את Desktop, Documents, או Downloads ב-macOS

ב-macOS, מארח סשן הרקע רץ כתהליך משלו ומבקש גישה לתיקיות מוגנות בנפרד מהמסוף שלך. אם סשן רקע מדווח Operation not permitted בקריאה של ~/Desktop, ~/Documents, ~/Downloads, או מיקום מוגן אחר, הענק גישה ב-System Settings תחת Privacy & Security > Files and Folders, או הפעל Full Disk Access עבור הרשומה.

בכל אחת משתי הרשימות, חפש רשומה בשם Claude Code, או אחת ששמה לפי הנתיב או שם הקובץ של הבינארי claude. שם הקובץ הזה יכול להיות מספר גרסה כמו 2.1.316. אם Operation not permitted חוזר אחרי עדכון של Claude Code, חפש רשומה חדשה, למשל אחת ששמה לפי הגרסה החדשה. אם יש רשומה כזו, הענק לה גישה.

#סשני רקע לא יכולים להגיע למארחים ברשת מקומית ב-macOS

ב-macOS 15 ואילך, המערכת חוסמת תהליך מלהגיע למכשירים ברשת המקומית שלך עד שאתה מעניק הרשאת Local Network, כך שפקודה שמכוונת לכתובת LAN יכולה להיכשל עם connect: no route to host בסשן רקע אף על פי שהיא עובדת במסוף בחזית. הפקודה הראשונה בסשן רקע שמתחברת לכתובת ברשת מקומית מפעילה את בקשת ההרשאה Local Network של macOS עבור Claude Code. הענק אותה פעם אחת והפקודות האלה מגיעות למארחי LAN באותו אופן שבו הן מגיעות במסוף בחזית.

#סשן מגיב לאט אחרי צירוף

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

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

#.claude/worktrees/ מתמלא

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

הצג את הרשומות שנשארו עם git worktree list בתיקיית הפרויקט והסר כל אחת עם git worktree remove <path>. ראה ניקוי worktrees.

#מגבלות

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

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

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

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

• הרצת סוכנים במקביל: השווה את תצוגת הסוכנים עם subagents, צוותי סוכנים, ו-worktrees
• העברת הודעות בין סשנים: כך שהסשנים שלך יעבירו ממצאים זה לזה
• צוותי סוכנים: תאם כמה סשנים ששולחים הודעות זה לזה
• השתמש ב-Claude Code בענן: הרץ סשנים בסביבת ענן מנוהלת במקום מקומית
• Projects: תן ל-Claude לתאם סשני ענן מקבילים משיחה אחת ולהגיד לך אילו צריכים אותך

#היסטוריית גרסאות

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