github2gerrit 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

github2gerrit/cli.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import json
 import logging
 import os
+import sys
 import tempfile
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
@@ -31,12 +32,20 @@ from .core import SubmissionResult
 from .duplicate_detection import DuplicateChangeError
 from .duplicate_detection import check_for_duplicates
 from .github_api import build_client
+from .github_api import get_pr_title_body
 from .github_api import get_pull
 from .github_api import get_repo_from_env
 from .github_api import iter_open_pulls
 from .gitutils import run_cmd
 from .models import GitHubContext
 from .models import Inputs
+from .rich_display import RICH_AVAILABLE
+from .rich_display import DummyProgressTracker
+from .rich_display import G2GProgressTracker
+from .rich_display import display_pr_info
+from .rich_display import safe_console_print
+from .rich_display import safe_typer_echo
+from .rich_logging import setup_rich_aware_logging
 from .ssh_common import build_git_ssh_command
 from .ssh_common import build_non_interactive_ssh_env
 from .utils import append_github_output
@@ -46,6 +55,104 @@ from .utils import log_exception_conditionally
 from .utils import parse_bool_env
 
 
+def get_version(package: str) -> str:
+    """Get package version, trying importlib.metadata first, then fallback."""
+    try:
+        from importlib.metadata import version as stdlib_version
+
+        return str(stdlib_version(package))
+    except ImportError:
+        from importlib_metadata import version as backport_version
+
+        return str(backport_version(package))
+
+
+def _exit_for_pr_state_error(pr_number: int, pr_state: str) -> None:
+    """Exit with error message for invalid PR state."""
+    error_msg = (
+        f"❌ Pull request #{pr_number} is {pr_state} and cannot be processed"
+    )
+    safe_console_print(error_msg, style="red", err=True)
+    raise typer.Exit(1)
+
+
+def _exit_for_pr_not_found(pr_number: int, repository: str) -> None:
+    """Exit with error message for PR not found."""
+    error_msg = (
+        f"❌ Pull request #{pr_number} not found in repository {repository}"
+    )
+    safe_console_print(error_msg, style="red", err=True)
+    raise typer.Exit(1)
+
+
+def _exit_for_pr_fetch_error(exc: Exception) -> None:
+    """Exit with error message for PR fetch failure."""
+    error_msg = f"❌ Failed to fetch PR details: {exc}"
+    safe_console_print(error_msg, style="red", err=True)
+    raise typer.Exit(1)
+
+
+def _extract_and_display_pr_info(
+    gh: GitHubContext,
+    progress_tracker: Any = None,
+) -> None:
+    """Extract PR information and display it with Rich formatting."""
+    if not gh.pr_number:
+        return
+
+    try:
+        # Get GitHub token and build client
+        token = os.getenv("GITHUB_TOKEN", "")
+        if not token:
+            safe_console_print(
+                "⚠️  No GITHUB_TOKEN available - skipping PR info display",
+                style="yellow",
+                progress_tracker=progress_tracker,
+            )
+            return
+
+        client = build_client(token)
+        repo = get_repo_from_env(client)
+        pr_obj = get_pull(repo, int(gh.pr_number))
+
+        # Check PR state and exit if not processable
+        pr_state = getattr(pr_obj, "state", "unknown")
+        if pr_state != "open":
+            _exit_for_pr_state_error(gh.pr_number, pr_state)
+
+        # Extract PR information
+        title, _body = get_pr_title_body(pr_obj)
+
+        # Get additional PR details
+        pr_info = {
+            "Repository": gh.repository,
+            "PR Number": gh.pr_number,
+            "Title": title or "No title",
+            "Author": getattr(getattr(pr_obj, "user", None), "login", "Unknown")
+            or "Unknown",
+            "Base Branch": gh.base_ref or "unknown",
+            "SHA": gh.sha or "unknown",
+            "URL": f"{gh.server_url}/{gh.repository}/pull/{gh.pr_number}",
+        }
+
+        # Add file changes count if available
+        try:
+            files = list(getattr(pr_obj, "get_files", list)())
+            pr_info["Files Changed"] = len(files)
+        except Exception:
+            pr_info["Files Changed"] = "unknown"
+
+        # Display the PR information
+        display_pr_info(pr_info, "Pull Request Details", progress_tracker)
+
+    except Exception as exc:
+        log.debug("Failed to display PR info: %s", exc)
+        if "404" in str(exc) or "Not Found" in str(exc):
+            _exit_for_pr_not_found(gh.pr_number, gh.repository)
+        else:
+            _exit_for_pr_fetch_error(exc)
+
+
 class ConfigurationError(Exception):
     """Raised when configuration validation fails.
 
@@ -114,9 +221,13 @@ class _ContextProto(Protocol):
 
 
 class _SingleUsageGroup(BaseGroup):
-    def format_usage(self, ctx: _ContextProto, formatter: _FormatterProto) -> None:
+    def format_usage(
+        self, ctx: _ContextProto, formatter: _FormatterProto
+    ) -> None:
         # Force a simplified usage line without COMMAND [ARGS]...
-        formatter.write_usage(ctx.command_path, "[OPTIONS] TARGET_URL", prefix="Usage: ")
+        formatter.write_usage(
+            ctx.command_path, "[OPTIONS] TARGET_URL", prefix="Usage: "
+        )
 
 
 # Error message constants to comply with TRY003
@@ -124,10 +235,20 @@ _MSG_MISSING_REQUIRED_INPUT = "Missing required input: {field_name}"
 _MSG_INVALID_FETCH_DEPTH = "FETCH_DEPTH must be a positive integer"
 _MSG_ISSUE_ID_MULTILINE = "Issue ID must be single line"
 
+# Show version information when --help is used or in GitHub Actions mode
+if "--help" in sys.argv or _is_github_actions_context():
+    try:
+        app_version = get_version("github2gerrit")
+        print(f"🏷️  github2gerrit version {app_version}")
+    except Exception:
+        print("⚠️  github2gerrit version information not available")
+
 app: typer.Typer = typer.Typer(
     add_completion=False,
     no_args_is_help=False,
     cls=cast(Any, _SingleUsageGroup),
+    rich_markup_mode="rich",
+    help="Tool to convert GitHub pull requests into Gerrit changes",
 )
 
 
@@ -144,7 +265,9 @@ def _resolve_org(default_org: str | None) -> str:
 if TYPE_CHECKING:
     F = TypeVar("F", bound=Callable[..., object])
 
-    def typed_app_command(*args: object, **kwargs: object) -> Callable[[F], F]: ...
+    def typed_app_command(
+        *args: object, **kwargs: object
+    ) -> Callable[[F], F]: ...
 else:
     typed_app_command = app.command
 
@@ -157,17 +280,46 @@ def main(
         help="GitHub repository or PR URL",
         metavar="TARGET_URL",
     ),
-    submit_single_commits: bool = typer.Option(
+    allow_duplicates: bool = typer.Option(
         False,
-        "--submit-single-commits",
-        envvar="SUBMIT_SINGLE_COMMITS",
-        help="Submit one commit at a time to the Gerrit repository.",
+        "--allow-duplicates",
+        envvar="ALLOW_DUPLICATES",
+        help="Allow submitting duplicate changes without error.",
     ),
-    use_pr_as_commit: bool = typer.Option(
+    allow_ghe_urls: bool = typer.Option(
         False,
-        "--use-pr-as-commit",
-        envvar="USE_PR_AS_COMMIT",
-        help="Use PR title and body as the commit message.",
+        "--allow-ghe-urls/--no-allow-ghe-urls",
+        envvar="ALLOW_GHE_URLS",
+        help="Allow non-github.com GitHub Enterprise URLs in direct URL mode.",
+    ),
+    allow_orphan_changes: bool = typer.Option(
+        False,
+        "--allow-orphan-changes/--no-allow-orphan-changes",
+        envvar="ALLOW_ORPHAN_CHANGES",
+        help="Keep unmatched Gerrit changes without warning.",
+    ),
+    ci_testing: bool = typer.Option(
+        False,
+        "--ci-testing/--no-ci-testing",
+        envvar="CI_TESTING",
+        help="Enable CI testing mode (overrides .gitreview, handles "
+        "unrelated repos).",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        envvar="DRY_RUN",
+        help="Validate settings and PR metadata; do not write to Gerrit.",
+    ),
+    duplicate_types: str = typer.Option(
+        "open",
+        "--duplicate-types",
+        envvar="DUPLICATE_TYPES",
+        help=(
+            "Gerrit change states to evaluate when determining if a change "
+            "should be considered a duplicate "
+            '(comma-separated). E.g. "open,merged,abandoned". Default: "open".'
+        ),
     ),
     fetch_depth: int = typer.Option(
         10,
@@ -181,6 +333,24 @@ def main(
         envvar="GERRIT_KNOWN_HOSTS",
         help="Known hosts entries for Gerrit SSH (single or multi-line).",
     ),
+    gerrit_project: str = typer.Option(
+        "",
+        "--gerrit-project",
+        envvar="GERRIT_PROJECT",
+        help="Gerrit project (optional; .gitreview preferred).",
+    ),
+    gerrit_server: str = typer.Option(
+        "",
+        "--gerrit-server",
+        envvar="GERRIT_SERVER",
+        help="Gerrit server hostname (optional; .gitreview preferred).",
+    ),
+    gerrit_server_port: int = typer.Option(
+        29418,
+        "--gerrit-server-port",
+        envvar="GERRIT_SERVER_PORT",
+        help="Gerrit SSH port (default: 29418).",
+    ),
     gerrit_ssh_privkey_g2g: str = typer.Option(
         "",
         "--gerrit-ssh-privkey-g2g",
@@ -199,23 +369,35 @@ def main(
         envvar="GERRIT_SSH_USER_G2G_EMAIL",
         help="Email address for the Gerrit SSH user.",
     ),
+    issue_id: str = typer.Option(
+        "",
+        "--issue-id",
+        envvar="ISSUE_ID",
+        help="Issue ID to include in commit message (e.g., Issue-ID: ABC-123).",
+    ),
+    log_reconcile_json: bool = typer.Option(
+        True,
+        "--log-reconcile-json/--no-log-reconcile-json",
+        envvar="LOG_RECONCILE_JSON",
+        help="Emit structured JSON reconciliation summary.",
+    ),
+    normalise_commit: bool = typer.Option(
+        True,
+        "--normalise-commit/--no-normalise-commit",
+        envvar="NORMALISE_COMMIT",
+        help="Normalize commit messages to conventional commit format.",
+    ),
     organization: str | None = typer.Option(
         None,
         "--organization",
         envvar="ORGANIZATION",
         help=("Organization (defaults to GITHUB_REPOSITORY_OWNER when unset)."),
     ),
-    reviewers_email: str = typer.Option(
-        "",
-        "--reviewers-email",
-        envvar="REVIEWERS_EMAIL",
-        help="Comma-separated list of reviewer emails.",
-    ),
-    allow_ghe_urls: bool = typer.Option(
-        False,
-        "--allow-ghe-urls/--no-allow-ghe-urls",
-        envvar="ALLOW_GHE_URLS",
-        help="Allow non-github.com GitHub Enterprise URLs in direct URL mode.",
+    persist_single_mapping_comment: bool = typer.Option(
+        True,
+        "--persist-single-mapping-comment/--no-persist-single-mapping-comment",
+        envvar="PERSIST_SINGLE_MAPPING_COMMENT",
+        help="Replace existing mapping comment instead of appending.",
     ),
     preserve_github_prs: bool = typer.Option(
         False,
@@ -223,61 +405,48 @@ def main(
         envvar="PRESERVE_GITHUB_PRS",
         help="Do not close GitHub PRs after pushing to Gerrit.",
     ),
-    dry_run: bool = typer.Option(
-        False,
-        "--dry-run",
-        envvar="DRY_RUN",
-        help="Validate settings and PR metadata; do not write to Gerrit.",
+    reuse_strategy: str = typer.Option(
+        "topic+comment",
+        "--reuse-strategy",
+        envvar="REUSE_STRATEGY",
+        help="Strategy for reusing Change-IDs: topic, comment, "
+        "topic+comment, none.",
     ),
-    gerrit_server: str = typer.Option(
+    reviewers_email: str = typer.Option(
         "",
-        "--gerrit-server",
-        envvar="GERRIT_SERVER",
-        help="Gerrit server hostname (optional; .gitreview preferred).",
+        "--reviewers-email",
+        envvar="REVIEWERS_EMAIL",
+        help="Comma-separated list of reviewer emails.",
     ),
-    gerrit_server_port: str = typer.Option(
-        "29418",
-        "--gerrit-server-port",
-        envvar="GERRIT_SERVER_PORT",
-        help="Gerrit SSH port (default: 29418).",
+    show_progress: bool = typer.Option(
+        True,
+        "--progress/--no-progress",
+        envvar="G2G_SHOW_PROGRESS",
+        help="Show real-time progress updates with Rich formatting.",
     ),
-    gerrit_project: str = typer.Option(
-        "",
-        "--gerrit-project",
-        envvar="GERRIT_PROJECT",
-        help="Gerrit project (optional; .gitreview preferred).",
+    similarity_files: bool = typer.Option(
+        True,
+        "--similarity-files/--no-similarity-files",
+        envvar="SIMILARITY_FILES",
+        help="Require exact file signature match for reconciliation.",
     ),
-    issue_id: str = typer.Option(
-        "",
-        "--issue-id",
-        envvar="ISSUE_ID",
-        help="Issue ID to include in commit message (e.g., Issue-ID: ABC-123).",
+    similarity_subject: float = typer.Option(
+        0.7,
+        "--similarity-subject",
+        envvar="SIMILARITY_SUBJECT",
+        help="Subject token Jaccard similarity threshold (0.0-1.0).",
     ),
-    allow_duplicates: bool = typer.Option(
+    submit_single_commits: bool = typer.Option(
         False,
-        "--allow-duplicates",
-        envvar="ALLOW_DUPLICATES",
-        help="Allow submitting duplicate changes without error.",
+        "--submit-single-commits",
+        envvar="SUBMIT_SINGLE_COMMITS",
+        help="Submit one commit at a time to the Gerrit repository.",
     ),
-    ci_testing: bool = typer.Option(
+    use_pr_as_commit: bool = typer.Option(
         False,
-        "--ci-testing/--no-ci-testing",
-        envvar="CI_TESTING",
-        help="Enable CI testing mode (overrides .gitreview, handles unrelated repos).",
-    ),
-    duplicates: str = typer.Option(
-        "open",
-        "--duplicates",
-        envvar="DUPLICATES",
-        help=(
-            'Gerrit statuses for duplicate detection (comma-separated). E.g. "open,merged,abandoned". Default: "open".'
-        ),
-    ),
-    normalise_commit: bool = typer.Option(
-        True,
-        "--normalise-commit/--no-normalise-commit",
-        envvar="NORMALISE_COMMIT",
-        help="Normalize commit messages to conventional commit format.",
+        "--use-pr-as-commit",
+        envvar="USE_PR_AS_COMMIT",
+        help="Use PR title and body as the commit message.",
     ),
     verbose: bool = typer.Option(
         False,
@@ -286,23 +455,35 @@ def main(
         envvar="G2G_VERBOSE",
         help="Verbose output (sets loglevel to DEBUG).",
     ),
+    version_flag: bool = typer.Option(
+        False,
+        "--version",
+        help="Show version and exit.",
+    ),
 ) -> None:
     """
     Tool to convert GitHub pull requests into Gerrit changes
 
