browser4-cli 4.12.0-rc.2 → 4.12.0

package/README.md

@@ -88,7 +88,7 @@ browser4-cli agent run "Search amazon for mechanical keyboards, compare the top
 
 # Parallel scraping with swarm
 browser4-cli swarm create --max-open-tabs 12 --display-mode HEADLESS
-browser4-cli swarm submit --seed-file ./urls.txt --refresh --store-content
+browser4-cli swarm submit --seed-file ./urls.txt --refresh
 browser4-cli swarm result scrape-task-1
 
 # Batch multiple commands
@@ -247,16 +247,19 @@ browser4-cli pdf --filename page.pdf
 
 | Command | Description |
 |---|---|
-| `tab-list` | List all tabs with their zero-based index. |
+| `tab-list` | List all tabs with their zero-based index and stable GUID. Use `--json` for full GUIDs. |
 | `tab-new [url]` | Open a new tab. |
-| `tab-close [index]` | Close a tab (current tab if no index). |
-| `tab-select <index>` | Switch to a tab by index. |
+| `tab-close [index]` | Close a tab (current tab if no index). Use `--guid <guid>` for GUID-based close. |
+| `tab-select <index>` | Switch to a tab by index. Use `--guid <guid>` for GUID-based select. |
 
 ```bash
 browser4-cli tab-list
+browser4-cli tab-list --json            # JSON output with full GUIDs
 browser4-cli tab-select 1
+browser4-cli tab-select --guid 1B46D74FB  # select by stable GUID
 browser4-cli tab-new https://example.com
 browser4-cli tab-close 1
+browser4-cli tab-close --guid 1B46D74FB  # close by stable GUID
 ```
 
 ### Element inspection
@@ -382,17 +385,21 @@ instructions that always match the installed CLI version.
 | `skills list` | List available bundled skills with file counts. |
 | `skills get <name>` | Output a skill's SKILL.md content. `--full` includes references and templates. `--all` outputs every skill. |
 | `skills path [name]` | Print the skills directory path. With a name, prints the path to that skill's subdirectory. |
+| `skills unpack [dest]` | Unpack bundled skill files to a directory (defaults to the skills directory). |
 
 Skill files are unpacked to the versioned installation directory during `browser4-cli install`.
+Use `skills unpack` to refresh or relocate skill files without reinstalling.
 Set `BROWSER4_SKILLS_DIR` to override the skills directory path.
 
 ```bash
-browser4-cli skills                        # List bundled skills
-browser4-cli skills get browser4-cli       # Get the CLI skill's main content
+browser4-cli skills                         # List bundled skills
+browser4-cli skills get browser4-cli        # Get the CLI skill's main content
 browser4-cli skills get browser4-cli --full # Include references and templates
-browser4-cli skills get --all              # Output every skill
-browser4-cli skills path                   # Print skills root directory
-browser4-cli skills path browser4-cli      # Print path to a specific skill
+browser4-cli skills get --all               # Output every skill
+browser4-cli skills path                    # Print skills root directory
+browser4-cli skills path browser4-cli       # Print path to a specific skill
+browser4-cli skills unpack                  # Unpack to default skills directory
+browser4-cli skills unpack /custom/path     # Unpack to a custom directory
 ```
 
 ### Other
@@ -489,7 +496,7 @@ browser4-cli htmlsnapshot
 browser4-cli htmlsnapshot get <field> [selector] [name]
 browser4-cli htmlsnapshot get all <field> [selector] [name]
 browser4-cli htmlsnapshot query [url] --sql <query>
-browser4-cli htmlsnapshot export [--file <path>]
+browser4-cli htmlsnapshot export [--file <path>] [--clean]
 browser4-cli htmlsnapshot summary
 browser4-cli htmlsnapshot grep [OPTIONS] <pattern>
 browser4-cli htmlsnapshot inspect [selector] [--max N] [--depth D]
