tmux וערימות-קונטרול: איך מפסיקים "לצ'וטט" עם Claude ומתחילים להפעיל צי שלם 🚀

מאת: אלון בר-נר, מהנדס-אוטומציה בכיר · RIPA

🪝 רגע לפני שאתה סוגר את הכרטיסייה

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

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

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

בוא נתחיל.

חלק א' · על מה נדבר היום 🗺️

המאמר הזה הוא שיעור-מעשי אחד, לא סקירה-תיאורטית. שלוש התחנות שלנו:

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

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

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

לאורך הדרך נבנה אוצר-מילים מקצועי משותף. כל מונח שנשתמש בו יוסבר במקומו, וגם ירוכז במילון בסוף כדי שתוכל לחזור אליו. עד שנסיים, מילים כמו pane, capture-pane, sub-agent ו-control-stack יהיו שלך.

מוכן? קדימה למנוע. 🔧

חלק ב' · ההסבר המרכזי: לבנות צי, שכבה על שכבה 🏗️

הבעיה: Claude "רגיל" קשור לך לרגל

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

ההבדל שאנחנו הולכים לייצר הוא ההבדל בין לצ'וטט עם Claude אחד לבין להפעיל צי של Claude-ים. נבנה אותו בארבע שכבות.

שכבה 1: החלון העמיד, על גבי tmux 🧱

tmux (ראשי-תיבות של terminal multiplexer, "מרבב-מסופים") הוא תוכנה שמריצה מסופים בתוך שרת שרץ ברקע ולא תלוי בחלון שלך. הרעיון פשוט ורב-עוצמה: הפרוצס לא רץ "בתוך" הטרמינל שלך, אלא בתוך שרת-tmux עצמאי. אתה רק מתחבר (attach) ומתנתק (detach) ממנו כרצונך, והעבודה ממשיכה לרוץ בלעדיך.

נריץ את Claude בתוך pane של tmux, ומאותו רגע:

• סוגר את הדפדפן? Claude ממשיך.
• נופל ה-SSH? Claude ממשיך.
• חוזר מחר בבוקר? מתחבר לסשן, וממשיך בדיוק מאיפה שהיית.

המהלך הבסיסי הזה נקרא Spawn: פתיחת pane מנותק (detached) ועמיד שמריץ את Claude. פקודת-הליבה:

tmux new-session -d -s NAME "bash -c '<launcher>'"

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

שכבה 2: הזרקת-הפרומפט בהשקה 💉

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

claude --remote-control LABEL "$(cat boot.txt)"

שים לב לפרט הקריטי: הפרומפט מגיע מקובץ, דרך "$(cat boot.txt)". פרומפט-אתחול אמיתי מלא במרכאות, גרשיים, שורות-חדשות ותווי-עברית. אם תשרשר אותו inline לתוך שורת-הפקודה, המרכאות יישברו והפרומפט ייחתך או יתעוות בשקט. קובץ פותר את זה לתמיד, ומעביר argv אחד בטוח.

שכבה 3: Remote Control · החלון חוזר לטלפון שלך 📱

כאן הקסם. הדגל --remote-control LABEL רושם את החלון אל ממסר-ה-Remote-Control (בקיצור RC): המנגנון שמצף חלון שרץ על השרת אל אפליקציית-Claude בנייד או בשולחן-העבודה שלך. אתה פותח את הכרטיס בשם ה-LABEL שנתת, ואתה שוב מחובר, מכל מקום בעולם.

יש כאן מלכודת ששווה כסף: Remote Control דורש הזדהות-מנוי (OAuth) של claude.ai, לא מפתח-API. אם המשתנה ANTHROPIC_API_KEY נמצא בסביבה של החלון, Claude יזדהה דרך המפתח, ירוץ מצוין מקומית, אבל לעולם לא יופיע ברשימת ה-RC בטלפון שלך. התרופה: להשיק עם env -u ANTHROPIC_API_KEY שמנקה את המפתח מהסביבה.