-    - Providing a URL to a pull request: converts that pull request
-      into a Gerrit change
+    - PR URL: converts the pull request to Gerrit change
+    - Repo URL: converts all open pull requests to Gerrit changes
+    - No arguments: uses environment variables (CI/CD mode)
+    """
 
-    - Providing a URL to a GitHub repository converts all open pull
-      requests into Gerrit changes
+    # Handle version flag first
+    if version_flag:
+        try:
+            app_version = get_version("github2gerrit")
+            typer.echo(f"github2gerrit version {app_version}")
+        except Exception:
+            typer.echo("Version information not available")
+        raise typer.Exit(code=0)
 
-    - No arguments for CI/CD environment; reads parameters from
-      environment variables
-    """
     # Override boolean parameters with properly parsed environment variables
     # This ensures that string "false" from GitHub Actions is handled correctly
     if os.getenv("SUBMIT_SINGLE_COMMITS"):
-        submit_single_commits = parse_bool_env(os.getenv("SUBMIT_SINGLE_COMMITS"))
+        submit_single_commits = parse_bool_env(
+            os.getenv("SUBMIT_SINGLE_COMMITS")
+        )
 
     if os.getenv("USE_PR_AS_COMMIT"):
         use_pr_as_commit = parse_bool_env(os.getenv("USE_PR_AS_COMMIT"))