@@ -581,10 +588,11 @@ browser4-cli htmlsnapshot query --sql "
 
 #### htmlsnapshot export
 
-Save the full snapshot HTML to a local file.
+Save the full snapshot HTML to a local file. Use `--clean` to strip `<script>`, `<style>`, comments, and non-standard attributes — producing minimal HTML ideal for LLM consumption.
 
 ```bash
 browser4-cli htmlsnapshot export --file snapshot.html
+browser4-cli htmlsnapshot export --file page.html --clean
 ```
 
 #### htmlsnapshot summary
@@ -735,13 +743,12 @@ line; `#` comments and blank lines ignored), or both.
 | `--expires <duration>` | Cache expiration (e.g. `1d`, `1h`) |
 | `--refresh` | Force fresh fetch, ignore cache |
 | `--parse` | Parse page immediately after fetching |
-| `--store-content` | Persist page content to storage |
 
 ```bash
 # Submit URLs from a file
 browser4-cli swarm submit --seed-file ./urls.txt \
   --deadline 2026-03-30T00:00:00Z \
-  --expires 1d --refresh --store-content
+  --expires 1d --refresh
 
 # Submit with inline X-SQL
 browser4-cli swarm submit "https://www.amazon.com/dp/B08PP5MSVB" --sql "
@@ -800,7 +807,6 @@ browser4-cli crawl <url> [options]
 | `-a`, `--args` | — | Additional LoadOptions passthrough (e.g. `-a "-nMaxRetry 5"`) |
 | `--refresh` | — | Force fresh fetch |
 | `--parse` | — | Parse pages immediately after fetching |
-| `--store-content` | — | Persist page content |
 | `--expires` | — | Cache expiration (e.g. `1d`, `1h`, `30m`) |
 | `-p`, `--priority` | — | Queue priority (lower = higher) |
 | `--ignore-url-query` | — | Strip query params during URL normalization |
@@ -821,7 +827,7 @@ browser4-cli crawl "https://shop.example.com" \
   --top-links 10
 
 # Deep crawl with refresh and content storage
-browser4-cli crawl "https://example.com" --depth 3 --refresh --store-content
+browser4-cli crawl "https://example.com" --depth 3 --refresh
 
 # Background crawl — submit and return immediately
 browser4-cli crawl "https://example.com" -ol "a[href]" --background

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser4-cli",
-  "version": "4.12.0-rc.2",
+  "version": "4.12.0",
   "description": "Browser automation CLI for AI agents",
   "type": "module",
   "files": [

package/scripts/install-browser4-cli.ps1

@@ -429,39 +429,101 @@ function New-Symlinks {
     if ($DryRun) {
         Write-Step "[DRY-RUN] Would create link: $linkName -> $BinaryName"
     } else {
-        New-PlatformLink -LinkPath $linkPath -TargetName $BinaryName -DisplayName $linkName
+        $null = New-PlatformLink -LinkPath $linkPath -TargetName $BinaryName -DisplayName $linkName
     }
 
-    # 2) Only if no conflict: b4 -> browser4-cli-<platform>
+    # 2) b4 -> browser4-cli-<platform> (only if b4 is our tool or doesn't exist)
     $shortName = "b4$ext"
     $shortPath = Join-Path $InstallDir $shortName
 
-    # Check if b4 is already on PATH (conflict with another tool)
-    $existingCmd = Get-Command b4 -ErrorAction SilentlyContinue
-    if ($existingCmd) {
-        Write-WarnMsg "Skipping short link '$shortName': 'b4' already found on PATH ($($existingCmd.Source))"
-        return
-    }
+    $b4Exists = $false
+    $b4IsOurs = $false
 
-    # Check if b4 already exists in the install directory
+    # Check in install dir first --anything here is ours
     if (Test-Path $shortPath) {
-        Write-WarnMsg "Skipping short link '$shortName': already exists in $InstallDir"
-        return
+        $b4Exists = $true
+        $b4IsOurs = $true
     }
 
-    # Also check b4.cmd if on Windows (wrapper fallback)
-    if ($script:OSWin) {
+    # Also check b4.cmd wrapper on Windows
+    if ($script:OSWin -and -not $b4Exists) {
         $shortCmdPath = Join-Path $InstallDir "b4.cmd"
         if (Test-Path $shortCmdPath) {
-            Write-WarnMsg "Skipping short link '$shortName': 'b4.cmd' already exists in $InstallDir"
-            return
+            $b4Exists = $true
+            $b4IsOurs = $true
         }
     }
 
+    # Check if b4 is on PATH from somewhere else.
+    # Try Get-Command first; fall back to scanning PATH directories manually
+    # because Get-Command may miss extensionless executables on Linux/macOS
+    # or may cache stale results in some PowerShell versions.
+    if (-not $b4Exists) {
+        $existingCmd = Get-Command b4 -ErrorAction SilentlyContinue
+        if ($existingCmd) {
+            $b4Exists = $true
+            # Check if it's ours by running --version
+            try {
+                $b4Version = & b4 --version 2>&1
+                if ($b4Version -match "browser4-cli") {
+                    $b4IsOurs = $true
+                }
+            } catch {
+                # Can't determine --leave it alone
+            }
+        }
+    }
+
+    # Fallback: scan PATH manually when Get-Command didn't find anything.
+    # On Linux/macOS, PowerShell's Get-Command may miss scripts that are
+    # executable but not in its command cache, especially in CI containers.
+    if (-not $b4Exists) {
+        $separator = [System.IO.Path]::PathSeparator
+        $pathDirs = @($env:Path -split $separator | Where-Object { $_ })
+        foreach ($dir in $pathDirs) {
+            $candidatePath = Join-Path $dir $shortName
+            if (Test-Path $candidatePath -PathType Leaf) {
+                $b4Exists = $true
+                try {
+                    $b4Version = & $candidatePath --version 2>&1
+                    if ($b4Version -match "browser4-cli") {
+                        $b4IsOurs = $true
+                    }
+                } catch {
+                    # Can't determine --leave it alone
+                }
+                break
+            }
+            # On Windows, also check for b4.cmd / b4.bat wrappers
+            if ($script:OSWin) {
+                foreach ($pext in @('.cmd', '.bat')) {
+                    $candidateWin = Join-Path $dir "b4$pext"
+                    if (Test-Path $candidateWin -PathType Leaf) {
+                        $b4Exists = $true
+                        try {
+                            $b4Version = & $candidateWin --version 2>&1
+                            if ($b4Version -match "browser4-cli") {
+                                $b4IsOurs = $true
+                            }
+                        } catch { }
+                        break
+                    }
+                }
+                if ($b4Exists) { break }
+            }
+        }
+    }
+
+    if ($b4Exists -and -not $b4IsOurs) {
+        Write-WarnMsg "Skipping short link '$shortName': 'b4' is not browser4-cli"
+        return
+    }
+
     if ($DryRun) {
-        Write-Step "[DRY-RUN] Would create link: $shortName -> $BinaryName"
+        $action = if ($b4Exists) { "Would update link" } else { "Would create link" }
+        Write-Step "[DRY-RUN] $action`: $shortName -> $BinaryName"
     } else {
-        New-PlatformLink -LinkPath $shortPath -TargetName $BinaryName -DisplayName $shortName
+        $null = New-PlatformLink -LinkPath $shortPath -TargetName $BinaryName -DisplayName $shortName
     }
 }
 

