feat: delegate -w to gemini and qwen native worktree support

The Gemini CLI (>=0.45) and Qwen Code (>=0.17) both gained a native
`--worktree` flag that creates and manages an isolated git worktree for
the session, just like claude/grok/droid already do. Detected by updating
the installed CLIs and re-checking their --help.

When `yolo -w gemini` / `yolo -w qwen` is requested, delegate worktree
management to the tool instead of creating a `.yolo/` worktree:

- gemini: appends `--worktree` (auto-generates a name)
- qwen:   appends `--worktree` (worktree under <repoRoot>/.qwen/worktrees/)

The flag is appended bare and last (after the `-i` prompt) so each tool
auto-generates the worktree name without consuming a following token.
As with the other native-delegation agents, yolo's -c/--clean and
-nc/--no-clean flags don't apply (the tool owns the lifecycle), and this
applies to single-agent runs only — multi-agent mode still uses yolo's
own per-agent worktrees for pane/cleanup orchestration.

Updates help text, README, and adds delegation tests for both agents.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Lars Trieloff <lars@trieloff.net>

Author: Grok Build

README.md

@@ -193,6 +193,30 @@ yolo -w -nc claude "keep this work"
    - With `-nc/--no-clean`: Preserves worktree without prompting
    - Without flags: Prompts user whether to clean up
 
+#### Native Worktree Delegation
+
+Some agents create and manage git worktrees themselves. For these, `yolo -w`
+**delegates** to the tool's own worktree support instead of creating a `.yolo/`
+worktree — the tool handles creation, naming, and cleanup, so yolo's
+`-c/--clean` and `-nc/--no-clean` flags don't apply:
+
+| Agent | Native flag | Worktree location |
+|-------|-------------|-------------------|
+| `claude` | `--worktree` | `.claude/worktrees/` |
+| `grok` | `-w` / `--worktree` | managed by grok |
+| `droid` | `-w` / `--worktree` | managed by droid |
+| `gemini` | `--worktree` | managed by gemini |
+| `qwen` | `--worktree` | `<repoRoot>/.qwen/worktrees/` |
+
+```bash
+yolo -w gemini "implement feature"   # gemini manages its own worktree
+yolo -w qwen "refactor the parser"   # qwen creates .qwen/worktrees/<slug>/
+```
+
+> **Note:** In multi-agent mode (comma-separated agents), yolo always creates
+> its own `.yolo/` worktree per agent so it can orchestrate panes and cleanup —
+> native delegation applies to single-agent runs only.
+
 ### Cleanup Mode
 
 Clean up all YOLO worktrees, branches, and processes at once:
@@ -229,9 +253,9 @@ Use `--mop` to clean up orphaned worktrees from interrupted sessions or when you
 | `amp` | `--dangerously-allow-all` |
 | `aider` | `--yes-always` |
 | `cursor-agent` | `--force` |
