📘 תיעוד 44

שליחת הודעות לסשנים האחרים שלך ב-Claude Code

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

[!NOTE]

הודעות בין סשנים דורשות Claude Code בגרסה v2.1.224 או חדשה יותר ב-macOS וב-Linux, כולל Linux בתוך WSL 2. ב-Windows מקורי נדרשת Claude Code בגרסה v2.1.234 או חדשה יותר. כשסשן עומד בדרישות, שליחת ההודעות פועלת בלי שצריך להפעיל משהו. ראה זמינות לדרישות הספק ולאופן שבו מאשרים שלסשן יש את היכולת.

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

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

#מתי להשתמש בהודעות בין סשנים

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

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

#הודעה לסשן אחר

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

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

Ask the session running in my other terminal whether the migration finished

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

Explain what we just did to the session working on the payments API

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

Let @api-worker know the schema migration finished

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

• סשן מעבר למחשב הזה: סשן ענן או סשן Remote Control מופיע בהשלמה האוטומטית רק אחרי ש-Claude רשם או שלח הודעה לסשנים שלך מעבר למחשב הזה, לכן בקש מ-Claude לרשום אותם קודם.
• שם עם רווח או תווים אחרים מחוץ לאותיות, ספרות, מקפים וקווים תחתונים: הקלד אותו במרכאות כפולות, למשל @"release notes". כשאתה בוחר את הסשן מההשלמה האוטומטית, Claude Code מכניס את המרכאות עבורך.

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

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

#מסירת הודעה

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

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

Claude Code מסרב להודעה במקרים הבאים:

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

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

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

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

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

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

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

#בקשת התראה

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

Tell me when the migration session finishes what it's working on

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

#מה כל סשן מציג

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

#מגבלות

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

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

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

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

#אילו סשנים Claude יכול להגיע אליהם

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

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

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

• ספריות עבודה: הוא משמיט את ספריית העבודה של כל סשן מקומי.
• שמות סשנים: הוא משמיט כל שם סשן שהוא לא יכול לייחס לאדם, כך ששורה שנשארת בלי שם נקראת (unnamed session).
• השורה הראשונה: הוא משמיט את השורה עם השם של הסשן הזה עצמו, אלא אם הקלדת את השם הזה במסוף הזה, עם --name או עם /rename והשם, מאז שהפעלת את הסשן או חידשת אותו לאחרונה.

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

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

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

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

#הודעות לסשנים במחשבים אחרים

האופן שבו הודעה נוסעת, והאם היא עוברת דרך שרתי Anthropic, תלוי במקום שבו רץ סשן היעד:

התחלת שיחה עם סשן באחד מהמחשבים האחרים שלך דורשת Claude Code בגרסה v2.1.225 או חדשה יותר, ויעד שמופיע ברשימה.

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

• offline: חיבור Remote Control של הסשן הזה נותק. ההודעה עוברת, אבל מגיעה רק אחרי שהמחשב של הסשן הזה מתחבר מחדש.
• can't receive cross-session messages (off in that session): הודעות אינן זמינות בסשן הזה, או שהערך של crossSessionInbound שלו הוא refuse. Claude Code מסרב להודעה לסשן הזה לפני שההודעה יוצאת מהמחשב הזה. התוצאה תחת קריאת SendMessage של Claude מתחילה ב-Not sent ומציינת את הסיבה. אחרי שמתקנים את הסיבה בסשן הזה, רישום מאוחר יותר כבר לא מציג את המצב הזה, ו-Claude יכול לשלוח הודעה לסשן הזה.

סשן בתוך קונטיינר וסשן על המארח לא יכולים להגיע זה אל זה. שני סשנים בתוך אותו קונטיינר עדיין יכולים לשלוח הודעות זה לזה, כולל ברץ self-hosted. גם סשן בתוך WSL 2 וסשן Windows מקורי באותו מחשב לא יכולים להגיע זה אל זה.

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

#תשובות ממחשבים אחרים ומסשני ענן

