ace-git-worktree 0.22.1 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd11e367c00bf01b67787574f51768d79adee5ca4fbdd2f0e31e2c68f15a56a
-  data.tar.gz: a98a57a36e0f520e19337f97dba830e273d5e9855f06badcf2493301c6218ce7
+  metadata.gz: 440da5b336b58817b1e6bbc1b8d57de396e78848b9e9c289d1492ca85fc7065a
+  data.tar.gz: 432c570346044a2351c72355b729501cef4723507fb64f0298307f7790edf289
 SHA512:
-  metadata.gz: e060226c29bdf088b46b9f83315e321ea52ad9b421766a5da3b369b6ffcbcbcfe8d6fbc5a3637d4e038d749f44c41867cbbc51f8e5b5a6636e9ab942654391ee
-  data.tar.gz: 8f0c1ad4f09380ce2cf8edf2a8944ac2a3267a1fe40e39111239dd5075f562f34c57bd2251f8cfb0520f4b7fc786584fd669d9b6b1522b81cbb4ad4ecbefd32b
+  metadata.gz: c4c1f7d225354653e5d6d4c3ff8e88c0c8b4cee1142707e5d51181569b961b58e81fd1f64bca355a78a6675205429654420ed9776481470204342f70e7bfc9a5
+  data.tar.gz: 46e6f7112657db3d867a69db98dacbe429883672beb37b83fa35bda5b059d071a8a318fe5d26adc90835da05a3b4f74d105b096244be92beb61a904007652358

data/CHANGELOG.md

@@ -7,7 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.24.0] - 2026-09-28
 
+### Added
+- Forge-neutral PR worktree checkout: the exact declared source
+  repository/ref is fetched and its head SHA verified against normalized PR
+  evidence before any worktree is created (fork and canonical sources are
+  equally valid).
+- `--server` / `--default-server` selection for PR creation, task-PR
+  creation, and cleanup; `--remote` remains a local Git remote name only.
+- Task PR creation proves the pushed branch head SHA to the provider
+  (`expected_head`); PR identity is never inferred from branch names.
+- Cleanup report digests now bind the resolved server identity and each
+  item's provider proof (status, PR, proven head, merge commit); `--apply`
+  recomputes the full report immediately before executing and refuses any
+  drift from the approved digest.
+
+### Removed
+- Direct GitHub coupling from worktree correctness paths: `ace/git/github`
+  requires, `Github::PrFetcher` usage, `gh` CLI checks and troubleshooting,
+  the raw gh-based `PrCreator` molecule, and the `ace-git-github` gemspec
+  dependency. Provider execution lives behind the neutral ace-git provider
+  contract.
+
+
+
+### Added
+- Forge-neutral PR worktree checkout: the exact declared source
+  repository/ref is fetched and its head SHA verified against normalized PR
+  evidence before any worktree is created (fork and canonical sources are
+  equally valid).
+- `--server` / `--default-server` selection for PR creation, task-PR
+  creation, and cleanup; `--remote` remains a local Git remote name only.
+- Task PR creation proves the pushed branch head SHA to the provider
+  (`expected_head`); PR identity is never inferred from branch names.
+- Cleanup report digests now bind the resolved server identity and each
+  item's provider proof (status, PR, proven head, merge commit); `--apply`
+  recomputes the full report immediately before executing and refuses any
+  drift from the approved digest.
+
+### Removed
+- Direct GitHub coupling from worktree correctness paths: `ace/git/github`
+  requires, `Github::PrFetcher` usage, `gh` CLI checks and troubleshooting,
+  the raw gh-based `PrCreator` molecule, and the `ace-git-github` gemspec
+  dependency. Provider execution lives behind the neutral ace-git provider
+  contract.
+
+
+
+## [0.23.0] - 2026-09-27
+
+### Changed
+- PR lookups now go through the `ace-git-github` provider (`Ace::Git::Github::PrFetcher`) instead of the `PrMetadataFetcher` molecule removed from the ace-git 0.24 core; provider failures surface as classified `Provider*Error`s instead of the removed `Gh*Error` classes.
+- Raised the `ace-git` dependency floor to `~> 0.24` and added `ace-git-github ~> 0.1.1` (cross-repository PR argument fix). Resolves the require-time `LoadError` (`ace/git/molecules/pr_metadata_fetcher`) that made released 0.22.1 incompatible with ace-git 0.24 and blocked adopting ace-review 0.55.0.
 ## [0.22.1] - 2026-09-02
 
 ### Technical