-| `gemini` | `--yolo` (+ `-i` when prompt present) |
+| `gemini` | `--yolo` (+ `-i` when prompt present; `-w` delegates to gemini's native `--worktree`) |
 | `opencode` | *(no flags)* |
-| `qwen` | `--yolo` (+ `-i` when prompt present) |
+| `qwen` | `--yolo` (+ `-i` when prompt present; `-w` delegates to qwen's native `--worktree`) |
 | `kimi` | `--yolo` (+ `--command` when prompt present) |
 | `crush` | `--yolo` (+ Ghostty injection when prompt present) |
 | `goose` | *(no flags - prompts passed via stdin)* |

executable_yolo

@@ -85,10 +85,11 @@ Usage: yolo [OPTIONS] [command] [args...]
 
 Options:
   -w, --worktree    Create a git worktree in .yolo/ before running command
-                    (exceptions: 'claude', 'grok', and 'droid' delegate to their
-                    built-in worktree support: claude uses .claude/worktrees/,
-                    grok uses its native -w/--worktree mode, droid uses its
-                    native -w/--worktree mode)
+                    (exceptions: 'claude', 'grok', 'droid', 'gemini', and 'qwen'
+                    delegate to their built-in worktree support: claude uses
+                    .claude/worktrees/, grok and droid use their native
+                    -w/--worktree mode, gemini and qwen use their native
+                    --worktree mode (qwen under .qwen/worktrees/))
   -c, --clean       Automatically clean up worktree after command completes
   -nc, --no-clean   Preserve worktree after command completes (no prompt)
   -e, --editor      Launch \$EDITOR to compose prompt (works in all modes)
@@ -106,8 +107,10 @@ Supported Commands:
   droid             No extra flags added (prompt allowed positionally)
   amp               Adds --dangerously-allow-all
   cursor-agent      Adds --force
-  gemini            Uses --yolo; adds -i when prompt present
-  qwen              Uses --yolo; adds -i when prompt present
+  gemini            Uses --yolo; adds -i when prompt present; -w delegates to
+                    gemini's native --worktree
+  qwen              Uses --yolo; adds -i when prompt present; -w delegates to
+                    qwen's native --worktree
   kimi              Uses --yolo (requires Ghostty for interactive prompts)
   opencode          No extra flags added
   crush             Uses --yolo (requires Ghostty for interactive prompts)
@@ -147,23 +150,28 @@ Examples:
   yolo -w -nc claude "keep this"   # Use claude's built-in --worktree (claude manages it)
   yolo -w grok "implement feature" # Use grok's native -w/--worktree (grok manages it)
   yolo -w droid "implement feature" # Use droid's native -w/--worktree (droid manages it)
+  yolo -w gemini "implement feature" # Use gemini's native --worktree (gemini manages it)
+  yolo -w qwen "implement feature" # Use qwen's native --worktree (qwen manages it)
   yolo -e codex,claude,gemini      # Compose prompt in editor, run 3 agents in parallel
   yolo copilot chat                # Run copilot chat with safety flags disabled
   yolo aider "add auth"            # Run aider with auto-approval
   yolo -w aider "implement feature" # Create worktree, run aider with prompt
 
 Worktree Mode:
-  When using -w/--worktree flag (for commands other than claude, grok, or droid):
+  When using -w/--worktree flag (for commands other than claude, grok, droid,
+  gemini, or qwen):
   - Creates .yolo/ directory in repository root
   - Creates branch: <command>-N (where N is the lowest available number)
   - Creates worktree: .yolo/<command>-N
   - Changes to worktree directory before running command
 
-  When using -w/--worktree flag with 'claude', 'grok', or 'droid':
+  When using -w/--worktree flag with 'claude', 'grok', 'droid', 'gemini', or 'qwen':
   - Delegates worktree management to the tool's native support
     - claude: uses --worktree (managed under .claude/worktrees/)
     - grok: uses -w/--worktree (managed by grok's native worktree system)
     - droid: uses -w/--worktree (managed by droid's native worktree system)
+    - gemini: uses --worktree (managed by gemini's native worktree system)
+    - qwen: uses --worktree (managed under <repoRoot>/.qwen/worktrees/)
   - The tool handles worktree creation, naming, and cleanup
   - yolo's -c/--clean and -nc/--no-clean flags are ignored in this mode
 
@@ -1592,11 +1600,12 @@ main() {
     fi
 
     # Track whether yolo is managing the worktree itself
-    # claude, grok, and droid have built-in --worktree / -w support, so we
-    # delegate to them rather than creating our own worktree under .yolo/
+    # claude, grok, droid, gemini, and qwen have built-in --worktree / -w
+    # support, so we delegate to them rather than creating our own worktree
+    # under .yolo/
     local yolo_managed_worktree=false
     if [[ "$use_worktree" == "true" ]]; then
-        if [[ "$command_name" == "claude" || "$command_name" == "grok" || "$command_name" == "droid" ]]; then
+        if [[ "$command_name" == "claude" || "$command_name" == "grok" || "$command_name" == "droid" || "$command_name" == "gemini" || "$command_name" == "qwen" ]]; then
             print_info "Delegating worktree management to $command_name's built-in worktree support"
             # These tools handle their own worktree lifecycle, so yolo's -c/-nc
             # cleanup flags do not apply in this mode.
@@ -1701,6 +1710,16 @@ main() {
                 prompt_joined=$(printf '%s ' "${command_args[@]}"); prompt_joined=${prompt_joined%% }
                 full_command+=("-i" "$prompt_joined")
             fi
+            # gemini and qwen have native git worktree support; delegate to it
+            # when -w is requested rather than creating one with yolo's own logic.
+            #   gemini: --worktree [name]  (worktree under git's worktree dir)
+            #   qwen:   --worktree [slug]  (worktree under <repoRoot>/.qwen/worktrees/)
+            # The flag takes an optional name/slug; appending it bare and last
+            # (after the -i prompt) lets each tool auto-generate the name without
+            # consuming a following token as that name.
+            if [[ "$use_worktree" == "true" ]]; then
+                full_command+=("--worktree")
+            fi
             ;;
         droid)
             # droid has native -w/--worktree support; delegate to it when requested

test.sh

@@ -608,6 +608,104 @@ EOF
     rm -f "$droid_cmd"
 }
 
+# Shared assertions for agents that delegate to a native --worktree and pass
+# their prompt via -i (gemini, qwen). For these, yolo appends --worktree LAST
+# (after the -i prompt) and must not create its own .yolo/ worktree.
+_assert_native_worktree_via_i() {
+    local agent="$1"
+
+    # Create a temporary git repository for testing
+    local test_repo="/tmp/yolo_test_${agent}_$$"
+    mkdir -p "$test_repo"
+    cd "$test_repo"
+
+    # Initialize git repo
+    git init -q
+    git config user.email "test@example.com"
+    git config user.name "Test User"
+    echo "test" > README.md
+    git add README.md
+    git commit -q -m "Initial commit"
+
+    # Create a dummy agent command that echoes args (so we can assert pass-through)
+    local agent_cmd="/tmp/$agent"
+    cat > "$agent_cmd" << 'EOF'
+#!/bin/bash
+echo "Running in: $PWD"
+echo "Args: $@"
+EOF
+    chmod +x "$agent_cmd"
+
+    # Assertion 1: --worktree is passed through when -w is set
+    run_test
+    local output
+    if output=$(PATH="/tmp:$PATH" run_with_timeout "$YOLO_TEST_TIMEOUT" "$YOLO_CMD" -w "$agent" "fix the bug" 2>&1); then
+        if echo "$output" | grep -F -q -- "--worktree"; then
+            print_pass "yolo -w $agent passes through --worktree flag"
+        else
+            print_fail "yolo -w $agent should pass --worktree (got: $output)"
+        fi
+    else
+        print_fail "yolo -w $agent failed to run"
+    fi
+
+    # Assertion 2: --worktree is appended after the -i prompt (bare, last) so the
+    # tool auto-generates the worktree name instead of eating the prompt
+    run_test
+    if echo "$output" | grep -F -q -- "-i fix the bug --worktree"; then
+        print_pass "yolo -w $agent appends --worktree after the -i prompt"
+    else
+        print_fail "yolo -w $agent should append --worktree after -i prompt (got: $output)"
+    fi
+
+    # Assertion 3: yolo did NOT create a .yolo/ directory
+    run_test
+    if [[ ! -d "$test_repo/.yolo" ]]; then
+        print_pass "yolo -w $agent does not create .yolo/ worktree directory"
+    else
+        print_fail "yolo -w $agent should not create .yolo/ directory"
+    fi
+
+    # Assertion 4: yolo did NOT create a git worktree
+    run_test
+    local wt_count
+    wt_count=$(git worktree list | wc -l | tr -d ' ')
+    if [[ "$wt_count" == "1" ]]; then
+        print_pass "yolo -w $agent does not invoke git worktree add"
+    else
+        print_fail "yolo -w $agent should not create a git worktree (found $wt_count)"
+    fi
+
+    # Assertion 5: yolo <agent> (without -w) does NOT pass --worktree
+    run_test
+    if output=$(PATH="/tmp:$PATH" run_with_timeout "$YOLO_TEST_TIMEOUT" "$YOLO_CMD" "$agent" "hello" 2>&1); then
+        if ! echo "$output" | grep -F -q -- "--worktree"; then
+            print_pass "yolo $agent (no -w) does not pass --worktree"
+        else
+            print_fail "yolo $agent should not pass --worktree without -w (got: $output)"
+        fi
+    else
+        print_fail "yolo $agent failed to run"
+    fi
+
+    # Cleanup
+    cd /tmp
+    rm -rf "$test_repo"
+    rm -f "$agent_cmd"
+}
+
+# Test 11: Test yolo -w gemini delegates to gemini's native --worktree
+test_gemini_builtin_worktree() {
+    print_test_header "Test 11: Gemini Built-in Worktree Delegation"
+    _assert_native_worktree_via_i "gemini"
+}
+
+# Test 12: Test yolo -w qwen delegates to qwen's native --worktree
+test_qwen_builtin_worktree() {
+    print_test_header "Test 12: Qwen Built-in Worktree Delegation"
+    _assert_native_worktree_via_i "qwen"
+}
+
 # Print summary
 print_summary() {
     echo ""
@@ -651,6 +749,8 @@ main() {
     test_argument_preservation
     test_claude_builtin_worktree
     test_droid_builtin_worktree
+    test_gemini_builtin_worktree
+    test_qwen_builtin_worktree
 
     print_summary
 }