@@ -318,13 +499,50 @@ def main(
 
     if os.getenv("CI_TESTING"):
         ci_testing = parse_bool_env(os.getenv("CI_TESTING"))
+
+    if os.getenv("SIMILARITY_FILES"):
+        similarity_files = parse_bool_env(os.getenv("SIMILARITY_FILES"))
+
+    if os.getenv("ALLOW_ORPHAN_CHANGES"):
+        allow_orphan_changes = parse_bool_env(os.getenv("ALLOW_ORPHAN_CHANGES"))
+
+    if os.getenv("PERSIST_SINGLE_MAPPING_COMMENT"):
+        persist_single_mapping_comment = parse_bool_env(
+            os.getenv("PERSIST_SINGLE_MAPPING_COMMENT")
+        )
+
+    if os.getenv("LOG_RECONCILE_JSON"):
+        log_reconcile_json = parse_bool_env(os.getenv("LOG_RECONCILE_JSON"))
     # Set up logging level based on verbose flag
     if verbose:
         os.environ["G2G_LOG_LEVEL"] = "DEBUG"
         _reconfigure_logging()
+
+    # Initialize Rich-aware logging system
+    setup_rich_aware_logging()
+
+    # Log version to logs in GitHub Actions environment
+    if _is_github_actions_context():
+        try:
+            app_version = get_version("github2gerrit")
+            log.info("github2gerrit version %s", app_version)
+        except Exception:
+            log.warning("Version information not available")
+
+    # Show initial progress if Rich is available and progress is enabled
+    if show_progress and not RICH_AVAILABLE:
+        safe_console_print(
+            "📋 Rich formatting not available - progress will be shown as "
+            "simple text..."
+        )
+
+    # Store progress flag in environment for use by processing functions
+    os.environ["G2G_SHOW_PROGRESS"] = "true" if show_progress else "false"
     # Normalize CLI options into environment for unified processing.
     # Explicitly set all boolean flags to ensure consistent behavior
-    os.environ["SUBMIT_SINGLE_COMMITS"] = "true" if submit_single_commits else "false"
+    os.environ["SUBMIT_SINGLE_COMMITS"] = (
+        "true" if submit_single_commits else "false"
+    )
     os.environ["USE_PR_AS_COMMIT"] = "true" if use_pr_as_commit else "false"
     os.environ["FETCH_DEPTH"] = str(fetch_depth)
     if gerrit_known_hosts:
@@ -340,22 +558,34 @@ def main(
         os.environ["ORGANIZATION"] = resolved_org
     if reviewers_email:
         os.environ["REVIEWERS_EMAIL"] = reviewers_email
-    os.environ["PRESERVE_GITHUB_PRS"] = "true" if preserve_github_prs else "false"
+    os.environ["PRESERVE_GITHUB_PRS"] = (
+        "true" if preserve_github_prs else "false"
+    )
     os.environ["DRY_RUN"] = "true" if dry_run else "false"
     os.environ["NORMALISE_COMMIT"] = "true" if normalise_commit else "false"
     os.environ["ALLOW_GHE_URLS"] = "true" if allow_ghe_urls else "false"
     if gerrit_server:
         os.environ["GERRIT_SERVER"] = gerrit_server
     if gerrit_server_port:
-        os.environ["GERRIT_SERVER_PORT"] = gerrit_server_port
+        os.environ["GERRIT_SERVER_PORT"] = str(gerrit_server_port)
     if gerrit_project:
         os.environ["GERRIT_PROJECT"] = gerrit_project
     if issue_id:
         os.environ["ISSUE_ID"] = issue_id
     os.environ["ALLOW_DUPLICATES"] = "true" if allow_duplicates else "false"
     os.environ["CI_TESTING"] = "true" if ci_testing else "false"
-    if duplicates:
-        os.environ["DUPLICATES"] = duplicates
+    os.environ["DUPLICATE_TYPES"] = duplicate_types
+    if reuse_strategy:
+        os.environ["REUSE_STRATEGY"] = reuse_strategy
+    os.environ["SIMILARITY_SUBJECT"] = str(similarity_subject)
+    os.environ["SIMILARITY_FILES"] = "true" if similarity_files else "false"
+    os.environ["ALLOW_ORPHAN_CHANGES"] = (
+        "true" if allow_orphan_changes else "false"
+    )
+    os.environ["PERSIST_SINGLE_MAPPING_COMMENT"] = (
+        "true" if persist_single_mapping_comment else "false"
+    )
+    os.environ["LOG_RECONCILE_JSON"] = "true" if log_reconcile_json else "false"
     # URL mode handling
     if target_url:
         org, repo, pr = _parse_github_target(target_url)
@@ -395,7 +625,10 @@ def main(
 def _setup_logging() -> logging.Logger:
     level_name = os.getenv("G2G_LOG_LEVEL", "INFO").upper()
     level = getattr(logging, level_name, logging.INFO)
-    fmt = "%(asctime)s %(levelname)-8s %(name)s %(filename)s:%(lineno)d | %(message)s"
+    fmt = (
+        "%(asctime)s %(levelname)-8s %(name)s %(filename)s:%(lineno)d | "
+        "%(message)s"
+    )
     logging.basicConfig(level=level, format=fmt)
     return logging.getLogger(APP_NAME)
 
@@ -421,22 +654,47 @@ def _build_inputs_from_env() -> Inputs:
         gerrit_ssh_privkey_g2g=env_str("GERRIT_SSH_PRIVKEY_G2G"),
         gerrit_ssh_user_g2g=env_str("GERRIT_SSH_USER_G2G"),
         gerrit_ssh_user_g2g_email=env_str("GERRIT_SSH_USER_G2G_EMAIL"),
-        organization=env_str("ORGANIZATION", env_str("GITHUB_REPOSITORY_OWNER")),
+        organization=env_str(
+            "ORGANIZATION", env_str("GITHUB_REPOSITORY_OWNER")
+        ),
         reviewers_email=env_str("REVIEWERS_EMAIL", ""),
         preserve_github_prs=env_bool("PRESERVE_GITHUB_PRS", False),
         dry_run=env_bool("DRY_RUN", False),
         normalise_commit=env_bool("NORMALISE_COMMIT", True),
         gerrit_server=env_str("GERRIT_SERVER", ""),
-        gerrit_server_port=env_str("GERRIT_SERVER_PORT", "29418"),
+        gerrit_server_port=int(
+            env_str("GERRIT_SERVER_PORT", "29418") or "29418"
+        ),
         gerrit_project=env_str("GERRIT_PROJECT"),
         issue_id=env_str("ISSUE_ID", ""),
         allow_duplicates=env_bool("ALLOW_DUPLICATES", False),
         ci_testing=env_bool("CI_TESTING", False),
-        duplicates_filter=env_str("DUPLICATES", "open"),
+        duplicates_filter=env_str("DUPLICATE_TYPES", "open"),
+        reuse_strategy=env_str("REUSE_STRATEGY", "topic+comment"),
+        similarity_subject=float(env_str("SIMILARITY_SUBJECT", "0.7") or "0.7"),
+        similarity_files=env_bool("SIMILARITY_FILES", True),
+        allow_orphan_changes=env_bool("ALLOW_ORPHAN_CHANGES", False),
+        persist_single_mapping_comment=env_bool(
+            "PERSIST_SINGLE_MAPPING_COMMENT", True
+        ),
+        log_reconcile_json=env_bool("LOG_RECONCILE_JSON", True),
     )
 
 
 def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
+    # Initialize progress tracker for bulk processing
+    show_progress = env_bool("G2G_SHOW_PROGRESS", True)
+    progress_tracker: Any = None
+
+    if show_progress:
+        target = gh.repository
+        progress_tracker = G2GProgressTracker(target)
+        progress_tracker.start()
+        progress_tracker.update_operation("Getting repository and PRs...")
+    else:
+        target = gh.repository
+        progress_tracker = DummyProgressTracker("GitHub to Gerrit", target)
+
     client = build_client()
     repo = get_repo_from_env(client)
 
@@ -447,6 +705,11 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
     prs_list = list(iter_open_pulls(repo))
     log.info("Found %d open PRs to process", len(prs_list))
 
+    if progress_tracker:
+        progress_tracker.update_operation(
+            f"Processing {len(prs_list)} open PRs..."
+        )
+
     # Result tracking for summary
     processed_count = 0
     succeeded_count = 0
@@ -466,22 +729,42 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
         if pr_number <= 0:
             return "invalid", None, None
 
-        log.info("Starting processing of PR #%d", pr_number)
+        log.debug("Starting processing of PR #%d", pr_number)
         log.debug(
-            "Processing PR #%d in multi-PR mode with event_name=%s, event_action=%s",
+            "Processing PR #%d in multi-PR mode with event_name=%s, "
+            "event_action=%s",
             pr_number,
             gh.event_name,
             gh.event_action,
         )
 
+        # Update progress tracker for this PR
+        if progress_tracker:
+            progress_tracker.update_operation(f"Processing PR #{pr_number}...")
+            progress_tracker.pr_processed()
+
         try:
             if data.duplicates_filter:
-                os.environ["DUPLICATES"] = data.duplicates_filter
-            check_for_duplicates(per_ctx, allow_duplicates=data.allow_duplicates)
+                os.environ["DUPLICATE_TYPES"] = data.duplicates_filter
+            # Generate expected GitHub hash for trailer-aware duplicate
+            # detection
+            from .duplicate_detection import DuplicateDetector
+
+            expected_github_hash = (
+                DuplicateDetector._generate_github_change_hash(per_ctx)
+            )
+            check_for_duplicates(
+                per_ctx,
+                allow_duplicates=data.allow_duplicates,
+                expected_github_hash=expected_github_hash,
+            )
         except DuplicateChangeError as exc:
+            if progress_tracker:
+                progress_tracker.duplicate_skipped()
             log_exception_conditionally(log, "Skipping PR #%d", pr_number)
             log.warning(
-                "Skipping PR #%d due to duplicate detection: %s. Use --allow-duplicates to override this check.",
+                "Skipping PR #%d due to duplicate detection: %s. Use "
+                "--allow-duplicates to override this check.",
                 pr_number,
                 exc,
             )
@@ -492,9 +775,20 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
                 workspace = Path(temp_dir)
                 orch = Orchestrator(workspace=workspace)
                 result_multi = orch.execute(inputs=data, gh=per_ctx)
+                if progress_tracker and result_multi.change_urls:
+                    if any(
+                        "new" in url.lower() for url in result_multi.change_urls
+                    ):
+                        progress_tracker.change_submitted()
+                    else:
+                        progress_tracker.change_updated()
                 return "success", result_multi, None
         except Exception as exc:
-            log_exception_conditionally(log, "Failed to process PR #%d", pr_number)
+            if progress_tracker:
+                progress_tracker.add_error(f"PR #{pr_number} processing failed")
+            log_exception_conditionally(
+                log, "Failed to process PR #%d", pr_number
+            )
             return "failed", None, exc
 
     # Prepare PR processing tasks
@@ -521,7 +815,11 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
 
     # Process PRs in parallel
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        log.info("Processing %d PRs with %d parallel workers", len(pr_tasks), max_workers)
+        log.info(
+            "Processing %d PRs with %d parallel workers",
+            len(pr_tasks),
+            max_workers,
+        )
 
         # Submit all tasks
         future_to_pr = {
@@ -544,25 +842,43 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
                         all_urls.extend(result_multi.change_urls)
                         for url in result_multi.change_urls:
                             log.info("Gerrit change URL: %s", url)
-                            log.info("PR #%d created Gerrit change: %s", pr_number, url)
+                            log.info(
+                                "PR #%d created Gerrit change: %s",
+                                pr_number,
+                                url,
+                            )
                     if result_multi.change_numbers:
                         all_nums.extend(result_multi.change_numbers)
-                        log.info("PR #%d change numbers: %s", pr_number, result_multi.change_numbers)
+                        log.info(
+                            "PR #%d change numbers: %s",
+                            pr_number,
+                            result_multi.change_numbers,
+                        )
                     if result_multi.commit_shas:
                         all_shas.extend(result_multi.commit_shas)
                 elif status == "skipped":
                     skipped_count += 1
                 elif status == "failed":
                     failed_count += 1
-                    typer.echo(f"Failed to process PR #{pr_number}: {exc}")
+                    safe_typer_echo(
+                        f"Failed to process PR #{pr_number}: {exc}",
+                        progress_tracker=progress_tracker,
+                        err=True,
+                    )
                     log.info("Continuing to next PR despite failure")
                 else:
                     failed_count += 1
 
             except Exception as exc:
                 failed_count += 1
-                log_exception_conditionally(log, "Failed to process PR #%d", pr_number)
-                typer.echo(f"Failed to process PR #{pr_number}: {exc}")
+                log_exception_conditionally(
+                    log, "Failed to process PR #%d", pr_number
+                )
+                safe_typer_echo(
+                    f"Failed to process PR #{pr_number}: {exc}",
+                    progress_tracker=progress_tracker,
+                    err=True,
+                )
                 log.info("Continuing to next PR despite failure")
 
     # Aggregate results and provide summary
@@ -575,12 +891,46 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
 
     append_github_output(
         {
-            "gerrit_change_request_url": "\n".join(all_urls) if all_urls else "",
-            "gerrit_change_request_num": "\n".join(all_nums) if all_nums else "",
+            "gerrit_change_request_url": "\n".join(all_urls)
+            if all_urls
+            else "",
+            "gerrit_change_request_num": "\n".join(all_nums)
+            if all_nums
+            else "",
             "gerrit_commit_sha": "\n".join(all_shas) if all_shas else "",
         }
     )
 
+    # Stop progress tracker and show final results
+    if progress_tracker:
+        if failed_count == 0:
+            progress_tracker.update_operation(
+                "Bulk processing completed successfully"
+            )
+        else:
+            progress_tracker.add_error("Some PRs failed processing")
+        # Aggregate results and provide summary
+        if progress_tracker:
+            progress_tracker.stop()
+
+        # Show summary after progress tracker is stopped
+        if show_progress and RICH_AVAILABLE:
+            summary = progress_tracker.get_summary() if progress_tracker else {}
+            safe_console_print(
+                "\n✅ Bulk processing completed!"
+                if failed_count == 0
+                else "\n⚠️  Bulk processing completed with errors!"
+            )
+            safe_console_print(
+                f"⏱️  Total time: {summary.get('elapsed_time', 'unknown')}"
+            )
+            safe_console_print(f"📊 PRs processed: {processed_count}")
+            safe_console_print(f"✅ Succeeded: {succeeded_count}")
+            safe_console_print(f"⏭️  Skipped: {skipped_count}")
+            if failed_count > 0:
+                safe_console_print(f"❌ Failed: {failed_count}")
+            safe_console_print(f"🔗 Gerrit changes created: {len(all_urls)}")
+
     # Summary block
     log.info("=" * 60)
     log.info("BULK PROCESSING SUMMARY:")
@@ -595,50 +945,101 @@ def _process_bulk(data: Inputs, gh: GitHubContext) -> bool:
     return failed_count == 0
 
 
-def _process_single(data: Inputs, gh: GitHubContext) -> bool:
+def _process_single(
+    data: Inputs,
+    gh: GitHubContext,
+    progress_tracker: Any = None,
+) -> bool:
     # Create temporary directory for all git operations
     with tempfile.TemporaryDirectory() as temp_dir:
         workspace = Path(temp_dir)
 
         try:
+            if progress_tracker:
+                progress_tracker.update_operation("Preparing local checkout...")
             _prepare_local_checkout(workspace, gh, data)
         except Exception as exc:
             log.debug("Local checkout preparation failed: %s", exc)
+            if progress_tracker:
+                progress_tracker.add_error("Checkout preparation failed")
+
+        if progress_tracker:
+            progress_tracker.update_operation(
+                "Configuring SSH authentication..."
+            )
 
         orch = Orchestrator(workspace=workspace)
+
+        if progress_tracker:
+            progress_tracker.update_operation(
+                "Extracting commit information..."
+            )
+
         pipeline_success = False
         try:
+            if progress_tracker:
+                progress_tracker.update_operation("Submitting to Gerrit...")
             result = orch.execute(inputs=data, gh=gh)
             pipeline_success = True
+            if progress_tracker:
+                progress_tracker.pr_processed()
+            if progress_tracker and result.change_urls:
+                if any("new" in url.lower() for url in result.change_urls):
+                    progress_tracker.change_submitted()
+                else:
+                    progress_tracker.change_updated()
         except Exception as exc:
             log.debug("Execution failed; continuing to write outputs: %s", exc)
+            if progress_tracker:
+                progress_tracker.add_error("Execution failed")
 
-            result = SubmissionResult(change_urls=[], change_numbers=[], commit_shas=[])
+            result = SubmissionResult(
+                change_urls=[], change_numbers=[], commit_shas=[]
+            )
         if result.change_urls:
-            os.environ["GERRIT_CHANGE_REQUEST_URL"] = "\n".join(result.change_urls)
+            os.environ["GERRIT_CHANGE_REQUEST_URL"] = "\n".join(
+                result.change_urls
+            )
             # Output Gerrit change URL(s) to console
             for url in result.change_urls:
-                log.info("Gerrit change URL: %s", url)
+                log.debug("Gerrit change URL: %s", url)
+                safe_console_print(
+                    f"🔗 Gerrit change URL: {url}",
+                    style="green",
+                    progress_tracker=progress_tracker,
+                )
         if result.change_numbers:
-            os.environ["GERRIT_CHANGE_REQUEST_NUM"] = "\n".join(result.change_numbers)
+            os.environ["GERRIT_CHANGE_REQUEST_NUM"] = "\n".join(
+                result.change_numbers
+            )
         if result.commit_shas:
             os.environ["GERRIT_COMMIT_SHA"] = "\n".join(result.commit_shas)
 
         # Also write outputs to GITHUB_OUTPUT if available
         append_github_output(
             {
-                "gerrit_change_request_url": "\n".join(result.change_urls) if result.change_urls else "",
-                "gerrit_change_request_num": "\n".join(result.change_numbers) if result.change_numbers else "",
-                "gerrit_commit_sha": "\n".join(result.commit_shas) if result.commit_shas else "",
+                "gerrit_change_request_url": "\n".join(result.change_urls)
+                if result.change_urls
+                else "",
+                "gerrit_change_request_num": "\n".join(result.change_numbers)
+                if result.change_numbers
+                else "",
+                "gerrit_commit_sha": "\n".join(result.commit_shas)
+                if result.commit_shas
+                else "",
             }
         )
 
         return pipeline_success
 
 
-def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) -> None:
+def _prepare_local_checkout(
+    workspace: Path, gh: GitHubContext, data: Inputs
+) -> None:
     repo_full = gh.repository.strip() if gh.repository else ""
-    server_url = gh.server_url or os.getenv("GITHUB_SERVER_URL", "https://github.com")
+    server_url = gh.server_url or os.getenv(
+        "GITHUB_SERVER_URL", "https://github.com"
+    )
     server_url = (server_url or "https://github.com").rstrip("/")
     base_ref = gh.base_ref or ""
     pr_num_str: str = str(gh.pr_number) if gh.pr_number else "0"
@@ -647,7 +1048,10 @@ def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) ->
         return
 
     # Try SSH first for private repos if available, then fall back to HTTPS/API
-    repo_ssh_url = f"git@{server_url.replace('https://', '').replace('http://', '')}:{repo_full}.git"
+    repo_ssh_url = (
+        f"git@{server_url.replace('https://', '').replace('http://', '')}:"
+        f"{repo_full}.git"
+    )
     repo_https_url = f"{server_url}/{repo_full}.git"
 
     run_cmd(["git", "init"], cwd=workspace)
@@ -658,25 +1062,38 @@ def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) ->
 
     # Check if we should try SSH for private repos
     use_ssh = False