data/docs/usage.md

@@ -76,12 +76,18 @@ Created task worktree and branch for 081
 
 ### Scenario 2: Review a Pull Request in Its Own Worktree
 
-**Goal:** Create a dedicated workspace for PR review or patching.
+**Goal:** Create a dedicated workspace for PR review or patching, on any
+configured forge (GitHub, default Forgejo, or a named Forgejo).
 
 **Commands:**
 
 ```bash
-ace-git-worktree create --pr 26
+# Preview provenance first (no mutation): source/base repositories, exact head
+ace-git-worktree create --pr 26 --server forgejo-lab --dry-run
+
+# Create the worktree; the declared source ref is fetched and its SHA is
+# verified against the PR evidence before anything is created
+ace-git-worktree create --pr 26 --server forgejo-lab
 ace-git-worktree list
 ```
 
@@ -187,6 +193,8 @@ ace-git-worktree create --task 081 --dry-run
 
 * `--task` - Task ID for a task-aware worktree
 * `--pr`, `--pull-request` - PR number for a PR-aware worktree
+* `--server <name>` - Named configured forge server for PR and task-PR operations
+* `--default-server` - Use the configured default forge server
 * `--from`, `-b` - Create from a specific local or remote branch
 * `--path` - Override the destination worktree path
 * `--source` - Override the git ref used as the start point
@@ -195,7 +203,8 @@ ace-git-worktree create --task 081 --dry-run
 * `--no-commit` - Skip committing task metadata changes
 * `--no-push` - Skip pushing task changes
 * `--no-upstream` - Skip pushing the new branch with upstream tracking
-* `--no-pr` - Skip automatic draft-PR creation when enabled
+* `--no-pr` - Skip automatic draft-PR creation; keeps task creation fully
+  local and provider-free
 * `--push-remote` - Override the remote used for task-related pushes
 * `--no-auto-navigate` - Stay in the current directory after creation
 * `--commit-message` - Use a custom commit message for task metadata updates
@@ -295,6 +304,42 @@ ace-git-worktree prune --cleanup-directories
 * `-v`, `--verbose` - Show verbose output
 * `-d`, `--debug` - Show debug output
 
+### `ace-git-worktree cleanup`
+
+Build a complete, deterministic, report-only cleanup inventory for merged
+worktrees and refs. Local ancestry is the first safe proof; provider PR
+evidence (from the selected forge server) proves candidates whose local
+ancestry is unproven. Unavailable or failed provider proof is never relabeled
+as merged.
+
+```bash
+ace-git-worktree cleanup --target main
+ace-git-worktree cleanup --target main --format json
+ace-git-worktree cleanup --target main --server forgejo-lab
+ace-git-worktree cleanup --target main --offline
+```
+
+**Options:**
+
+* `--target <ref>` - Target ref for ancestry proof (required)
+* `--remote <name>` - Local Git remote name (default: `origin`); never forge selection
+* `--server <name>` - Named configured forge server for PR proof
+* `--default-server` - Use the configured default forge server
+* `--offline` - Skip remote refresh and provider proof
+* `--format <type>` - Output format: `table` (default), `json`
+* `--apply` - Apply a reviewed plan (see below)
+* `--approved-digest <sha256>` - Digest of the reviewed plan; required with `--apply`
+* `--require-only-target` - Fail if the final rescan retains non-target state
+
+**Approval binding:** the report carries a canonical SHA-256 digest over the
+inventory, decisions, the resolved server identity, and each item's provider
+proof (status, PR number, proven head, merge commit). `--apply` recomputes
+the full report immediately before executing and refuses anything whose
+digest differs from the approved one — changed repo state, changed server
+configuration, or changed PR/head proof all invalidate consent. Only
+confirmed merged evidence permits remote-merge cleanup; `--force` does not
+exist and dirty, locked, and in-use worktrees are always retained.
+
 ### `ace-git-worktree bootstrap [IDENTIFIER]`
 
 Rerun preparation phases (toolchain trust and bootstrap policy) for an existing worktree in place.
@@ -399,16 +444,23 @@ data is available.
 
 ### Problem: PR worktree creation fails
 
-**Symptom:** `create --pr` reports a GitHub or authentication error.
+**Symptom:** `create --pr` reports a classified provider error (missing
+provider CLI, unauthenticated, unreachable, or identity mismatch).
 
 **Solution:**
 