סשן ענן, כולל סשן על רץ self-hosted, לא יכול להשתמש ב-SendMessage כדי לענות להודעה ממחשב אחר, גם כשההודעה נושאת כתובת תשובה. ההודעה עדיין מגיעה. קרא את התשובה של סשן הענן בתמליל שלו ב-claude.ai/code.

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

#איך סשן מתייחס להודעה נכנסת

כשסשן A שולח הודעה לסשן B, Claude Code אומר לקלוד של B שההודעה הגיעה מסשן אחר, לא ממך, ומגביל מה ההודעה יכולה לעשות:

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

#איך הודעה נראית

כשהודעה מגיעה, Claude Code מציג אותה בשיחה כתצוגה מקדימה מעומעמת בשורה אחת, ושורה התצוגה המקדימה נשארת בשיחה אחר כך. התצוגה המקדימה נושאת את שם השולח ואת השורה הראשונה של ההודעה, חתוכה עם … כשהיא ארוכה, למשל › Message from @api-worker: Schema migration finished (ctrl+o to expand).

כל אחת מאלה מציגה לך את הטקסט המלא:

• לחץ Ctrl+O כדי לפתוח את מציג התמליל ולקרוא את הטקסט המלא תחת שם הסשן של השולח.

  אם קלוד עסוק ועדיין לא קיבל את ההודעה, גלול לסוף התמליל, שם ההודעה מופיעה תחת Waiting to be delivered. דורש Claude Code v2.1.309 או חדש יותר.

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

• בסשן שהתחיל עם --verbose, Claude Code מציג את הטקסט המלא במקום התצוגה המקדימה.

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

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

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

Schema migration finished
The new column is tenant_id, and rebasing on main is safe now.

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

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

מעבר לעריכת קובץ הגדרות, אפשר לבחור את הערך בשורת /config Messages from your other sessions. Claude Code כותב את הערך שבחרת להגדרות המשתמש שלך. השורה דורשת Claude Code v2.1.232 או חדש יותר ולא מופיעה בזמן שהגדרות מנוהלות או הדגל --settings מגדירים את המפתח, כי אז ערך מהגדרות המשתמש לא היה חל. Claude Code דוחה את הקיצור /config crossSessionInbound=value עבור המפתח הזה.

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

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

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

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

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

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

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

#סשנים לא אינטראקטיביים

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

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

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

הגדר את dialogExpiry ל-"never" כדי לשמור הודעות שהוחזקו כברירת מחדל עד שהסשן נגמר. הודעה שהוחזקה על ידי הגדרת hold מפורשת לא פגה. Claude Code מוסר אותה כש-accept חל אחר כך.

כדי לאפשר לעובד -p לקחת הודעות בלי השגחה, התחל אותו עם crossSessionInbound שמוגדר ל-accept בערך --settings שלו. accept בהגדרות המשתמש שלך גם עובד אבל חל על כל סשן שאתה מריץ.

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

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

Claude Code קושר שקע תיבת דואר נכנס לכל סשן שבו העברת הודעות בין סשנים מופעלת, ושם סשנים אחרים במכונה מוסרים הודעות. השקע הוא Unix domain socket ב-macOS וב-Linux, כולל Linux בתוך WSL 2, ו-named pipe ב-Windows מקורי. לאילו סוגי סשנים קושרים אחד, ראה סשנים לא אינטראקטיביים.

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

• /status מציג אותו בשורת Peer address. הנתיב מקבל קידומת uds:.
• Claude Code מייצא אותו ל-hooks ולפקודות Bash כמשתנה הסביבה CLAUDE_CODE_MESSAGING_SOCKET:
  • בסשן שמתחיל עם העברת הודעות מופעלת, Claude Code מייצא את המשתנה לפני שכל hook רץ, כולל SessionStart.

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

ב-macOS וב-Linux, Claude Code גם מסרב ליצור את השקע בספרייה שהוא לא יכול לקבל, למשל ספרייה שמשתמש אחר הוא הבעלים שלה, ומשתמש במקום זאת בספרייה פרטית לכל משתמש, /tmp/cc-socks-<uid>. כשהוא לא יכול לקבל שום ספרייה, הסשן רץ בלי תיבת דואר נכנס: Claude Code מציג הודעה, /status מציג unavailable ואת הסיבה בשורת Peer address שלו, ויומן --debug רושם את הסירוב המלא.