-    respect_user_ssh = os.getenv("G2G_RESPECT_USER_SSH", "false").lower() in ("true", "1", "yes")
+    respect_user_ssh = os.getenv("G2G_RESPECT_USER_SSH", "false").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
     gerrit_ssh_privkey = os.getenv("GERRIT_SSH_PRIVKEY_G2G")
 
     log.debug(
-        "GitHub repo access decision: SSH URL available=%s, G2G_RESPECT_USER_SSH=%s, GERRIT_SSH_PRIVKEY_G2G=%s",
+        "GitHub repo access decision: SSH URL available=%s, "
+        "G2G_RESPECT_USER_SSH=%s, GERRIT_SSH_PRIVKEY_G2G=%s",
         repo_ssh_url.startswith("git@"),
         respect_user_ssh,
         bool(gerrit_ssh_privkey),
     )
 
     if repo_ssh_url.startswith("git@"):
-        # For private repos, only try SSH if G2G_RESPECT_USER_SSH is explicitly enabled
-        # Don't use SSH just because GERRIT_SSH_PRIVKEY_G2G is set (that's for Gerrit, not GitHub)
+        # For private repos, only try SSH if G2G_RESPECT_USER_SSH is
+        # explicitly enabled
+        # Don't use SSH just because GERRIT_SSH_PRIVKEY_G2G is set
+        # (that's for Gerrit, not GitHub)
         if respect_user_ssh:
             use_ssh = True
             repo_url = repo_ssh_url