-```bash
-gh auth status
-gh auth login
-```
-
-PR-based creation depends on `gh` being installed and authenticated.
+1. Configure the forge server in `git.servers` (see `ace-git` docs) and
+   select it with `--server` / `--default-server`, or make the repository
+   remote resolvable.
+2. Install and authenticate the provider CLI for that server's provider
+   type (`gh` for GitHub, `fj` for Forgejo; check `gh auth status` or
+   `fj auth list`).
+3. Preview with `--dry-run` to inspect the exact source/base provenance
+   before creating anything.
+
+PR creation is forge-neutral: the exact declared source repository/ref is
+fetched and its head SHA is verified against the PR evidence. Failures never
+fall back to another provider.
 
 ### Problem: `switch` returns nothing useful
 

data/lib/ace/git/worktree/commands/cleanup_command.rb

@@ -30,28 +30,16 @@ module Ace
 
             validate_options(options)
 
-            reporter = Molecules::CleanupReporter.new(
-              target: options[:target],
-              remote: options[:remote],
-              offline: options[:offline]
-            )
-
-            result = reporter.report
+            result = build_reporter(options).report
 
             if result[:success]
               if options[:apply]
-                applier = Molecules::CleanupApplier.new(result, options[:approved_digest])
-                apply_result = applier.apply
+                apply_result = apply_fresh_report(options)
 
                 if apply_result[:success]
-                  # Strict rescan
-                  final_reporter = Molecules::CleanupReporter.new(
-                    target: options[:target],
-                    remote: options[:remote],
-                    offline: options[:offline]
-                  )
-                  final_result = final_reporter.report
-                  
+                  # Strict rescan with the same selection
+                  final_result = build_reporter(options).report
+
                   if final_result[:success]
                     # Check require_only_target if needed
                     if options[:require_only_target] && has_non_target_state?(final_result)
@@ -59,7 +47,7 @@ module Ace
                       display_result(final_result, options)
                       return 1
                     end
-                    
+
                     display_apply_result(apply_result, final_result, options)
                     return 0
                   else
@@ -93,6 +81,35 @@ module Ace
             1
           end
 
+          private
+
+          # Build a reporter with the command's server selection; --remote
+          # stays a local Git remote name and is never forge selection.
+          def build_reporter(options)
+            Molecules::CleanupReporter.new(
+              target: options[:target],
+              remote: options[:remote],
+              offline: options[:offline],
+              server_name: options[:server],
+              use_default: options[:default_server] == true,
+              remote_name: options[:remote]
+            )
+          end
+
+          # Recompute the complete report immediately before apply; approval
+          # is bound to the reviewed digest over the exact evidence. Any
+          # drift (repo state, server identity, PR/head proof) invalidates
+          # the approved digest and refuses the apply.
+          def apply_fresh_report(options)
+            fresh = build_reporter(options).report
+            unless fresh[:success]
+              return {success: false, error: "Report recomputation failed before apply: #{fresh[:error]}", ledger: [], partial_failure: false}
+            end
+
+            applier = Molecules::CleanupApplier.new(fresh, options[:approved_digest])
+            applier.apply
+          end
+
           # Show help
           #
           # @return [Integer] Exit code
@@ -103,8 +120,10 @@ module Ace
 
               OPTIONS
                 --target <ref>      Target ref for ancestry proof (required)
-                --remote <name>     Remote name (default: origin)
-                --offline           Skip remote evidence refresh
+                --remote <name>     Local Git remote name (default: origin); never forge selection
+                --server <name>     Named configured forge server for PR proof
+                --default-server    Use the configured default forge server
+                --offline           Skip remote evidence refresh and provider proof
                 --apply             Apply a reviewed plan
                 --approved-digest <sha256>   Approved plan digest to apply
                 --require-only-target        Fail if final rescan has retained non-target state
@@ -128,12 +147,11 @@ module Ace
             0
           end
 
-          private
-
           def parse_arguments(args)
             options = {
               target: nil, remote: "origin", offline: false, format: "table", help: false,
-              apply: false, approved_digest: nil, require_only_target: false
+              apply: false, approved_digest: nil, require_only_target: false,
+              server: nil, default_server: false
             }
             i = 0
             while i < args.length
@@ -146,6 +164,11 @@ module Ace
                 options[:remote] = args[i]
               when "--offline"
                 options[:offline] = true
+              when "--server"
+                i += 1
+                options[:server] = args[i]
+              when "--default-server"
+                options[:default_server] = true
               when "--apply"
                 options[:apply] = true
               when "--approved-digest"