package/scripts/install-browser4-cli.sh

@@ -497,25 +497,48 @@ create_symlinks() {
     ok "Created symlink: ${link_name} -> ${binary_name}"
   fi
 
-  # 2) Only if no conflict: b4 -> browser4-cli-<platform>
+  # 2) b4 -> browser4-cli-<platform> (only if b4 is our tool or doesn't exist)
   local short_name="b4${ext}"
   local short_path="${install_dir}/${short_name}"
 
-  if command -v b4 >/dev/null 2>&1; then
-    warn "Skipping short link '${short_name}': 'b4' already found on PATH"
-    return
-  fi
+  local b4_exists=false
+  local b4_is_ours=false
 
+  # Check in install dir first — anything here is ours
   if [[ -e "$short_path" ]] || [[ -L "$short_path" ]]; then
-    warn "Skipping short link '${short_name}': already exists in ${install_dir}"
+    b4_exists=true
+    b4_is_ours=true
+  fi
+
+  # Check if b4 is on PATH from somewhere else
+  if [[ "$b4_exists" != true ]]; then
+    if command -v b4 >/dev/null 2>&1; then
+      b4_exists=true
+      # Check if it's ours by running --version
+      if b4 --version 2>&1 | grep -qi "browser4-cli"; then
+        b4_is_ours=true
+      fi
+    fi
+  fi
+
+  if [[ "$b4_exists" == true ]] && [[ "$b4_is_ours" != true ]]; then
+    warn "Skipping short link '${short_name}': 'b4' is not browser4-cli"
     return
   fi
 
   if [[ "$DRY_RUN" == true ]]; then
-    step "[DRY-RUN] Would create symlink: ${short_name} -> ${binary_name}"
+    if [[ "$b4_exists" == true ]]; then
+      step "[DRY-RUN] Would update symlink: ${short_name} -> ${binary_name}"
+    else
+      step "[DRY-RUN] Would create symlink: ${short_name} -> ${binary_name}"
+    fi
   else
     ln -sf "$binary_name" "$short_path"
-    ok "Created symlink: ${short_name} -> ${binary_name}"
+    if [[ "$b4_exists" == true ]]; then
+      ok "Updated symlink: ${short_name} -> ${binary_name}"
+    else
+      ok "Created symlink: ${short_name} -> ${binary_name}"
+    fi
   fi
 }
 