לצד הנתיב של השקע, Claude Code מייצא אסימון לכל סשן בתור CLAUDE_CODE_MESSAGING_TOKEN. סקריפט שמפרסם לשקע של הסשן שלו עצמו יכול לשלוח {"type":"auth","token":"<token>"} כשורה הראשונה של החיבור שלו, כאשר <token> הוא הערך של CLAUDE_CODE_MESSAGING_TOKEN. האם Claude Code דורש את השורה תלוי בפלטפורמה:

• macOS ו-Linux, כולל WSL 2: השורה אופציונלית. Claude Code מקבל חיבור איתה או בלעדיה.
• Windows מקורי: השורה נדרשת. Claude Code סוגר כל חיבור שהשורה הראשונה שלו אינה שורת אימות תקינה ולא מוסר שום דבר מהחיבור הזה.

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

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

• הודעות של ילד עצמי: כשאין ערך crossSessionInbound שחל, Claude Code מוסר הודעה שהוא מאמת שהגיעה מתהליכי הילד של הסשן עצמו, כמו hook או פקודת Bash שמפרסמת בחזרה לשקע של הסשן שלה.
  • ב-Linux, כולל בתוך WSL 2, Claude Code יכול לאמת לפי ראיית תהליך אפילו לילד שכבר יצא. ב-macOS הוא יכול לאמת כך רק כל עוד תהליך הפרסום עדיין רץ, ובמכולה שבה Claude Code רץ כמזהה תהליך 1 אין לו ראיית תהליך בכלל. ב-Windows מקורי גם אין לו.
  • ב-macOS אחרי שתהליך הפרסום יצא ובמכולות שבהן Claude Code רץ כמזהה תהליך 1, ראיית התהליך הזו חסרה, ו-Claude Code במקום זאת מאמת ילד ששלח את CLAUDE_CODE_MESSAGING_TOKEN המיוצא של הסשן בשורת האימות שפתחה את החיבור שלו. ב-Windows מקורי, האסימון הזה הוא הדרך היחידה שבה Claude Code מאמת הודעת ילד עצמי.
  • כש-Claude Code לא יכול לאמת באף אחת מהדרכים, הוא מתייחס להודעה כמו לכל הודעה אחרת שלא טוענת למחלקת הרשאה, ולכן סשן שעוקף בקשות הרשאה מחזיק אותה לאישור שלך.
• סשנים בארגז חול: שלוט אם פקודת Bash יכולה להגיע לשקע מתוך ארגז החול עם הגדרות Unix socket של ארגז החול, sandbox.network.allowAllUnixSockets ו-sandbox.network.allowUnixSockets.

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

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

#דרישת אישור להודעות בין מכונות

הגדר את isolatePeerMachines ל-true כדי לדרוש את האישור המפורש שלך לפני שכל SendMessage מגיע לסשן מעבר למכונה הזו:

{
  "isolatePeerMachines": true
}

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

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

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

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

מנהלים יכולים לכבות את שני הצדדים לארגון בהגדרות מנוהלות, בשילוב כללי ה-deny עם ה-refuse:

{
  "permissions": {
    "deny": ["SendMessage", "ListAgents"]
  },
  "crossSessionInbound": "refuse"
}

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

#זמינות

העברת הודעות בין סשנים דורשת Claude Code v2.1.224 או חדש יותר ב-macOS, Linux ו-WSL 2, ו-v2.1.234 או חדש יותר ב-Windows מקורי. הזמינות, ואילו סשנים קלוד יכול לשלוח אליהם הודעה, תלויות גם במערכת ההפעלה, בספק ובתצורה שלך:

• מערכת הפעלה: זמין ב-macOS, Windows ו-Linux, כולל Linux בתוך WSL 2.