-            log.debug("Using SSH for GitHub repo access due to G2G_RESPECT_USER_SSH=true")
+            log.debug(
+                "Using SSH for GitHub repo access due to "
+                "G2G_RESPECT_USER_SSH=true"
+            )
         else:
-            log.debug("Not using SSH for GitHub repo access - G2G_RESPECT_USER_SSH not enabled")
+            log.debug(
+                "Not using SSH for GitHub repo access - "
+                "G2G_RESPECT_USER_SSH not enabled"
+            )
 
     if use_ssh:
         env = {
@@ -711,7 +1128,10 @@ def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) ->
 
     if pr_num_str:
         try:
-            pr_ref = f"refs/pull/{pr_num_str}/head:refs/remotes/origin/pr/{pr_num_str}/head"
+            pr_ref = (
+                f"refs/pull/{pr_num_str}/head:"
+                f"refs/remotes/origin/pr/{pr_num_str}/head"
+            )
             run_cmd(
                 [
                     "git",
@@ -736,7 +1156,9 @@ def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) ->
             )
             fetch_success = True
         except Exception as exc:
-            log.warning("Git fetch failed, attempting API archive fallback: %s", exc)
+            log.warning(
+                "Git fetch failed, attempting API archive fallback: %s", exc
+            )
             # Try API archive fallback for private repos
             try:
                 _fallback_to_api_archive(workspace, gh, data, pr_num_str)