@@ -169,16 +192,17 @@ module Ace
           def validate_options(options)
             raise ArgumentError, "--target is required" unless options[:target]
             raise ArgumentError, "--remote is required" unless options[:remote]
+            raise ArgumentError, "--server and --default-server are mutually exclusive" if options[:server] && options[:default_server]
 
             valid_formats = %w[table json]
             unless valid_formats.include?(options[:format])
               raise ArgumentError, "Invalid format '#{options[:format]}'. Use: #{valid_formats.join(", ")}"
             end
-            
+
             if options[:apply] && !options[:approved_digest]
               raise ArgumentError, "--approved-digest is required when --apply is used"
             end
-            
+
             if options[:approved_digest] && !options[:apply]
               raise ArgumentError, "--apply is required when --approved-digest is used"
             end

data/lib/ace/git/worktree/commands/create_command.rb

@@ -55,9 +55,10 @@ module Ace
             puts
             show_help
             1
-          rescue Ace::Git::PrNotFoundError,
-            Ace::Git::GhAuthenticationError,
-            Ace::Git::GhNotInstalledError,
+          rescue Ace::Git::ProviderObjectNotFoundError,
+            Ace::Git::ProviderAuthenticationError,
+            Ace::Git::ProviderCliMissingError,
+            Ace::Git::ProviderIdentityMismatchError,
             Ace::Git::TimeoutError => e
             puts "Error: #{e.message}"
             1
@@ -86,9 +87,12 @@ module Ace
                                          Task ID formats: 081, task.081, v.0.9.0+081
 
               PR-AWARE CREATION:
-                  --pr <number>           Create worktree for a GitHub pull request
+                  --pr <number>           Create worktree for a pull request
                   --pull-request <number> (alias for --pr)
-                                         Requires gh CLI to be installed and authenticated
+                                         Requires a configured forge server and its
+                                         provider package; fetches the exact declared
+                                         source repository/ref and verifies the head
+                                         SHA against the PR evidence.
 
               BRANCH-AWARE CREATION:
                   -b <branch>             Create worktree from a branch (local or remote)
@@ -100,12 +104,14 @@ module Ace
                   --path <path>           Custom worktree path (default: from config)
                   --source <ref>          Git ref to use as branch start-point (default: current branch)
                                         Examples: main, origin/develop, HEAD~3, commit-sha
+                  --server <name>         Use the named configured forge server (PR mode)
+                  --default-server        Use the configured default forge server
                   --dry-run               Show what would be created without creating
                   --no-status-update      Skip marking task as in-progress (task mode only)
                   --no-commit             Skip committing task changes (task mode only)
                   --no-push               Skip pushing task changes to remote (task mode only)
                   --no-upstream           Skip pushing worktree branch with upstream tracking (task mode only)
-                  --no-pr                 Skip creating draft PR (task mode only)
+                  --no-pr                 Skip creating draft PR; keeps task creation local and provider-free
                   --no-bootstrap          Skip worktree bootstrap preparation
                   --push-remote <name>    Remote to push to (default: origin) (task mode only)
                   --no-auto-navigate      Stay in current directory (default: navigate to worktree)
@@ -120,8 +126,8 @@ module Ace
                   # Create task worktree based on main instead of current branch
                   ace-git-worktree create --task 081 --source main
 
-                  # Create PR worktree
-                  ace-git-worktree create --pr 26
+                  # Create PR worktree on a named forge server (no mutation)
+                  ace-git-worktree create --pr 26 --server forgejo-lab --dry-run
 
                   # Create worktree from remote branch
                   ace-git-worktree create -b origin/feature/auth
@@ -148,9 +154,10 @@ module Ace
                   - hooks.after_create: Commands to run after worktree creation
 
               REQUIREMENTS:
-                  PR-aware creation requires GitHub CLI (gh):
-                  - Install: brew install gh
-                  - Authenticate: gh auth login
+                  PR-aware creation requires a configured forge server
+                  (git.servers) and the provider package for its provider
+                  type. Task and branch creation are fully local and never
+                  touch a forge.
             HELP
             0
           end
@@ -168,6 +175,8 @@ module Ace
               branch: nil,
               path: nil,
               source: nil,
+              server: nil,
+              default_server: false,
               dry_run: false,
               no_status_update: false,
               no_commit: false,