וכלל-זהב שני: אמת שהחלון נרשם, אל תניח. הרישום הראשון ל-RC עלול להיכשל בשקט, החלון חי ועובד אבל לא הצטרף לממסר. אחרי ההשקה, קרא את תוכן ה-pane בעזרת capture-pane ודרוש שני סימנים גם-יחד: הסמן /rc וגם סמן-מצב-חי כמו accept edits או esc to interrupt. חסר אחד מהם? הרוג את הסשן והשק מחדש פעם אחת, וזה כמעט תמיד מתחבר.

שכבה 4: ערימת-הקונטרול · מצי-של-אחד לצי-של-רבים 🐝

וכאן אנחנו מגיעים ללב-העניין, לערימת-קונטרול (control-stack). זו כמה חלונות-Claude שרצים בו-זמנית, כל אחד בנתיב-עבודה משלו, מתואמים דרך קבצים ולא זה-דרך-זה. בעולם ה-RIPA אנחנו קוראים לגרסה הזו הכוורת (hive): צי של עובדים-Claude זולים שכל אחד עושה חתיכה.

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

• תיבת-נכנס (inbox, window-<id>-in.md) שהוא קורא.
• תיבת-יוצא (outbox, window-<id>-out.md) שאליה הוא כותב.

מתזמן (dispatcher), שהוא אתה או חלון-מוביל, כותב משימות לתיבות-הנכנס וקורא את התוצאות מתיבות-היוצא. מה זה קונה לך:

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

הצורה המוכחת: סשן-tmux אחד, N חלונות פרושים (tiled), כל אחד מריץ לולאת-עובד (worker-loop). הלולאה משגיחה על שדה ה-status: בתיבת-הנכנס שלה, וכשהוא מתהפך ל-pending, היא מריצה claude -p על המשימה, כותבת את התוצאה לתיבת-היוצא, ומהפכת ל-status: done.

   מתזמן ──כותב──► window-a-in.md ──► [עובד A] ──► window-a-out.md ──┐
                   window-b-in.md ──► [עובד B] ──► window-b-out.md ──┤
                   window-c-in.md ──► [עובד C] ──► window-c-out.md ──┤
                                                                     ▼
                                                    המתזמן קורא את התוצאות

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

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

לנווט ולצפות בחלון חי · הידיים הבלתי-נראות 🖐️

איך שולטים בחלון בלי לשבת מולו? שני מהלכים:

להניע (Drive) בעזרת send-keys:

tmux send-keys -t NAME -l 'סכם את מה שעשית בשלוש נקודות'
tmux send-keys -t NAME Enter

לצפות (Observe) בעזרת capture-pane, שקורא בחזרה את תוכן ה-pane כטקסט, כדי לאמת או לתזמן את הצעד הבא:

tmux capture-pane -t NAME -p

וכלל-ברזל: שלח את הטקסט (עם -l) ואת ה-Enter בנפרד. שרשור של השניים, או השמטת ה--l (literal), גורם לתווים להתפרש כפקודות, נקודה-פסיק תועה יורה מוקדם, והפרומפט נבלע חצי-מוקלד.

חמשת כללי-הברזל · במרוכז 🔩

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

1. לעולם בלי pipe או הפניה על ה-stdout של claude בהשקה. claude ... | tee log הופך את ה-stdout ללא-TTY, וזה מפיל את Claude למצב-הדפסה (print mode): הוא מעבד את האתחול כפרומפט-בודד, עונה פעם-אחת, ויוצא, וגורר איתו את סשן-ה-tmux למוות. רוצה תיעוד? השתמש ב-tmux pipe-pane על ה-pane, לא בצינור על הפרוצס.

2. פרומפט-אתחול מקובץ: "$(cat boot.txt)". שרשור-inline של פרומפט מלא-מרכאות משבש אותו בשקט.

3. Remote Control דורש OAuth-מנוי, לא מפתח-API. נקה את המפתח בהשקה: env -u ANTHROPIC_API_KEY.

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