@@ -750,7 +1172,9 @@ def _prepare_local_checkout(workspace: Path, gh: GitHubContext, data: Inputs) ->
         raise RuntimeError(msg)
 
 
-def _fallback_to_api_archive(workspace: Path, gh: GitHubContext, data: Inputs, pr_num_str: str) -> None:
+def _fallback_to_api_archive(
+    workspace: Path, gh: GitHubContext, data: Inputs, pr_num_str: str
+) -> None:
     """Fallback to GitHub API archive download for private repos."""
     import io
     import json
@@ -871,7 +1295,9 @@ def _fallback_to_api_archive(workspace: Path, gh: GitHubContext, data: Inputs, p
     # Create the expected branch
     run_cmd(["git", "checkout", "-B", "g2g_pr_head"], cwd=workspace)
 
-    log.info("Successfully extracted PR #%s content via API archive", pr_num_str)
+    log.info(
+        "Successfully extracted PR #%s content via API archive", pr_num_str
+    )
 
 
 def _load_effective_inputs() -> Inputs:
@@ -879,7 +1305,11 @@ def _load_effective_inputs() -> Inputs:
     data = _build_inputs_from_env()
 
     # Load per-org configuration and apply to environment before validation
-    org_for_cfg = data.organization or os.getenv("ORGANIZATION") or os.getenv("GITHUB_REPOSITORY_OWNER")
+    org_for_cfg = (
+        data.organization
+        or os.getenv("ORGANIZATION")
+        or os.getenv("GITHUB_REPOSITORY_OWNER")
+    )
     cfg = load_org_config(org_for_cfg)
 
     # Apply dynamic parameter derivation for missing Gerrit parameters
@@ -889,7 +1319,8 @@ def _load_effective_inputs() -> Inputs:
     log.debug("Configuration to apply: %s", cfg)
     if "DRY_RUN" in cfg:
         log.warning(
-            "Configuration contains DRY_RUN=%s, this may override environment DRY_RUN=%s",
+            "Configuration contains DRY_RUN=%s, this may override "
+            "environment DRY_RUN=%s",
             cfg["DRY_RUN"],
             os.getenv("DRY_RUN"),
         )
@@ -900,7 +1331,9 @@ def _load_effective_inputs() -> Inputs:
     data = _build_inputs_from_env()
 
     # Derive reviewers from local git config if running locally and unset
-    if not os.getenv("REVIEWERS_EMAIL") and (os.getenv("G2G_TARGET_URL") or not os.getenv("GITHUB_EVENT_NAME")):
+    if not os.getenv("REVIEWERS_EMAIL") and (
+        os.getenv("G2G_TARGET_URL") or not os.getenv("GITHUB_EVENT_NAME")
+    ):
         try:
             from .gitutils import enumerate_reviewer_emails
 
@@ -927,8 +1360,14 @@ def _load_effective_inputs() -> Inputs:
                     allow_duplicates=data.allow_duplicates,
                     ci_testing=data.ci_testing,
                     duplicates_filter=data.duplicates_filter,
+                    reuse_strategy=data.reuse_strategy,
+                    similarity_subject=data.similarity_subject,
+                    similarity_files=data.similarity_files,
+                    allow_orphan_changes=data.allow_orphan_changes,
+                    persist_single_mapping_comment=data.persist_single_mapping_comment,
+                    log_reconcile_json=data.log_reconcile_json,
                 )
-                log.info("Derived reviewers: %s", data.reviewers_email)
+                log.debug("Derived reviewers: %s", data.reviewers_email)
         except Exception as exc:
             log.debug("Could not derive reviewers from git config: %s", exc)
 
@@ -936,23 +1375,33 @@ def _load_effective_inputs() -> Inputs:
 
 
 def _augment_pr_refs_if_needed(gh: GitHubContext) -> GitHubContext:
-    if os.getenv("G2G_TARGET_URL") and gh.pr_number and (not gh.head_ref or not gh.base_ref):
+    if (
+        os.getenv("G2G_TARGET_URL")
+        and gh.pr_number
+        and (not gh.head_ref or not gh.base_ref)
+    ):
         try:
             client = build_client()
             repo = get_repo_from_env(client)
             pr_obj = get_pull(repo, int(gh.pr_number))
-            base_ref = str(getattr(getattr(pr_obj, "base", object()), "ref", "") or "")
-            head_ref = str(getattr(getattr(pr_obj, "head", object()), "ref", "") or "")
-            head_sha = str(getattr(getattr(pr_obj, "head", object()), "sha", "") or "")
+            base_ref = str(
+                getattr(getattr(pr_obj, "base", object()), "ref", "") or ""
+            )
+            head_ref = str(
+                getattr(getattr(pr_obj, "head", object()), "ref", "") or ""
+            )
+            head_sha = str(
+                getattr(getattr(pr_obj, "head", object()), "sha", "") or ""
+            )
             if base_ref:
                 os.environ["GITHUB_BASE_REF"] = base_ref
-                log.info("Resolved base_ref via GitHub API: %s", base_ref)
+                log.debug("Resolved base_ref via GitHub API: %s", base_ref)
             if head_ref:
                 os.environ["GITHUB_HEAD_REF"] = head_ref
-                log.info("Resolved head_ref via GitHub API: %s", head_ref)
+                log.debug("Resolved head_ref via GitHub API: %s", head_ref)
             if head_sha:
                 os.environ["GITHUB_SHA"] = head_sha
-                log.info("Resolved head sha via GitHub API: %s", head_sha)
+                log.debug("Resolved head sha via GitHub API: %s", head_sha)
             return _read_github_context()
         except Exception as exc:
             log.debug("Could not resolve PR refs via GitHub API: %s", exc)
@@ -967,21 +1416,26 @@ def _process() -> None:
         _validate_inputs(data)
     except ConfigurationError as exc:
         log_exception_conditionally(log, "Configuration validation failed")
-        typer.echo(f"Configuration validation failed: {exc}", err=True)
+        safe_typer_echo(f"Configuration validation failed: {exc}", err=True)
         raise typer.Exit(code=2) from exc
 
     gh = _read_github_context()
-    _log_effective_config(data, gh)
+    _display_effective_config(data, gh)
 
     # Test mode: short-circuit after validation
     if env_bool("G2G_TEST_MODE", False):
-        log.info("Validation complete. Ready to execute submission pipeline.")
-        typer.echo("Validation complete. Ready to execute submission pipeline.")
+        log.debug("Validation complete. Ready to execute submission pipeline.")
+        safe_typer_echo(
+            "Validation complete. Ready to execute submission pipeline."
+        )
         return
 
     # Bulk mode for URL/workflow_dispatch
     sync_all = env_bool("SYNC_ALL_OPEN_PRS", False)