@@ -203,6 +212,11 @@ module Ace
               when "--source"
                 i += 1
                 options[:source] = args[i]
+              when "--server"
+                i += 1
+                options[:server] = args[i]
+              when "--default-server"
+                options[:default_server] = true
               when "--dry-run"
                 options[:dry_run] = true
               when "--no-status-update"
@@ -375,6 +389,8 @@ module Ace
               push_remote: options[:push_remote],
               commit_message: options[:commit_message],
               target_branch: options[:target_branch],
+              server: options[:server],
+              default_server: options[:default_server],
               no_mise_trust: options[:no_mise_trust],
               force: options[:force]
             }.compact
@@ -408,7 +424,7 @@ module Ace
             end
           end
 
-          # Create a PR worktree
+          # Create a PR worktree from normalized provider evidence.
           #
           # @param options [Hash] Command options
           # @return [Integer] Exit code
@@ -432,47 +448,28 @@ module Ace
 
             puts "Creating worktree for PR ##{pr_number}..."
 
-            # Check gh CLI availability using ace-git's PrMetadataFetcher
-            unless Ace::Git::Molecules::PrMetadataFetcher.gh_installed?
-              puts "Error: gh CLI is required for PR worktree creation."
-              puts
-              puts gh_not_available_message
-              return 1
-            end
-
-            unless Ace::Git::Molecules::PrMetadataFetcher.gh_authenticated?
-              puts "Error: gh CLI is not authenticated."
-              puts
-              puts "Authenticate with: gh auth login"
-              return 1
-            end
-
-            # Fetch PR data
-            puts "Fetching PR information..."
             begin
-              result = Ace::Git::Molecules::PrMetadataFetcher.fetch_metadata(pr_number.to_s)
-
-              unless result[:success]
-                puts "Error: #{result[:error]}"
-                return 1
-              end
-
-              metadata = result[:metadata]
-
-              # Convert to pr_data format expected by worktree creator
-              pr_data = pr_data_from_metadata(metadata)
-
-              # Show PR details
-              puts "PR ##{pr_data[:number]}: #{pr_data[:title]}"
-              puts "Branch: #{pr_data[:head_branch]} -> #{pr_data[:base_branch]}"
-
-              # Warn about fork PRs
-              if pr_data[:is_cross_repository]
-                puts
-                puts "Warning: This PR is from a fork (#{pr_data[:head_repository_owner]})."
-                puts "You will not be able to push to the PR branch directly."
+              # Fetch normalized evidence through the selected forge server.
+              puts "Fetching PR information..."
+              resolver = Molecules::PullRequestEvidenceResolver.new(
+                server_name: options[:server],
+                use_default: options[:default_server] == true
+              )
+              resolved = resolver.resolve(pr_number)
+              evidence = resolved[:evidence]
+
+              display_pr_evidence(evidence)
+
+              # Fetch and verify the exact declared source (skipped for dry
+              # runs, which may read evidence but never create anything).
+              checkout = nil
+              unless options[:dry_run]
+                checkout = Molecules::PullRequestCheckoutPreparer.new.prepare(evidence)
+                unless checkout[:success]
+                  puts "Error: #{checkout[:error]}"
+                  return 1
+                end
               end
-              puts
 
               # Prepare creation options
               creation_options = {
@@ -483,7 +480,7 @@ module Ace
               }.compact
 
               # Create the worktree
-              result = @manager.create_pr(pr_number, pr_data, creation_options)
+              result = @manager.create_pr(evidence, checkout, creation_options)
 
               if result[:success]
                 display_pr_creation_result(result, options[:dry_run])
@@ -493,14 +490,30 @@ module Ace
                 display_warnings(result[:warnings]) if result[:warnings]
                 1
               end
-            rescue Ace::Git::PrNotFoundError, Ace::Git::GhAuthenticationError,
-              Ace::Git::GhNotInstalledError => e
-              # Let specific ace-git errors be handled by handle_pr_fetch_error
-              # Other errors will bubble up to the top-level rescue in run()
-              handle_pr_fetch_error(e, pr_number)
+            rescue Ace::Git::Error => e
+              puts "Error: #{e.message}"
+              puts "Debug: #{e.class}" if ENV["DEBUG"]
+              1
             end
           end
 