5. send-keys לטקסט (-l) ול-Enter בנפרד. שרשור, או השמטת -l, שורף הקשות ובולע פרומפטים.

🎁 המתנה: הסקיל ControlStack, מוטמע כאן ועכשיו

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

מה יש בחבילה:

• SKILL.md ש-Claude טוען כדי להכיר את כל השיטה.
• ארבעה מודולים ממוקדים (modules/): ניהול-סשנים, ה-idioms של send-keys ו-capture-pane, רישום Remote Control ואימות /rc, ותבניות ערימת-הקונטרול.
• שבעה סקריפטים רצים (examples/): spawn במסלול-הזהב, אימות-rc, הנעת-חלון, לולאת-עובד, משגר-ערימה, רענון-בשיטת-handoff, ופרומפט-אתחול לדוגמה.

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

Quickstart:

# מהתיקייה examples של החבילה:
chmod +x *.sh

# 1) חלון עמיד ונשלט-מרחוק, פרומפט-אתחול מוזרק בהשקה
./spawn-window.sh myagent "$HOME/project" boot.example.txt
#    → פתח את הכרטיס "myagent" באפליקציית-Claude, ואתה שוב מחובר

# 2) הנע אותו בלי מקלדת
./drive-window.sh myagent 'סכם את המאגר בשלוש נקודות' --wait

# 3) הרץ ערימה של 4 עובדים מתואמים דרך קבצים
./stack-launch.sh 4

דרישות: tmux, ה-CLI של claude מחובר למנוי claude.ai (ה-RC דורש OAuth-מנוי ולא מפתח-API), ו-shell תואם-POSIX.

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

🎁 קחו את זה — ControlStack פתוח וחינמי ב-GitHub
הכלי חי עכשיו כ-plugin מתועד: שכפלו, התאימו, ותרמו בחזרה.
➡️ github.com/yzadok/open-ripa-skills

התקנה בשתי פקודות מתוך Claude Code:

/plugin marketplace add yzadok/open-ripa-skills
/plugin install controlstack@open-ripa-skills

וזהו, מגדל-הפיקוד ברשותכם. 🎛️

חלק ג' · סיכום קצר, עכשיו כשהמונחים כבר שלך 🎓

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

התחלנו מ-Claude שקשור לך לרגל, והרכבנו עליו tmux שהופך כל session לpane עמיד ששורד detach ו-attach. הזרקנו לתוכו פרומפט-אתחול במצב-FLAG, רשמנו אותו לRemote Control ואימתנו את ה-/rc בעזרת capture-pane, ונתנו לו ידיים בלתי-נראות דרך send-keys. ואז עברנו מצי-של-אחד לצי-של-רבים: ערימת-קונטרול, הכוורת, שבה מתזמן מזין משימות לתיבות-נכנס, כל לולאת-עובד רצה על claude -p וכותבת לתיבת-יוצא, והכל מתואם דרך קבצים, בלי התנגשויות ובשקיפות מלאה.

ומעל הכל, חמשת כללי-הברזל: בלי צינור על ה-stdout, פרומפט מקובץ, OAuth ולא מפתח-API, לאמת /rc ולא להניח, ולהפריד send-keys מ-Enter. חמישה כללים, חמישה באגים שכבר לא תשלם עליהם.

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

📚 מילון-מונחים

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

אלון בר-נר | מהנדס-אוטומציה בכיר, RIPA

📬 יצירת-קשר עם אלון בר-נר

מעוניינים לנהוג צי-סוכנים משלכם, או פשוט לשאול שאלה? אלון ישמח לשוחח.

📬 יצירת-קשר עם אלון בר-נר: מעוניינים לנהוג צי-סוכנים משלכם, או פשוט לשאול שאלה? אלון ישמח לשוחח.
✉️ alon@ripa.co.il · 💬 וואטסאפ: 050-640-4909

ריפא מדיה גרופ · ripa.co.il

© 2026 ריפא מדיה גרופ בע"מ · כל הזכויות שמורות