package/scripts/tests/install-browser4-cli.tests.ps1

@@ -301,6 +301,157 @@ $sb = [ScriptBlock]::Create($scriptContent)
 
 Write-Host ""
 
+# ── New-Symlinks (b4 link logic) ──
+Write-Host "--- New-Symlinks ---" -ForegroundColor Cyan
+
+& {
+    $Silent = $true
+    $DryRun = $false
+    $SkipLocal = $false
+    $Locate = $false
+    $Source = ""
+    $Version = ""
+    $InstallDir = ""
+    $AddToPath = $true
+
+    . $sb
+
+    $testPlatformKey = if ($script:OSWin) { "win32-x64" } else { "linux-x64" }
+    $testExt = if ($testPlatformKey.StartsWith("win32")) { ".exe" } else { "" }
+    $testBinaryName = "browser4-cli-$testPlatformKey$testExt"
+    $testShortName = "b4$testExt"
+
+    $tempDir = Join-Path ([System.IO.Path]::GetTempPath()) "b4-install-test-$(Get-Random)"
+    New-Item -ItemType Directory -Path $tempDir -Force | Out-Null
+
+    try {
+        # Create the dummy platform binary that New-PlatformLink needs
+        $dummyBinary = Join-Path $tempDir $testBinaryName
+        "dummy" | Out-File $dummyBinary
+
+        $testShortPath = Join-Path $tempDir $testShortName
+        $testCmdPath = Join-Path $tempDir "b4.cmd"
+
+        function Clear-B4Links {
+            if (Test-Path $testShortPath) { Remove-Item $testShortPath -Force -ErrorAction SilentlyContinue }
+            if (Test-Path $testCmdPath) { Remove-Item $testCmdPath -Force -ErrorAction SilentlyContinue }
+        }
+
+        # ── Scenario 1: b4 does not exist → should create ──
+        Clear-B4Links
+
+        New-Symlinks -BinaryName $testBinaryName -InstallDir $tempDir -PlatformKey $testPlatformKey
+
+        Test "New-Symlinks creates b4 when it does not exist" {
+            if (-not ((Test-Path $testShortPath) -or (Test-Path $testCmdPath))) {
+                throw "b4 link was not created (neither symlink nor .cmd wrapper found in $tempDir)"
+            }
+        }
+
+        # ── Scenario 2: b4 exists in install dir → should update ──
+        Clear-B4Links
+
+        # Create initial link
+        New-Symlinks -BinaryName $testBinaryName -InstallDir $tempDir -PlatformKey $testPlatformKey
+
+        $existingPath = if (Test-Path $testShortPath) { $testShortPath }
+                        elseif (Test-Path $testCmdPath) { $testCmdPath }
+                        else { $null }
+
+        if ($existingPath) {
+            $beforeTime = (Get-Item $existingPath).LastWriteTime
+            Start-Sleep -Milliseconds 200
+
+            New-Symlinks -BinaryName $testBinaryName -InstallDir $tempDir -PlatformKey $testPlatformKey
+
+            $afterPath = if (Test-Path $testShortPath) { $testShortPath }
+                         elseif (Test-Path $testCmdPath) { $testCmdPath }
+                         else { $null }
+
+            Test "New-Symlinks updates b4 when it already exists in install dir" {
+                if (-not $afterPath) {
+                    throw "b4 link disappeared after update"
+                }
+                if ((Get-Item $afterPath).LastWriteTime -le $beforeTime) {
+                    throw "b4 link was not updated (timestamp unchanged)"
+                }
+            }
+        } else {
+            Write-Host "  SKIP  New-Symlinks updates b4 (precondition: initial link creation failed)" -ForegroundColor Yellow
+        }
+
+        # ── Scenario 3: foreign b4 on PATH → should NOT create b4 in install dir ──
+        Clear-B4Links
+
+        $foreignDir = Join-Path ([System.IO.Path]::GetTempPath()) "b4-foreign-test-$(Get-Random)"
+        New-Item -ItemType Directory -Path $foreignDir -Force | Out-Null
+        try {
+            # Create fake b4 that is NOT browser4-cli
+            $foreignB4 = Join-Path $foreignDir $testShortName
+            if ($script:OSWin) {
+                # Use .cmd so Get-Command finds it via PATHEXT
+                $foreignCmd = Join-Path $foreignDir "b4.cmd"
+                "@echo off`r`necho NotBrowser4" | Out-File $foreignCmd -Encoding ASCII
+            } else {
+                "#!/bin/sh`necho NotBrowser4" | Out-File $foreignB4 -Encoding ASCII
+                & { chmod +x $foreignB4 2>$null } | Out-Null
+            }
+
+            $oldPath = $env:Path
+            $env:Path = "$foreignDir$([System.IO.Path]::PathSeparator)$oldPath"
+            try {
+                New-Symlinks -BinaryName $testBinaryName -InstallDir $tempDir -PlatformKey $testPlatformKey
+
+                Test "New-Symlinks skips b4 when foreign b4 is on PATH" {
+                    if ((Test-Path $testShortPath) -or (Test-Path $testCmdPath)) {
+                        throw "b4 link was created even though a non-browser4-cli b4 is on PATH"
+                    }
+                }
+            } finally {
+                $env:Path = $oldPath
+            }
+        } finally {
+            Remove-Item $foreignDir -Recurse -Force -ErrorAction SilentlyContinue
+        }
+
+        # ── Scenario 4: b4 on PATH is browser4-cli → should create b4 link ──
+        Clear-B4Links
+
+        $oursDir = Join-Path ([System.IO.Path]::GetTempPath()) "b4-ours-test-$(Get-Random)"
+        New-Item -ItemType Directory -Path $oursDir -Force | Out-Null
+        try {
+            $oursB4 = Join-Path $oursDir $testShortName
+            if ($script:OSWin) {
+                $oursCmd = Join-Path $oursDir "b4.cmd"
+                "@echo off`r`necho browser4-cli v4.12.0" | Out-File $oursCmd -Encoding ASCII
+            } else {
+                "#!/bin/sh`necho browser4-cli v4.12.0" | Out-File $oursB4 -Encoding ASCII
+                & { chmod +x $oursB4 2>$null } | Out-Null
+            }
+
+            $oldPath = $env:Path
+            $env:Path = "$oursDir$([System.IO.Path]::PathSeparator)$oldPath"
+            try {
+                New-Symlinks -BinaryName $testBinaryName -InstallDir $tempDir -PlatformKey $testPlatformKey
+
+                Test "New-Symlinks creates b4 when b4 on PATH is browser4-cli" {
+                    if (-not ((Test-Path $testShortPath) -or (Test-Path $testCmdPath))) {
+                        throw "b4 link was not created even though PATH b4 is browser4-cli"
+                    }
+                }
+            } finally {
+                $env:Path = $oldPath
+            }
+        } finally {
+            Remove-Item $oursDir -Recurse -Force -ErrorAction SilentlyContinue
+        }
+    } finally {
+        Remove-Item $tempDir -Recurse -Force -ErrorAction SilentlyContinue
+    }
+}
+
+Write-Host ""
+
 # ── Summary ──
 Write-Host "============================================" -ForegroundColor Cyan
 $total = $pass + $fail