+          # Display normalized PR evidence before checkout.
+          #
+          # @param evidence [Ace::Git::ProviderPullRequest] normalized evidence
+          def display_pr_evidence(evidence)
+            puts "PR ##{evidence.number}: #{evidence.title}"
+            puts "Branch: #{evidence.head_ref} -> #{evidence.base_ref}"
+            puts "Source: #{evidence.head_repository_url}@#{evidence.head_ref}" \
+              " (head #{evidence.head_sha.to_s[0, 8] || "unknown"})"
+            puts "Server: #{evidence.server_name}"
+
+            return unless evidence.head_repository_url != evidence.base_repository_url
+
+            puts
+            puts "Warning: This PR is from a fork (#{evidence.head_repository_url})."
+            puts "You will not be able to push to the PR branch directly."
+          end
+
           # Create a branch worktree
           #
           # @param options [Hash] Command options
@@ -863,104 +876,6 @@ module Ace
             system("which ace-tmux > /dev/null 2>&1")
           end
 
-          # Convert PR metadata from gh CLI to internal pr_data format
-          #
-          # Anti-corruption layer that translates gh CLI JSON output to internal format.
-          # This isolates worktree creation from gh CLI output structure changes.
-          #
-          # Expected metadata schema from ace-git PrMetadataFetcher (via gh pr view --json):
-          #   {
-          #     "number" => Integer,
-          #     "title" => String,
-          #     "headRefName" => String (PR source branch),
-          #     "baseRefName" => String (PR target branch),
-          #     "isCrossRepository" => Boolean (true for fork PRs),
-          #     "headRepositoryOwner" => { "login" => String } (fork owner info)
-          #   }
-          #
-          # @param metadata [Hash] PR metadata from gh CLI
-          # @return [Hash] pr_data format expected by worktree creator
-          def pr_data_from_metadata(metadata)
-            {
-              number: metadata["number"],
-              title: metadata["title"],
-              head_branch: metadata["headRefName"],
-              base_branch: metadata["baseRefName"],
-              is_cross_repository: metadata["isCrossRepository"] || false,
-              head_repository_owner: metadata.dig("headRepositoryOwner", "login") || "unknown"
-            }
-          end
-
-          # Handle errors during PR metadata fetch
-          #
-          # @param error [Exception] The error that occurred
-          # @param pr_number [Integer] PR number for context in error messages
-          # @return [Integer] Exit code (always 1 for errors)
-          def handle_pr_fetch_error(error, pr_number)
-            case error
-            when Ace::Git::PrNotFoundError
-              handle_pr_not_found(error, pr_number)
-            when Ace::Git::GhAuthenticationError
-              handle_gh_auth_error(error)
-            when Ace::Git::GhNotInstalledError
-              handle_gh_not_installed(error)
-            else
-              handle_unknown_error(error)
-            end
-            1
-          end
-
-          # Handle PR not found error with helpful suggestions
-          def handle_pr_not_found(error, pr_number)
-            puts "Error: #{error.message}"
-            puts
-            puts "Suggestions:"
-            puts "  1. Verify the PR number is correct"
-            puts "  2. Check if the PR exists: gh pr view #{pr_number}"
-            puts "  3. Ensure you're in the correct repository"
-          end
-
-          # Handle GitHub authentication error with troubleshooting steps
-          def handle_gh_auth_error(error)
-            puts "Error: #{error.message}"
-            puts
-            puts "Troubleshooting:"
-            puts "  1. Verify GitHub authentication: gh auth status"
-            puts "  2. Re-authenticate if needed: gh auth login"
-            puts "  3. Check repository access permissions"
-          end
-
-          # Handle gh CLI not installed error with installation guidance
-          def handle_gh_not_installed(error)
-            puts "Error: #{error.message}"
-            puts
-            puts gh_not_available_message
-          end
-
-          # Handle unknown/unexpected errors with debug info
-          def handle_unknown_error(error)
-            puts "Error: #{error.message}"
-            if ENV["DEBUG"]
-              puts "Debug: #{error.class}"
-              puts "Debug: #{error.backtrace&.first}" if error.backtrace
-            end
-          end
-
-          # Get helpful error message when gh CLI is unavailable
-          #
-          # @return [String] User-friendly error message with installation guidance
-          def gh_not_available_message
-            <<~MESSAGE
-              gh CLI is required for PR worktrees but is not installed.
-
-              Install gh CLI:
-              - macOS: brew install gh
-              - Linux: See https://github.com/cli/cli#installation
-              - Windows: See https://github.com/cli/cli#installation
-
-              After installation, authenticate with: gh auth login
-            MESSAGE
-          end
         end
       end
     end