• סשנים במכונה הזו: זמין בכל ספק, כולל Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform ו-Microsoft Foundry, ובסשנים שרצים עם שליפת דגלי תכונה כבויה. אצל הספקים האלה, ועם שליפת דגלים כבויה, העברת הודעות באותה מכונה דורשת Claude Code v2.1.248 או חדש יותר. Claude Code מוסר את ההודעות האלה דרך שקע לכל סשן במכונה שלך, אף פעם לא דרך שרתי Anthropic.

  כדי לעצור סשן מקבלתן, הגדר את crossSessionInbound ל-refuse.

• סשנים מעבר למכונה הזו: קלוד מוצא את סשני הענן שלך ואת הסשנים שלך במכונות אחרות מסשן שמחובר ל-Remote Control, שצריך כניסה ל-claude.ai בתור האימות הפעיל של הסשן הזה ואת דרישות Remote Control האחרות. קלוד לא יכול למצוא את הסשנים האלה עם מפתח API או ב-Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform ו-Microsoft Foundry.

כדי לבדוק סשן, הקלד /list-agents, זמין גם בתור /peers. התוצאה מפרידה סשן שאין לו את התכונה מסשן שבו משהו צר יותר חסם הודעה, כמו כלי SendMessage חסר או שליחה שנדחתה:

• /list-agents לא מזוהה: לסשן אין העברת הודעות בין סשנים. עבור על הדרישות למעלה, החל מ-claude --version לדרישת הגרסה.
• /list-agents עובד אבל שליחה לא הגיעה: העברת ההודעות מופעלת, ומשהו צר יותר חל:
  • כללי Deny: כלל deny להרשאה מסיר את הכלים SendMessage ו-ListAgents.
  • בקרות כניסה: בקרות הכניסה של הסשן המקבל יכולות להחזיק או להשליך את מה שאתה שולח אליו.
  • סשן ענן חסר: סשן ענן מופיע רק כל עוד הסשן הזה מחובר ל-Remote Control.
  • סשן במכונה אחרת חסר: סשן במכונה אחרת שלך מופיע רק כשהוא רץ עם Remote Control וגם הסשן הזה מחובר.
  • סשן במכונה אחרת offline: הודעה לסשן שרשום כ-offline עוברת, אבל מגיעה רק אחרי שהמכונה של הסשן הזה מתחברת מחדש.
  • סשן ענן או מכונה אחרת can't receive cross-session messages: הודעה לסשן שרשום עם התנאי הזה לא עוזבת את המכונה הזו, והתוצאה תחת SendMessage מתחילה ב-Not sent.
  • סשן ענן או מכונה אחרת ישן יותר חסר: Claude Code קורא את רשימות הסשנים האלה מהחדש לראשון ועוצר אחרי מספר עמודים חסום, כך שקלוד לא יכול לשלוח הודעה לסשן שנפל מעבר להם לפי שם.

בסשן עם העברת הודעות, /status גם מציג שורת Peer address עם כתובת תיבת הדואר הנכנס של הסשן עצמו, או unavailable ואת הסיבה כש-Claude Code לא הצליח להגדיר תיבת דואר נכנס.

#מגבלות

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

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

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

• תת-סוכנים וצוותי סוכנים: העברת הודעות בתוך סשן יחיד או צוות
• סוכני רקע: שיגור ומעקב אחר הסשנים המקבילים שאפשר לשלוח אליהם הודעה
• Remote Control: חיבור הסשן הזה כדי להגיע לסשנים שלכם במכונות אחרות
• ערוצים: דחיפת אירועים חיצוניים, כגון תוצאות CI או הודעות צ'אט, לתוך סשן
• הגדרות: crossSessionInbound, isolatePeerMachines ו-dialogExpiry
• מצבי הרשאה: המצבים שמאחורי שתי המחלקות של ברירת המחדל הנכנסת
• הפניה לכלים: השורות של ListAgents ו-SendMessage בטבלת הכלים
• הרצת סוכנים במקביל: השוואה בין הדרכים שבהן Claude Code מריץ כמה סוכנים