# Git worktree ב-Claude Code: סשנים מקבילים

> כיצד להשתמש ב־--worktree, ב־.worktreeinclude, ב־worktree.baseRef ובבידוד של סוכני משנה. ההבדלים בין worktree לענפים, ניקוי worktrees וטעויות נפוצות.

Source: https://ailoot.ai/blog/he/claude-code-git-worktree/
Canonical: https://ailoot.ai/blog/he/claude-code-git-worktree/
Language: he
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-045
Revision: sha256-b0af579337690d33da49ef08abbd2611aa594b7e8b9daa99fa8418ebd7fae023




[מידע מעשי על עבודה עם Ailoot נמצא בתיעוד](https://ailoot.ai/docs/).

## מהו git worktree ב-Claude Code

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

Git worktree הוא ספריית עבודה נפרדת לענף אחר באותו מאגר. הפקודה `claude --worktree <name>` יוצרת אוטומטית worktree בתוך `.claude/worktrees/<name>/` ומפעילה בו את Claude Code. שני מסופים → שני סשנים → קבצים שונים בדיסק, בלי הפרעות. התכונה זמינה כברירת מחדל ב-Claude Code <bdi>v2.0+</bdi>, וניתן להגדיר אותה באמצעות `.worktreeinclude` עבור סודות ובאמצעות `worktree.baseRef` לבחירת ענף הבסיס.

</div>

הפעלת כמה סוכנים במקביל באותה תיקייה היא נקודת הכאב הבסיסית של vibe-coding בקצב של 2026. סוכני AI כותבים קוד מהר יותר מכפי שאדם יכול לעקוב אחרי מי נוגע במה. בלי בידוד קבצים, הפעלת שני סשנים מקבילים של Claude Code באותה תיקייה מסתיימת בכך שאחד מהם דורס את העבודה של האחר.

Git worktree פותר את הבעיה ברמת מערכת הקבצים. יש לכם תיקייה ראשית אחת שבה אתם עובדים. הפקודה `claude --worktree feature-auth` יוצרת את התיקייה `.claude/worktrees/feature-auth/` בענף נפרד ומפעילה שם את Claude Code. הקבצים מבודדים. שינויים בסשן אחד אינם גלויים לאחר עד שתמזגו אותם במפורש.

כך מתאר זאת התיעוד הרשמי של Anthropic:

<figure>
<blockquote>
<p>הפעלה של כל סשן Claude Code ב-worktree משלו פירושה שעריכות בסשן אחד לעולם אינן משפיעות על קבצים בסשן אחר. אפשר לפתח תכונה במסוף אחד ולתקן באג במסוף אחר.</p>
</blockquote>
<figcaption>— תיעוד Anthropic, https://code.claude.com/docs/en/worktrees</figcaption>
</figure>

רמז לבדיקה עצמית: אם קיבלתם אי פעם commit שחצי מהקבצים בו היו עבודה של מישהו אחר, אתם צריכים worktree.

## במה git worktree שונה מענף רגיל

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

`git checkout` רגיל מחליף את עותק העבודה באותה תיקייה — הקבצים הישנים נעלמים מהדיסק עד שחוזרים לענף. `git worktree add` יוצר **תיקייה שנייה** לענף אחר לצד הראשונה. שני הענפים נמצאים על הדיסק בו-זמנית; עוברים ביניהם באמצעות `cd`. מתחת למכסה המנוע יש מאגר `.git` אחד, עם היסטוריה משותפת ו-remote משותף. רק כמה עותקי עבודה.

</div>

זרימת העבודה הרגילה ב-Git: אתם בענף `main` ומריצים `git checkout feature-x` — Git מחליף את קובצי עותק העבודה. תהליך `npm run dev` שרץ נשבר כי `package.json` השתנה מתחתיו. אתם שומרים את השינויים שטרם בוצע להם commit באמצעות stash ומחכים שה-IDE יוסיף אותם מחדש לאינדקס. אתם חוזרים, הכול נדרס שוב, ולכן צריך שוב stash ו-pop.

Git worktree נותן אפשרות אחרת: במקום להחליף ענף בתיקייה **אחת**, יוצרים **תיקייה שנייה** לענף אחר. הפקודה `git worktree add ../project-feature-x feature-x` יוצרת את הספרייה `../project-feature-x/` עם הקבצים מענף `feature-x`. ענף `main` נשאר בתיקייה המקורית, ושרת הפיתוח ממשיך לפעול.

| פרמטר | ענף `git checkout` | `git worktree add` |
|----|----|----|
| קובצי עותק העבודה | מוחלפים | מופיעים בתיקייה חדשה |
| עבודה במקביל על שני ענפים | לא | כן |
| שינויים שטרם בוצע להם commit | צריך `git stash` | אין צורך לעשות דבר |
| מהירות המעבר | תלויה בגודל ההפרש | פשוט `cd` |
| שטח דיסק | פי 1 | פי N (עותק קבצים אחד לכל ענף) |

בעבר היה צריך להגדיר ידנית מצב worktree ב-Claude Code: `git worktree add`, אחר כך `cd`, ואז `claude` — ולחזור על כך בכל מסוף. הדגל `--worktree` (וגם `-w`) עושה את שלושתם בפקודה אחת.

## הפעלת הסשן המקביל הראשון: הדגל `--worktree`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

הפקודה `claude --worktree feature-auth` יוצרת worktree ב-`.claude/worktrees/feature-auth/`, יוצרת את הענף `worktree-feature-auth` מ-`origin/HEAD` ומפעילה שם את Claude Code. אין צורך ב-`git worktree add` או ב-`cd` ידניים. במסוף הסמוך חזרו על הפקודה עם שם אחר כדי לקבל שני סשנים עצמאיים. אם משמיטים את השם (`claude --worktree`), Claude יוצר שם אקראי כמו `bright-running-fox`.

</div>

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

```bash
claude --worktree feature-auth
```

Claude Code עושה שלושה דברים:

1. יוצר את `.claude/worktrees/feature-auth/` עם תמונת מצב של `origin/HEAD` (בדרך כלל ענף ברירת המחדל שלכם).
2. יוצר ענף חדש בשם `worktree-feature-auth`.
3. מפעיל את הסשן בתיקייה הזאת.

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

```bash
claude --worktree bugfix-123
```

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

אם אינכם רוצים להקליד שם, Claude ימציא אחד:

```bash
claude --worktree
# → creates something like .claude/worktrees/bright-running-fox/
```

טיפ למתחילים ב-Git: הוסיפו את `.claude/worktrees/` ל-`.gitignore`. אחרת, כשמריצים `git status` בתיקייה הראשית, תראו את התוכן של כל ה-worktrees כקבצים לא במעקב:

```
# .gitignore
.claude/worktrees/
```

מכשול שכדאי להימנע ממנו: לפני ההפעלה הראשונה של `--worktree` בתיקייה חדשה, היכנסו אליה באמצעות `claude` רגיל (בלי הדגל) ואשרו את דו-שיח האמון בסביבת העבודה. אחרת, הדגל ייכשל בשגיאה “trust not accepted” — גם אם משלבים אותו עם `-p` למצב ללא ממשק.

## איפה נמצאים worktrees ואיך למצוא אותם

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

כברירת מחדל, כל ה-worktrees נמצאים ב-`.claude/worktrees/<name>/` לצד שורש המאגר. כדי להציג את הרשימה, הריצו `git worktree list`. כדי להיכנס ידנית ל-worktree, השתמשו ב-`cd .claude/worktrees/feature-auth`. כדי לעבור בתוך סשן של Claude, בקשו ממנו “switch to another worktree”; הוא משתמש בכלי EnterWorktree המובנה. ה-worktree הקודם נשאר ללא שינוי בדיסק.

</div>

מיקום ברירת המחדל קבוע: `.claude/worktrees/<value>/` בשורש המאגר. אם הפרויקט נמצא ב-`~/dev/my-app/`, ה-worktree של `feature-auth` יהיה ב-`~/dev/my-app/.claude/worktrees/feature-auth/`.

לפריסות לא סטנדרטיות (למשל, אם רוצים שה-worktree יהיה מחוץ למאגר), יש את ה-hook של `WorktreeCreate` — עוד על כך בהמשך, בסעיף על SVN ו-Mercurial.

במהלך סשן אחד של Claude אפשר לעבור ל-worktree קיים אחר. פשוט כתבו בצ'אט: “switch to `.claude/worktrees/bugfix-123`”, ו-Claude יפעיל את כלי `EnterWorktree`. התיקייה הנוכחית תישאר ללא שינוי — אפשר לחזור אליה באותה דרך.

פקודת Git הרגילה מציגה רשימה של כל ה-worktrees, כולל הראשי ואלה שנוצרו ידנית:

```bash
git worktree list
```

הפלט ייראה כך:

```
/home/user/dev/my-app                  abc1234 [main]
/home/user/dev/my-app/.claude/worktrees/feature-auth  def5678 [worktree-feature-auth]
/home/user/dev/my-app/.claude/worktrees/bugfix-123    9876fed [worktree-bugfix-123]
```

## העתקת `.env` וסודות: הקובץ `.worktreeinclude`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

Worktree הוא checkout נקי מחדש. קבצים מתוך `.gitignore` (`.env`, `.env.local`, תצורות מקומיות) אינם נמצאים בתיקייה החדשה. בלעדיהם, `npm run dev` או `prisma db push` לא יפעלו. הקובץ `.worktreeinclude` בשורש הפרויקט משתמש בתחביר של `.gitignore` ואומר ל-Claude Code אילו קבצים להעתיק אוטומטית לכל worktree חדש. הוא מזוהה עבור `--worktree`, worktrees של סוכני משנה וסשנים באפליקציית שולחן העבודה.

</div>

כש-`--worktree` יוצר תיקייה חדשה, היא מקבלת רק את מה שבוצע לו commit ב-Git. `.env` עם מפתחות API ו-`.env.local` עם תצורה מקומית נמצאים ב-`.gitignore`, ולכן אינם נמצאים ב-worktree. והפקודה הראשונה `npm run dev` נכשלת עם “MISSING DATABASE_URL.”

הפתרון הביתי הוא להעתיק את `.env` ידנית אחרי כל `--worktree`. זה עובד פעם אחת, ואז שוכחים. הפתרון של Anthropic הוא קובץ `.worktreeinclude` בשורש הפרויקט, ובו רשימת קבצים שמתעלמים מהם ב-Git ושיש להעתיק אוטומטית לכל worktree חדש.

צרו קובץ `.worktreeinclude` בשורש המאגר:

```
.env
.env.local
config/secrets.json
```

התחביר זהה לזה של `.gitignore`. אפשר להשתמש בתבניות glob:

```
.env*
*.local
config/*.json
.vscode/settings.json
```

Anthropic מציגה כלל ברור למניעת תאונות:

<figure>
<blockquote>
<p>הקובץ משתמש בתחביר של gitignore. מועתקים רק קבצים שתואמים לתבנית וגם מתעלמים מהם ב-Git. קבצים שבמעקב Git לעולם אינם משוכפלים.</p>
</blockquote>
<figcaption>— תיעוד Anthropic, https://code.claude.com/docs/en/worktrees</figcaption>
</figure>

במילים אחרות, אי אפשר להעתיק בטעות את `package.json` באמצעות `.worktreeinclude` — הוא אינו נמצא ב-`.gitignore`. בטוח להוסיף שם כל תבנית.

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

## יצירת worktree מבקשת pull לצורך סקירת קוד

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

הפקודה `claude --worktree "#1234"` מושכת את בקשת pull ‏\#1234 מ-origin ויוצרת worktree ב-`.claude/worktrees/pr-1234/` עם ענף ה-PR. אפשר להעביר את כתובת ה-URL המלאה — `claude --worktree https://github.com/OWNER/REPO/pull/1234`. שימושי לסקירת קוד: פותחים את ה-PR בתיקייה משלו, ו-Claude יכול להריץ בדיקות, לקרוא יומנים ולכתוב הערה, בעוד המאגר הראשי נשאר ללא שינוי.

</div>

תרחיש רגיל של סקירת קוד: עמית שלח PR; צריך לבדוק את הקוד, להריץ בדיקות ולהשאיר הערה. עם `git checkout pull/1234/head` רגיל, מחליפים שוב את עותק העבודה ושוברים את הסשן הפעיל.

עם הדגל `--worktree`, דרושה לכך פקודה אחת:

```bash
claude --worktree "#1234"
```

מה קורה: Claude Code מריץ `git fetch origin pull/1234/head`, יוצר worktree ב-`.claude/worktrees/pr-1234/` ועובר לענף ה-PR. הסשן מתחיל. אפשר מיד לבקש ממנו “read the diff, run the tests, and find logical errors” — בזמן ש-Claude עובד, הסשן הראשי שלכם בענף `main` ממשיך לפעול.

התחביר החלופי הוא כתובת ה-URL המלאה של בקשת pull:

```bash
claude --worktree https://github.com/OWNER/REPO/pull/1234
```

שימוש בפרויקט אמיתי: שילוב של `claude --worktree "#N"` עם סוכן משנה משלכם לסקירת קוד נותן סקירה אוטומטית תוך דקה או שתיים. הפעילו אותו ברקע, המשיכו לעבוד בחלון הראשי וחזרו לתוצאה באמצעות `claude agents`.

## ענף בסיס: `worktree.baseRef` עבור `fresh` או `head`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

כברירת מחדל, worktree מסתעף מ-`origin/HEAD` — ה-commit העדכני ביותר שסונכרן מה-remote. זוהי התחלה בטוחה ו„נקייה”. אם רוצים שה-worktree יכלול commits מקומיים שעדיין לא נשלחו, הגדירו `worktree.baseRef: "head"` בהגדרות. HEAD מזהה commit; שינויים בקבצים במעקב שטרם בוצע להם commit נשארים בעותק העבודה המקורי ודורשים העברה נפרדת ומפורשת. הדבר שימושי כשסוכן משנה צריך לעבוד על גבי התכונה הנוכחית שלכם בלי לעבור ל-main. הערכים היחידים הנתמכים הם `fresh` או `head`; הפניות שרירותיות אינן נתמכות.

</div>

הגדרת ברירת המחדל היא זו: כל worktree חדש מתחיל מ-`origin/HEAD`. היתרון הוא התחלה נקייה שמובטח שתתאים למה ש-CI יראה. החיסרון הוא שאם יש לכם שינויים שטרם בוצע להם commit או כמה commits מקומיים מעבר ל-remote בענף הנוכחי, הם לא ייכללו ב-worktree החדש.

כדי להתחיל worktree מה-commit הנוכחי של HEAD המקומי, הוסיפו זאת ל-`.claude/settings.json` (או להגדרות הגלובליות):

```json
{
  "worktree": {
    "baseRef": "head"
  }
}
```

כעת `claude --worktree experimental-feature` מתחיל מ-`HEAD` המקומי הנוכחי. הדבר שימושי כשכבר יש לתכונה commits מקומיים שטרם נשלחו. הוא אינו כולל שינויים בקבצים במעקב שטרם בוצע להם commit. אם סוכן המשנה זקוק להם, שמרו והעבירו את השינויים הדרושים במפורש ואז בדקו את ה-diff ביעד; זו פעולה נפרדת מ-`.worktreeinclude`, שמטפל בקבצים מקומיים ש-Git מתעלם מהם.

ההגדרה מקבלת בדיוק שני ערכים: `"fresh"` (= `origin/HEAD`) ו-`"head"` (= HEAD מקומי). הפניות שרירותיות כמו `"feature-branch"` או hash של commit אינן נתמכות — זוהי מגבלה מכוונת שנועדה למנוע פיצוץ קומבינטורי של אפשרויות.

## בידוד סוכני משנה באופן אוטומטי: `isolation: worktree`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

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

</div>

כשאומרים ל-Claude “launch three subagents: one reads the database, the second looks at the API, and the third checks the tests”, שלושתם עובדים כברירת מחדל בעותק העבודה שלכם. אם אפילו שניים מהם כותבים באותו זמן לאותו קובץ, נוצר עימות. הפתרון הוא לתת לכל אחד מהם worktree משלו באופן אוטומטי.

שיטה 1: לבקש במילים. כתבו ל-Claude בשיחה:

```
Use worktrees for your agents.
```

Claude יחיל בידוד על כל סוכני המשנה הבאים בסשן הזה.

שיטה 2: להגדיר זאת במפורש בסוכן המשנה עצמו. בקובץ של סוכן המשנה (למשל, `.claude/agents/code-reviewer.md`), הוסיפו שדה ל-frontmatter:

```yaml
---
name: code-reviewer
description: Reads the diff and writes code review comments
isolation: worktree
---

You're a meticulous reviewer. Read the diff and look for logic errors...
```

כעת כל הפעלה של סוכן המשנה הזה מקבלת worktree זמני ב-`.claude/worktrees/`. אם סוכן המשנה לא כתב דבר, התיקייה נמחקת אוטומטית עם סיום פעולתו. אם יש שינויים שלא בוצע להם commit, Claude ישאל אם להשאיר אותם או להסיר אותם.

ענף הבסיס ל-worktrees של סוכני משנה זהה לזה של `--worktree`: כברירת מחדל `origin/HEAD`; כאשר `worktree.baseRef: head`, ה-`HEAD` המקומי.

## מטריצת החלטה: worktree, ‏`/bg`, סוכן משנה או Agent View

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

ארבעה מנגנונים של Claude Code שנוטים להתבלבל ביניהם. Worktree הוא **בידוד קבצים** (דיסק). `/bg` הוא **סשן ברקע** (הקשר ואסימונים). סוכן משנה הוא **סוכן חד-פעמי ייעודי** (הנחיה וכלים). Agent View הוא **לוח מחוונים לכל הסשנים** (ממשק משתמש). אפשר לשלב ביניהם: `/bg` יוצר worktree אוטומטית, סוכן משנה עם `isolation: worktree` מתחיל ב-worktree זמני, ו-Agent View מציג את שלושתם כשורות ברשימה אחת.

</div>

| כלי | מה הוא מבודד | מתי להשתמש בו |
|----|----|----|
| `claude --worktree <name>` | קבצים (תיקייה וענף נפרדים) | רוצים להפעיל ידנית N סשנים במקביל במסופים שונים |
| `/bg` (או `Ctrl+B`) | הקשר וזמן | משימה ארוכה כשלא רוצים לחסום את החלון הנוכחי. Worktree נוצר מאחורי הקלעים |
| סוכן משנה עם `isolation: worktree` | קבצים בתוך סשן אחד | הנחיה אחת מקצה עבודה ל-N סוכנים, ונדרש למנוע מהם לדרוס זה את זה |
| `claude agents` (Agent View) | דבר — זהו ממשק משתמש | רוצים לראות את כל הסשנים הפעילים / מושהים / שהושלמו בלוח מחוונים אחד |
| `/goal` | ניהול אוטונומיה | רוצים ש-Claude יעבוד עד שתנאי יתקיים, בלי הנחיות מכם בין התורות |

שילובים טיפוסיים:

- **„2 תכונות במקביל, ידנית”** — שני מסופים, בכל אחד `claude --worktree`. המקרה הפשוט ביותר.
- **„הפעל ארגון מחדש למשך הלילה; אסגור את האפליקציה”** — `/bg` + `/goal` עם תנאי להשלמה. הסשן פועל ללא תלות בחלון שלכם.
- **„הנחיה אחת, שלוש חקירות במקביל”** — שלושה סוכני משנה עם `isolation: worktree`. כל אחד בסביבת העבודה המבודדת שלו.
- **„מה פועל עכשיו?”** — `claude agents`. לוח מחוונים של כל הסשנים עם מסנני “running”, “blocked” ו-“done”.

## 5 מכשולים בעבודה עם worktrees

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

הבעיות הנפוצות ביותר: שוכחים את `.worktreeinclude` והסביבה לא פועלת; מבלבלים בין worktree לענף רגיל ומאבדים שינויים שלא בוצע להם commit; משאירים <bdi>5+</bdi> סשנים מקבילים ושוכחים מה נמצא היכן; לא מגדירים `cleanupPeriodDays` ולכן תיקיות נטושות מצטברות; ושוכחים את דו-שיח האמון בתיקייה חדשה, כך ש-`--worktree` נכשל עם שגיאה.

</div>

**1. הפעלתם worktree, חסר `.env`, ושום דבר לא עובד.** זו הבעיה הנפוצה ביותר. Worktree הוא checkout נקי שאין בו קבצים שמתעלמים מהם ב-Git. הפתרון הוא להוסיף קובץ `.worktreeinclude` עם `.env*` ועם תצורות מקומיות נחוצות ברגע שמגדירים מצב worktree. ודאו שהקובץ נמצא בשורש המאגר, ולא בתוך `.claude/`.

**2. רוצים לעבור לענף הראשי, מריצים `cd` לשורש ומאבדים את השינויים שטרם בוצע להם commit ב-worktree.** תיקיית השורש וה-worktree הם שני עותקי עבודה **שונים**. חזרתם באמצעות `cd`; השינויים ב-worktree נשארו במקומם — הם לא נעלמו. אבל אם התבלבלתם והרצתם `git stash` בתיקייה הראשית, מתוך מחשבה שאתם ב-worktree, ה-stash ייווצר בענף הראשי ולא בענף שציפיתם לו.

**3. הפעלתם 5 סשנים במקביל ואינכם זוכרים מה כל אחד עושה.** התיעוד של Anthropic מזהיר במפורש שרוב המפתחים אינם מסוגלים להתמודד קוגניטיבית עם יותר מ-2–3 סשנים. סימן לעומס הוא פתיחת Agent View ואי-יכולת לומר מיד מה כל סוכן עושה. הגבילו את עצמכם לשני סשנים בו-זמנית. אם המשימה דורשת יותר, צריך לתזמר אותה באמצעות `/goal` + סוכני משנה, ולא ידנית.

**4. Worktrees מ-`-p` (ללא ממשק) אינם מתנקים אוטומטית.** הפקודה `claude --worktree feature-x -p "do thing"` אינה מציגה הודעת יציאה אינטראקטיבית, ולכן אין שלב שבו Claude שואל “remove the worktree?” ה-worktrees האלה מצטברים. נקו אותם ידנית: `git worktree remove .claude/worktrees/feature-x`. לחלופין, השתמשו בסקריפט cron שמסיר כל מה שגילו מעל 7 ימים.

**5. דו-שיח אמון בתיקייה חדשה.** אם פותחים לראשונה את המאגר ומיד מריצים `claude --worktree`, הפקודה תיכשל. הריצו `claude` בלי דגלים, אשרו אמון בסביבת העבודה וצאו — ואז `--worktree` יפעל. זאת בכוונה, כדי ש-Claude לא יקבל גישה לפרויקט של מישהו אחר בלי הסכמת המשתמש.

## ניקוי: מה נמחק אוטומטית

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

Worktree שנוצר באמצעות `--worktree` ושאין בו שינויים (אין commits, קבצים לא במעקב או שינויים שלא בוצע להם commit) מוסר אוטומטית ביציאה. כשיש שינויים, Claude ישאל. Worktrees של סוכני משנה ושל `/bg` מוסרים אוטומטית באמצעות הזמן הקצוב `cleanupPeriodDays` בהגדרות, אם הם נקיים. Worktrees מ-`-p` אינם מתנקים כלל — הסירו אותם ידנית באמצעות `git worktree remove`.

</div>

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

<figure>
<blockquote>
<p>אם אין ב-worktree שינויים שלא בוצע להם commit, קבצים לא במעקב או commits חדשים, ה-worktree והענף שלו מוסרים אוטומטית כשאתם יוצאים מהסשן. אם לסשן יש שם, Claude שואל במקום להסיר אותו, כדי שתוכלו לשמור את ה-worktree לשימוש מאוחר יותר.</p>
</blockquote>
<figcaption>— תיעוד Anthropic, https://code.claude.com/docs/en/worktrees</figcaption>
</figure>

תרחיש 1: נכנסתם, לא עשיתם דבר ויצאתם — ה-worktree הוסר.

תרחיש 2: עשיתם עבודה כלשהי ולא ביצעתם לה commit — Claude ישאל “keep or remove?” כשתצאו. “Keep” שומר את התיקייה והענף להמשך. “Remove” מוחק את הספרייה **יחד עם** שינויים שלא בוצע להם commit ועם commits חדשים. פעולה זו הרסנית — אל תלחצו על “remove” מתוך הרגל.

תרחיש 3: הפעלתם עם `-p` (ללא ממשק), והפקודה הסתיימה ויצאה. ה-worktree נשאר. נקו אותו ידנית:

```bash
git worktree remove .claude/worktrees/feature-x
```

בנוסף, worktrees של סוכני משנה ושל סשני `/bg` מוסרים אוטומטית באמצעות ניקוי ברקע אם הם ישנים יותר מ-`cleanupPeriodDays` ימים (הגדרה, בדרך כלל 30 יום כברירת מחדל) **וגם** אין בהם עבודה שלא נשמרה. ניקוי אוטומטי אינו נוגע ב-worktrees מ-`--worktree` — האחריות עליהם שלכם.

## חלופות ל-SVN, ‏Perforce ו-Mercurial: ה-hook של `WorktreeCreate`

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

מצב worktree משתמש ב-`git worktree` כברירת מחדל. עבור SVN, ‏Perforce, ‏Mercurial ומערכות VCS אחרות, אפשר לחבר מנגנון משלכם באמצעות ה-hooks ‏`WorktreeCreate` ו-`WorktreeRemove` בהגדרות של Claude Code. ה-hook מקבל את השם ב-stdin, חייב להדפיס את הנתיב לספרייה שנוצרה ולצאת עם קוד 0. כאשר משתמשים ב-hook משלכם, `.worktreeinclude` אינו מעובד — עליכם להעתיק קבצים מקומיים בעצמכם בתוך ה-hook.

</div>

אם המאגר משתמש ב-Subversion או ב-Mercurial, הדגל `--worktree` לא יפעל ישירות. Anthropic מספקת נקודת הרחבה באמצעות שני hooks: ‏`WorktreeCreate` (יוצר עותק מבודד) ו-`WorktreeRemove` (מסיר אותו).

דוגמה ל-hook של SVN מתוך התיעוד הרשמי:

```json
{
  "hooks": {
    "WorktreeCreate": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "bash -c 'NAME=$(jq -r .name); DIR=\"$HOME/.claude/worktrees/$NAME\"; svn checkout https://svn.example.com/repo/trunk \"$DIR\" >&2 && echo \"$DIR\"'"
          }
        ]
      }
    ]
  }
}
```

ה-hook קורא את שם ה-worktree מה-stdin (`{ "name": "feature-auth" }`), מריץ `svn checkout` לתוך ספרייה שחושבה מראש ומדפיס את הנתיב ל-stdout — Claude Code משתמש בו כספריית העבודה של הסשן החדש.

הסתייגות חשובה: כשמשתמשים ב-hook משלכם, `.worktreeinclude` אינו בשימוש. אם אתם זקוקים ל-`.env` או לקבצים אחרים שמתעלמים מהם ב-Git בתיקייה החדשה, העתיקו אותם בתוך סקריפט ה-hook עצמו.

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

הנקודה המרכזית

Worktree מספק בידוד קבצים. `/bg` מספק בידוד של הקשר ואסימונים. סוכן משנה מספק בידוד של משימות וכלים. `/goal` מספק אוטונומיה עד שתנאי מתקיים. כל אחד פותר בעיה אחת בפני עצמו. יחד הם מאפשרים להמשיך 3–5 משימות מקבילות בלי קריסה קוגניטיבית. בהמשך כדאי לעיין במדריכים הקשורים למצב אוטונומי, לסוכני משנה מותאמים אישית ולתהליכי עבודה דינמיים דרך הקישורים שלמטה.

</div>

Worktree מספק בידוד קבצים. `/bg` מספק בידוד הקשר. סוכני משנה מספקים בידוד משימות. כל מנגנון פותר בעיה אחת בפני עצמו. יחד, הם מספקים דרך לעבוד על שלוש עד חמש משימות במקביל בלי קריסה קוגניטיבית. זהו מכלול המיומנויות שמאחורי vibe-coding מתקדם ב-2026.

הנושא ממשיך באופן טבעי לשלושה נושאים קשורים: [כיצד להגדיר סוכן אוטונומי באמצעות `/goal` ו-Agent View](https://ailoot.ai/blog/he/claude-code-goal-agent-view/), [כיצד לבנות סוכני משנה משלכם למשימות שלכם](https://ailoot.ai/blog/he/claude-code-subagents/), ו-[כיצד להפעיל מאות סוכנים באמצעות Dynamic Workflows](https://ailoot.ai/blog/he/claude-code-dynamic-workflows/).

<div class="section" role="doc-bibliography" aria-label="Sources">

### מקורות

- [הפעלת סשנים מקבילים עם worktrees - תיעוד Claude Code](https://code.claude.com/docs/en/worktrees)
- [יצירת סוכני משנה מותאמים אישית - תיעוד Claude Code](https://code.claude.com/docs/en/sub-agents)
- [יומן שינויים של Claude Code (מאי-יוני 2026)](https://code.claude.com/docs/en/changelog)
- [הפעלת סוכנים במקביל - תיעוד Claude Code](https://code.claude.com/docs/en/agents)
- [Agent View - תיעוד Claude Code](https://code.claude.com/docs/en/agent-view)
- [דף man של git worktree](https://git-scm.com/docs/git-worktree)

</div>





[פתחו את Ailoot](https://ailoot.ai/).

## שאלות ותשובות: Git worktree ב-Claude Code: סשנים מקבילים

### האם baseRef head מעתיק שינויים שטרם בוצע להם commit ל-worktree חדש?

לא. הוא מתחיל מה-commit הנוכחי של HEAD המקומי, כולל commits מקומיים שאינם בשרת המרוחק. שינויים בקבצים במעקב שטרם בוצע להם commit נשארים בעותק המקורי; העבירו במפורש כל עבודה בתהליך שנחוצה ובדקו את ה-worktree החדש.

### למה קובץ .env חסר ב-worktree חדש?

worktree הוא עותק חדש מ-Git, ולכן קבצים מקומיים ש-Git מתעלם מהם אינם נכללים. קובץ .worktreeinclude של Claude Code מפרט קבצים כאלה להעתקה; hook מותאם של WorktreeCreate צריך לטפל בהעתקה בעצמו. כללו רק קבצים שהמשימה באמת דורשת.


## Ailoot · החברה ופורטפוליו הפרויקטים שלה

Ailoot נשענת על ניסיון תפעולי מצטבר, בסיס לקוחות רחב, שירות יציב ובקרה שוטפת של KPI.

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

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