package/scripts/tests/install-browser4-cli.tests.sh

@@ -303,6 +303,141 @@ test "empty --version with dry-run doesn't download" bash -c "
 
 echo ""
 
+# ── create_symlinks (b4 link logic) ─────────────────────
+
+echo "--- create_symlinks ---" | cyan
+
+# Run symlink tests using the already-sourced FUNC_TEST_SCRIPT.
+SYMLINK_TEST_SCRIPT="$(mktemp)"
+SYMLINK_RESULT="$(mktemp)"
+trap "rm -f '$FUNC_TEST_SCRIPT' '$SYMLINK_TEST_SCRIPT' '$SYMLINK_RESULT'" EXIT
+
+cat > "$SYMLINK_TEST_SCRIPT" << 'SYMLINKEOF'
+src="$1"
+result_file="$2"
+set --       # clear positional params so the sourced install script doesn't parse our args
+source "$src" >/dev/null 2>&1
+
+# Detect platform for test names
+case "$(uname -s)" in
+    MINGW*|MSYS*|CYGWIN*) test_platform="win32-x64"; test_ext=".exe" ;;
+    *)                    test_platform="linux-x64"; test_ext="" ;;
+esac
+test_binary="browser4-cli-${test_platform}${test_ext}"
+test_short="b4${test_ext}"
+
+temp_dir="${TMPDIR:-/tmp}/b4-install-test-$$"
+mkdir -p "$temp_dir"
+cd "$temp_dir" || exit 1
+
+pass=0
+fail=0
+
+do_test() {
+    local name="$1" fn="$2"
+    if bash -c "$fn" 2>/dev/null; then
+        pass=$((pass + 1))
+        printf '\033[0;32m  PASS  %s\033[0m\n' "$name"
+    else
+        fail=$((fail + 1))
+        printf '\033[0;31m  FAIL  %s\033[0m\n' "$name"
+    fi
+}
+
+# Create dummy platform binary (required by create_symlinks)
+echo "dummy" > "$test_binary"
+
+# ── Scenario 1: b4 does not exist → should create ──
+rm -f "$test_short" "b4.cmd" 2>/dev/null || true
+create_symlinks "$test_binary" "$temp_dir" >/dev/null 2>&1
+
+do_test "create_symlinks creates b4 when it does not exist" \
+    "[[ -e '$test_short' || -L '$test_short' || -e '$temp_dir/b4.cmd' ]]"
+
+# ── Scenario 2: b4 exists in install dir → should update ──
+rm -f "$test_short" "$temp_dir/b4.cmd" 2>/dev/null || true
+create_symlinks "$test_binary" "$temp_dir" >/dev/null 2>&1
+
+existing=""
+if [[ -e "$test_short" ]] || [[ -L "$test_short" ]]; then
+    existing="$test_short"
+elif [[ -e "$temp_dir/b4.cmd" ]]; then
+    existing="$temp_dir/b4.cmd"
+fi
+
+if [[ -n "$existing" ]]; then
+    # Remove the link and verify create_symlinks recreates it
+    rm -f "$existing"
+    [[ ! -e "$test_short" ]] && [[ ! -L "$test_short" ]] && [[ ! -e "$temp_dir/b4.cmd" ]] || true
+
+    create_symlinks "$test_binary" "$temp_dir" >/dev/null 2>&1
+
+    after_path=""
+    if [[ -e "$test_short" ]] || [[ -L "$test_short" ]]; then
+        after_path="$test_short"
+    elif [[ -e "$temp_dir/b4.cmd" ]]; then
+        after_path="$temp_dir/b4.cmd"
+    fi
+
+    do_test "create_symlinks updates b4 when it already exists in install dir" \
+        "[[ -n '$after_path' ]]"
+else
+    printf '  SKIP  create_symlinks updates b4 (precondition: initial link creation failed)\n'
+fi
+
+# ── Scenario 3: foreign b4 on PATH → should NOT create b4 ──
+rm -f "$test_short" "$temp_dir/b4.cmd" 2>/dev/null || true
+
+foreign_dir="${TMPDIR:-/tmp}/b4-foreign-$$"
+mkdir -p "$foreign_dir"
+foreign_b4="${foreign_dir}/${test_short}"
+printf '#!/bin/sh\necho NotBrowser4\n' > "$foreign_b4"
+chmod +x "$foreign_b4" 2>/dev/null || true
+
+OLD_PATH="$PATH"
+PATH="${foreign_dir}:${PATH}"
+create_symlinks "$test_binary" "$temp_dir" >/dev/null 2>&1
+PATH="$OLD_PATH"
+
+do_test "create_symlinks skips b4 when foreign b4 is on PATH" \
+    "! [[ -e '$test_short' || -L '$test_short' || -e '$temp_dir/b4.cmd' ]]"
+
+rm -rf "$foreign_dir"
+
+# ── Scenario 4: b4 on PATH is browser4-cli → should create b4 ──
+rm -f "$test_short" "$temp_dir/b4.cmd" 2>/dev/null || true
+
+ours_dir="${TMPDIR:-/tmp}/b4-ours-$$"
+mkdir -p "$ours_dir"
+ours_b4="${ours_dir}/${test_short}"
+printf '#!/bin/sh\necho browser4-cli v4.12.0\n' > "$ours_b4"
+chmod +x "$ours_b4" 2>/dev/null || true
+
+OLD_PATH="$PATH"
+PATH="${ours_dir}:${PATH}"
+create_symlinks "$test_binary" "$temp_dir" >/dev/null 2>&1
+PATH="$OLD_PATH"
+
+do_test "create_symlinks creates b4 when b4 on PATH is browser4-cli" \
+    "[[ -e '$test_short' || -L '$test_short' || -e '$temp_dir/b4.cmd' ]]"
+
+rm -rf "$ours_dir"
+
+# Cleanup temp dir
+rm -rf "$temp_dir"
+
+# Write results to the result file for the parent to parse
+printf '%d\n%d\n' "$pass" "$fail" > "$result_file"
+SYMLINKEOF
+
+bash "$SYMLINK_TEST_SCRIPT" "$FUNC_TEST_SCRIPT" "$SYMLINK_RESULT"
+symlink_pass=$(head -1 "$SYMLINK_RESULT")
+symlink_fail=$(tail -1 "$SYMLINK_RESULT")
+PASS=$((PASS + ${symlink_pass:-0}))
+FAIL=$((FAIL + ${symlink_fail:-0}))
+
+echo ""
+
 # ── Summary ────────────────────────────────────────────
 
 cyan  "============================================"