-    if sync_all and (gh.event_name == "workflow_dispatch" or os.getenv("G2G_TARGET_URL")):
+    if sync_all and (
+        gh.event_name == "workflow_dispatch" or os.getenv("G2G_TARGET_URL")
+    ):
+        safe_console_print(f"🔍 Examining repository {gh.repository}")
         bulk_success = _process_bulk(data, gh)
 
         # Log external API metrics summary
@@ -1003,11 +1457,13 @@ def _process() -> None:
 
     if not gh.pr_number:
         log.error(
-            "PR_NUMBER is empty. This tool requires a valid pull request context. Current event: %s",
+            "PR_NUMBER is empty. This tool requires a valid pull request "
+            "context. Current event: %s",
             gh.event_name,
         )
-        typer.echo(
-            f"PR_NUMBER is empty. This tool requires a valid pull request context. Current event: {gh.event_name}",
+        safe_typer_echo(
+            f"PR_NUMBER is empty. This tool requires a valid pull request "
+            f"context. Current event: {gh.event_name}",
             err=True,
         )
         raise typer.Exit(code=2)
@@ -1015,25 +1471,87 @@ def _process() -> None:
     # Test mode handled earlier
 
     # Execute single-PR submission
+    # Initialize progress tracker
+    show_progress = env_bool("G2G_SHOW_PROGRESS", True)
+    progress_tracker: Any = None
+
+    if show_progress:
+        target = (
+            f"{gh.repository}/pull/{gh.pr_number}"
+            if gh.pr_number
+            else gh.repository
+        )
+        progress_tracker = G2GProgressTracker(target)
+        progress_tracker.start()
+        progress_tracker.update_operation("Getting source PR details...")
+    else:
+        target = (
+            f"{gh.repository}/pull/{gh.pr_number}"
+            if gh.pr_number
+            else gh.repository
+        )
+        progress_tracker = DummyProgressTracker("GitHub to Gerrit", target)
+
     # Augment PR refs via API when in URL mode and token present
     gh = _augment_pr_refs_if_needed(gh)
 
+    # Display PR information with Rich formatting
+    if gh.pr_number:
+        _extract_and_display_pr_info(gh, progress_tracker)
+
     # Check for duplicates in single-PR mode (before workspace setup)
     if gh.pr_number and not env_bool("SYNC_ALL_OPEN_PRS", False):
         try:
             if data.duplicates_filter:
-                os.environ["DUPLICATES"] = data.duplicates_filter
-            check_for_duplicates(gh, allow_duplicates=data.allow_duplicates)
+                os.environ["DUPLICATE_TYPES"] = data.duplicates_filter
+            # Generate expected GitHub hash for trailer-aware duplicate
+            # detection
+            from .duplicate_detection import DuplicateDetector
+
+            expected_github_hash = (
+                DuplicateDetector._generate_github_change_hash(gh)
+            )
+            if progress_tracker:
+                progress_tracker.update_operation("Checking for duplicates...")
+            check_for_duplicates(
+                gh,
+                allow_duplicates=data.allow_duplicates,
+                expected_github_hash=expected_github_hash,
+            )
+            if progress_tracker:
+                progress_tracker.update_operation("Duplicate check completed")
         except DuplicateChangeError as exc:
-            log_exception_conditionally(
-                log,
-                "Duplicate detection blocked submission for PR #%d",
-                gh.pr_number,
+            if progress_tracker:
+                progress_tracker.add_error("Duplicate change detected")
+                progress_tracker.stop()
+
+            # Display clear Rich console output for duplicate detection
+            if exc.urls:
+                urls_display = ", ".join(exc.urls)
+                safe_console_print(
+                    f"❌ Duplicate Gerrit change blocked submission: "
+                    f"{urls_display}",
+                    style="red",
+                    progress_tracker=progress_tracker,
+                )
+            else:
+                safe_console_print(
+                    "❌ Duplicate Gerrit change blocked submission",
+                    style="red",
+                    progress_tracker=progress_tracker,
+                )
+
+            safe_console_print(
+                "💡 Use --allow-duplicates to override this check.",
+                style="yellow",
+                progress_tracker=progress_tracker,
             )
-            log.info("Use --allow-duplicates to override this check.")
             raise typer.Exit(code=3) from exc
 
-    pipeline_success = _process_single(data, gh)
+    if progress_tracker:
+        progress_tracker.update_operation("Processing pull request...")
+
+    pipeline_success = _process_single(data, gh, progress_tracker)
 
     # Log external API metrics summary
     try:
@@ -1043,11 +1561,39 @@ def _process() -> None:
     except Exception as exc:
         log.debug("Failed to log API metrics summary: %s", exc)
 
+    # Stop progress tracker and show final results
+    # Clean up progress tracker
+    if progress_tracker:
+        progress_tracker.stop()
+
+    # Show summary after progress tracker is stopped
+    if show_progress and RICH_AVAILABLE:
+        summary = progress_tracker.get_summary() if progress_tracker else {}
+        safe_console_print(
+            "\n✅ Operation completed!"
+            if pipeline_success
+            else "\n❌ Operation failed!",
+            style="green" if pipeline_success else "red",
+        )
+        safe_console_print(
+            f"⏱️  Total time: {summary.get('elapsed_time', 'unknown')}"
+        )
+        if summary.get("prs_processed", 0) > 0:
+            safe_console_print(f"📊 PRs processed: {summary['prs_processed']}")
+        if summary.get("changes_submitted", 0) > 0:
+            safe_console_print(
+                f"🔄 Changes submitted: {summary['changes_submitted']}"
+            )
+        if summary.get("changes_updated", 0) > 0:
+            safe_console_print(
+                f"📝 Changes updated: {summary['changes_updated']}"
+            )
+
     # Final success/failure message after all cleanup
     if pipeline_success:
-        log.info("Submission pipeline completed SUCCESSFULLY ✅")
+        log.debug("Submission pipeline completed SUCCESSFULLY ✅")
     else:
-        log.error("Submission pipeline FAILED ❌")
+        log.debug("Submission pipeline FAILED ❌")
         raise typer.Exit(code=1)
 
     return
@@ -1065,7 +1611,9 @@ def _load_event(path: Path | None) -> dict[str, Any]:
     if not path or not path.exists():
         return {}
     try:
-        return cast(dict[str, Any], json.loads(path.read_text(encoding="utf-8")))
+        return cast(
+            dict[str, Any], json.loads(path.read_text(encoding="utf-8"))
+        )
     except Exception as exc:
         log.warning("Failed to parse GITHUB_EVENT_PATH: %s", exc)
         return {}
@@ -1132,7 +1680,10 @@ def _read_github_context() -> GitHubContext:
 
 def _validate_inputs(data: Inputs) -> None:
     if data.use_pr_as_commit and data.submit_single_commits:
-        msg = "USE_PR_AS_COMMIT and SUBMIT_SINGLE_COMMITS cannot be enabled at the same time"
+        msg = (
+            "USE_PR_AS_COMMIT and SUBMIT_SINGLE_COMMITS cannot be enabled "
+            "at the same time"
+        )
         raise ConfigurationError(msg)
 
     # Context-aware validation: different requirements for GH Actions vs CLI
@@ -1156,19 +1707,21 @@ def _validate_inputs(data: Inputs) -> None:
         # In local CLI: require explicit values or organization + derivation
         # This prevents unexpected behavior when running locally
         missing_gerrit_params = [
-            field for field in ["gerrit_ssh_user_g2g", "gerrit_ssh_user_g2g_email"] if not getattr(data, field)
+            field
+            for field in ["gerrit_ssh_user_g2g", "gerrit_ssh_user_g2g_email"]
+            if not getattr(data, field)
         ]
         if missing_gerrit_params:
             if data.organization:
                 log.info(
-                    "Local CLI usage: Gerrit parameters can be derived from "
-                    "organization '%s'. Missing: %s. Consider setting "
-                    "G2G_ENABLE_DERIVATION=true to enable derivation.",
+                    "Gerrit parameters can be derived from "
+                    "organization '%s'. Missing: %s. Set "
+                    "G2G_ENABLE_DERIVATION=false to disable derivation.",
                     data.organization,
                     ", ".join(missing_gerrit_params),
                 )
-                # Allow derivation in local mode only if explicitly enabled
-                if not env_bool("G2G_ENABLE_DERIVATION", False):
+                # Derivation enabled by default, can be disabled explicitly
+                if not env_bool("G2G_ENABLE_DERIVATION", True):
                     required_fields.extend(missing_gerrit_params)
             else:
                 required_fields.extend(missing_gerrit_params)
@@ -1181,21 +1734,20 @@ def _validate_inputs(data: Inputs) -> None:
                 "gerrit_ssh_user_g2g_email",
             ]:
                 if data.organization:
-                    if is_github_actions:
-                        log.error(
-                            "These fields can be derived automatically from "
-                            "organization '%s' if G2G_ENABLE_DERIVATION=true",
-                            data.organization,
-                        )
-                    else:
-                        log.error(
-                            "These fields can be derived from organization '%s'",
-                            data.organization,
-                        )
-                        log.error("Set G2G_ENABLE_DERIVATION=true to enable")
+                    log.error(
+                        "These fields can be derived automatically from "
+                        "organization '%s' (derivation enabled by default). "
+                        "Check that G2G_ENABLE_DERIVATION is not set to false.",
+                        data.organization,
+                    )
                 else:
-                    log.error("These fields require either explicit values or an ORGANIZATION for derivation")
-            raise ConfigurationError(_MSG_MISSING_REQUIRED_INPUT.format(field_name=field_name))
+                    log.error(
+                        "These fields require either explicit values or an "
+                        "ORGANIZATION for derivation"
+                    )
+            raise ConfigurationError(
+                _MSG_MISSING_REQUIRED_INPUT.format(field_name=field_name)
+            )
 
     # Validate fetch depth is a positive integer
     if data.fetch_depth <= 0:
@@ -1207,35 +1759,79 @@ def _validate_inputs(data: Inputs) -> None:
         raise ConfigurationError(_MSG_ISSUE_ID_MULTILINE)
 
 
-def _log_effective_config(data: Inputs, gh: GitHubContext) -> None:
-    # Avoid logging sensitive values
-    safe_privkey = _mask_secret(data.gerrit_ssh_privkey_g2g)
-    log.info("Effective configuration (sanitized):")
-    log.info("  SUBMIT_SINGLE_COMMITS: %s", data.submit_single_commits)
-    log.info("  USE_PR_AS_COMMIT: %s", data.use_pr_as_commit)
-    log.info("  FETCH_DEPTH: %s", data.fetch_depth)
-    known_hosts_status = "<provided>" if data.gerrit_known_hosts else "<will auto-discover>"
-    log.info("  GERRIT_KNOWN_HOSTS: %s", known_hosts_status)
-    log.info("  GERRIT_SSH_PRIVKEY_G2G: %s", safe_privkey)
-    log.info("  GERRIT_SSH_USER_G2G: %s", data.gerrit_ssh_user_g2g)
-    log.info("  GERRIT_SSH_USER_G2G_EMAIL: %s", data.gerrit_ssh_user_g2g_email)
-    log.info("  ORGANIZATION: %s", data.organization)
-    log.info("  REVIEWERS_EMAIL: %s", data.reviewers_email or "")
-    log.info("  PRESERVE_GITHUB_PRS: %s", data.preserve_github_prs)
-    log.info("  DRY_RUN: %s", data.dry_run)
-    log.info("  CI_TESTING: %s", data.ci_testing)
-    log.info("  GERRIT_SERVER: %s", data.gerrit_server)
-    log.info("  GERRIT_SERVER_PORT: %s", data.gerrit_server_port or "")
-    log.info("  GERRIT_PROJECT: %s", data.gerrit_project or "")
-    log.info("GitHub context:")
-    log.info("  event_name: %s", gh.event_name)
-    log.info("  event_action: %s", gh.event_action)
-    log.info("  repository: %s", gh.repository)
-    log.info("  repository_owner: %s", gh.repository_owner)
-    log.info("  pr_number: %s", gh.pr_number)
-    log.info("  base_ref: %s", gh.base_ref)
-    log.info("  head_ref: %s", gh.head_ref)
-    log.info("  sha: %s", gh.sha)
+def _display_effective_config(data: Inputs, gh: GitHubContext) -> None:
+    """Display effective configuration in a formatted table."""
+    from .rich_display import display_pr_info
+
+    # Avoid displaying sensitive values
+    known_hosts_status = "✅" if data.gerrit_known_hosts else "❌"
+    privkey_status = "✅" if data.gerrit_ssh_privkey_g2g else "❌"
+
+    # Build configuration data, filtering out empty/default values
+    # Order items logically: behavioral settings first, then credentials
+    config_info = {}
+
+    # Only show non-default boolean values
+    if data.submit_single_commits:
+        config_info["SUBMIT_SINGLE_COMMITS"] = str(data.submit_single_commits)
+    if data.use_pr_as_commit:
+        config_info["USE_PR_AS_COMMIT"] = str(data.use_pr_as_commit)
+
+    # Only show non-default fetch depth
+    if data.fetch_depth != 10:
+        config_info["FETCH_DEPTH"] = str(data.fetch_depth)
+
+    # SSH user and email first
+    if data.gerrit_ssh_user_g2g:
+        config_info["GERRIT_SSH_USER_G2G"] = data.gerrit_ssh_user_g2g
+    if data.gerrit_ssh_user_g2g_email:
+        config_info["GERRIT_SSH_USER_G2G_EMAIL"] = (
+            data.gerrit_ssh_user_g2g_email
+        )
+    if data.organization:
+        config_info["ORGANIZATION"] = data.organization
+    if data.reviewers_email:
+        config_info["REVIEWERS_EMAIL"] = data.reviewers_email
+
+    # Only show non-default boolean values
+    if data.preserve_github_prs:
+        config_info["PRESERVE_GITHUB_PRS"] = str(data.preserve_github_prs)
+    if data.dry_run:
+        config_info["DRY_RUN"] = str(data.dry_run)
+    if data.ci_testing:
+        config_info["CI_TESTING"] = str(data.ci_testing)
+
+    # Show Gerrit settings if they have values
+    if data.gerrit_server:
+        config_info["GERRIT_SERVER"] = data.gerrit_server
+    # Only show non-default port (29418 is default)
+    if data.gerrit_server_port and data.gerrit_server_port != 29418:
+        config_info["GERRIT_SERVER_PORT"] = str(data.gerrit_server_port)
+    if data.gerrit_project:
+        config_info["GERRIT_PROJECT"] = data.gerrit_project
+
+    # Move credentials to bottom of table
+    # Always show known hosts status
+    if data.gerrit_known_hosts or not data.gerrit_known_hosts:
+        config_info["GERRIT_KNOWN_HOSTS"] = known_hosts_status
+    config_info["GERRIT_SSH_PRIVKEY_G2G"] = privkey_status
+
+    # Display the configuration table
+    display_pr_info(config_info, "GitHub2Gerrit Configuration")
+
+    # Log GitHub context at debug level only
+    log.debug(
+        "GitHub context: event_name=%s, event_action=%s, repository=%s, "
+        "repository_owner=%s, pr_number=%s, base_ref=%s, head_ref=%s, sha=%s",
+        gh.event_name,
+        gh.event_action,
+        gh.repository,
+        gh.repository_owner,
+        gh.pr_number,
+        gh.base_ref,
+        gh.head_ref,
+        gh.sha,
+    )
 
 
 if __name__ == "__main__":