airbyte-internal-ops 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

{airbyte_internal_ops-0.4.0.dist-info → airbyte_internal_ops-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.4.0
+Version: 0.4.2
 Summary: MCP and API interfaces that let the agents do the admin work
 Author-email: Aaron Steers <aj@airbyte.io>
 Keywords: admin,airbyte,api,mcp

{airbyte_internal_ops-0.4.0.dist-info → airbyte_internal_ops-0.4.2.dist-info}/RECORD

@@ -2,8 +2,8 @@ airbyte_ops_mcp/__init__.py,sha256=tuzdlMkfnWBnsri5KGHM2M_xuNnzFk2u_aR79mmN7Yg,7
 airbyte_ops_mcp/_annotations.py,sha256=MO-SBDnbykxxHDESG7d8rviZZ4WlZgJKv0a8eBqcEzQ,1757
 airbyte_ops_mcp/constants.py,sha256=khcv9W3WkApIyPygEGgE2noBIqLomjoOMLxFBU1ArjA,5308
 airbyte_ops_mcp/gcp_auth.py,sha256=i0cm1_xX4fj_31iKlfARpNvTaSr85iGTSw9KMf4f4MU,7206
-airbyte_ops_mcp/github_actions.py,sha256=wKnuIVmF4u1gMYNdSoryD_PUmvMz5SaHgOvbU0dsolA,9957
-airbyte_ops_mcp/github_api.py,sha256=uupbYKAkm7yLHK_1cDXYKl1bOYhUygZhG5IHspS7duE,8104
+airbyte_ops_mcp/github_actions.py,sha256=FSi_tjS9TbwRVp8dwlDZhFOi7lJXEZQLhPm2KpcjNlY,7022
+airbyte_ops_mcp/github_api.py,sha256=ezpMR1vjqQ-1f5yOLBVbxW70OPtUferl1uA0u_gUVo8,12733
 airbyte_ops_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_ops_mcp/_legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_ops_mcp/_legacy/airbyte_ci/README.md,sha256=qEYx4geDR8AEDjrcA303h7Nol-CMDLojxUyiGzQprM8,236
@@ -353,9 +353,9 @@ airbyte_ops_mcp/cli/__init__.py,sha256=XpL7FyVfgabfBF2JR7u7NwJ2krlYqjd_OwLcWf-Xc
 airbyte_ops_mcp/cli/_base.py,sha256=I8tWnyQf0ks4r3J8N8h-5GZxyn37T-55KsbuHnxYlcg,415
 airbyte_ops_mcp/cli/_shared.py,sha256=jg-xMyGzTCGPqKd8VTfE_3kGPIyO_3Kx5sQbG4rPc0Y,1311
 airbyte_ops_mcp/cli/app.py,sha256=SEdBpqFUG2O8zGV5ifwptxrLGFph_dLr66-MX9d69gQ,789
-airbyte_ops_mcp/cli/cloud.py,sha256=OmeJPW8ME82PLJSqzoU_tz_3iqsTA-MY4QBO-ad8gfo,44141
-airbyte_ops_mcp/cli/gh.py,sha256=91b1AxFXvHQCFyXhrrym-756ZjnMCqvxFdmwCtma1zI,2046
-airbyte_ops_mcp/cli/registry.py,sha256=tcf_CDiUVJpSdBRNqlEL3zFKMqK53AhFpJjAETM4gLs,9781
+airbyte_ops_mcp/cli/cloud.py,sha256=7Iy8gpIM-Im5GMy2aShi3gE-BSPZABXPICnOyrZrJAw,44621
+airbyte_ops_mcp/cli/gh.py,sha256=koJPu0MDB6AW7mJq2z4dZV65ofvsZTkqoeitGF8KJR8,5364
+airbyte_ops_mcp/cli/registry.py,sha256=L4nDKhlegr31gSE-GUvDFSq10KgDz5kJuZXgLIxYIyg,9785
 airbyte_ops_mcp/cli/repo.py,sha256=G1hoQpH0XYhUH3FFOsia9xabGB0LP9o3XcwBuqvFVo0,16331
 airbyte_ops_mcp/cloud_admin/__init__.py,sha256=cqE96Q10Kp6elhH9DAi6TVsIwSUy3sooDLLrxTaktGk,816
 airbyte_ops_mcp/cloud_admin/api_client.py,sha256=ysTztSbLX0SZSK3qneHTSKVODRzVmLbHBC3ND0j_LTc,38020
@@ -376,15 +376,15 @@ airbyte_ops_mcp/mcp/cloud_connector_versions.py,sha256=5qUYRZapYBprmmc5J3lKQzeQ3
 airbyte_ops_mcp/mcp/connector_analysis.py,sha256=OC4KrOSkMkKPkOisWnSv96BDDE5TQYHq-Jxa2vtjJpo,298
 airbyte_ops_mcp/mcp/connector_qa.py,sha256=aImpqdnqBPDrz10BS0owsV4kuIU2XdalzgbaGZsbOL0,258
 airbyte_ops_mcp/mcp/gcp_logs.py,sha256=IPtq4098_LN1Cgeba4jATO1iYFFFpL2-aRO0pGcOdzs,2689
-airbyte_ops_mcp/mcp/github.py,sha256=h3M3VJrq09y_F9ueQVCq3bUbVBNFuTNKprHtGU_ttio,8045
+airbyte_ops_mcp/mcp/github_actions.py,sha256=_mAVTl6UX3F7S_HeV1-M5R4jMNzNQGI3ADs3sBzden8,11760
 airbyte_ops_mcp/mcp/github_repo_ops.py,sha256=PiERpt8abo20Gz4CfXhrDNlVM4o4FOt5sweZJND2a0s,5314
 airbyte_ops_mcp/mcp/metadata.py,sha256=fwGW97WknR5lfKcQnFtK6dU87aA6TmLj1NkKyqDAV9g,270
-airbyte_ops_mcp/mcp/prerelease.py,sha256=GI4p1rGDCLZ6QbEG57oD_M3_buIHwq9B0In6fbj7Ptk,11883
+airbyte_ops_mcp/mcp/prerelease.py,sha256=OoZxwy3-PAiTiKuWhhbfv_DrsHBDs9LVz4Y6EuL0Qkk,10596
 airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=VsiBBnVbOjc8lBb2Xr1lmcH3wu7QHQfjd4lORarEE1s,42700
 airbyte_ops_mcp/mcp/prompts.py,sha256=mJld9mdPECXYZffWXGSvNs4Xevx3rxqUGNlzGKVC2_s,1599
 airbyte_ops_mcp/mcp/registry.py,sha256=PW-VYUj42qx2pQ_apUkVaoUFq7VgB9zEU7-aGrkSCCw,290
-airbyte_ops_mcp/mcp/regression_tests.py,sha256=VpXS36Ox2qPxtxnDhVoNfr83UfppWx8rMgCoDiKWzWg,16727
-airbyte_ops_mcp/mcp/server.py,sha256=lKAXxt4u4bz7dsKvAYFFHziMbun2pOnxYmrMtRxsZvM,5317
+airbyte_ops_mcp/mcp/regression_tests.py,sha256=dmM22ODwUTbVisKiRcJunzEgMKrZOkpsbkUm0_hFWYk,16752
+airbyte_ops_mcp/mcp/server.py,sha256=dMOFXPFeHBIqicOWs8UsPfzgsWnzsWDsZJ79E_OYjT0,5341
 airbyte_ops_mcp/mcp/server_info.py,sha256=Yi4B1auW64QZGBDas5mro_vwTjvrP785TFNSBP7GhRg,2361
 airbyte_ops_mcp/prod_db_access/__init__.py,sha256=5pxouMPY1beyWlB0UwPnbaLTKTHqU6X82rbbgKY2vYU,1069
 airbyte_ops_mcp/prod_db_access/db_engine.py,sha256=VUqEWZtharJUR-Cri_pMwtGh1C4Neu4s195mbEXlm-w,9190
@@ -396,7 +396,7 @@ airbyte_ops_mcp/registry/models.py,sha256=B4L4TKr52wo0xs0CqvCBrpowqjShzVnZ5eTr2-
 airbyte_ops_mcp/registry/publish.py,sha256=VoPxsM2_0zJ829orzCRN-kjgcJtuBNyXgW4I9J680ro,12717
 airbyte_ops_mcp/regression_tests/__init__.py,sha256=8pwJIdz1Lb9oFV6UQ3DSjYKd8HCSqU8RpH5SDgEcEBA,1038
 airbyte_ops_mcp/regression_tests/cdk_secrets.py,sha256=iRjqqBS96KZoswfgT7ju-pE_pfbYoDy4PfrK-K8uyYs,3204
-airbyte_ops_mcp/regression_tests/ci_output.py,sha256=rrvCVKKShc1iVPMuQJDBqSbsiAHIDpX8SA9j0Uwl_Cg,12718
+airbyte_ops_mcp/regression_tests/ci_output.py,sha256=DwBVCaCZAhI4MNf39EpUDIzOsHx5T1BZp268IAdaayg,15180
 airbyte_ops_mcp/regression_tests/config.py,sha256=dwWeY0tatdbwl9BqbhZ7EljoZDCtKmGO5fvOAIxeXmA,5873
 airbyte_ops_mcp/regression_tests/connection_fetcher.py,sha256=5wIiA0VvCFNEc-fr6Po18gZMX3E5fyPOGf2SuVOqv5U,12799
 airbyte_ops_mcp/regression_tests/connection_secret_retriever.py,sha256=FhWNVWq7sON4nwUmVJv8BgXBOqg1YV4b5WuWyCzZ0LU,4695
@@ -414,7 +414,7 @@ airbyte_ops_mcp/regression_tests/regression/comparators.py,sha256=MJkLZEKHivgrG0
 airbyte_ops_mcp/regression_tests/validation/__init__.py,sha256=MBEwGOoNuqT4_oCahtoK62OKWIjUCfWa7vZTxNj_0Ek,1532
 airbyte_ops_mcp/regression_tests/validation/catalog_validators.py,sha256=jqqVAMOk0mtdPgwu4d0hA0ZEjtsNh5gapvGydRv3_qk,12553
 airbyte_ops_mcp/regression_tests/validation/record_validators.py,sha256=RjauAhKWNwxMBTu0eNS2hMFNQVs5CLbQU51kp6FOVDk,7432
-airbyte_internal_ops-0.4.0.dist-info/METADATA,sha256=K9rJIUSobD2QWdHccHpKZooawgipH8ZozDqTl0FrG-8,5679
-airbyte_internal_ops-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-airbyte_internal_ops-0.4.0.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
-airbyte_internal_ops-0.4.0.dist-info/RECORD,,
+airbyte_internal_ops-0.4.2.dist-info/METADATA,sha256=RP-Eu-2phGMnspxD4d5rQBI9Q6jnU-Zr0Fdi8hrzpqY,5679
+airbyte_internal_ops-0.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_internal_ops-0.4.2.dist-info/entry_points.txt,sha256=WxP0l7bRFss4Cr5uQqVj9mTEKwnRKouNuphXQF0lotA,171
+airbyte_internal_ops-0.4.2.dist-info/RECORD,,

airbyte_ops_mcp/cli/cloud.py

@@ -53,7 +53,7 @@ from airbyte_ops_mcp.mcp.cloud_connector_versions import (
 from airbyte_ops_mcp.regression_tests.cdk_secrets import get_first_config_from_secrets
 from airbyte_ops_mcp.regression_tests.ci_output import (
     generate_regression_report,
-    get_report_summary,
+    generate_single_version_report,
     write_github_output,
     write_github_outputs,
     write_github_summary,
@@ -988,6 +988,18 @@ def regression_test(
             },
         )
 
+        # Generate report.md with detailed metrics
+        report_path = generate_single_version_report(
+            connector_image=resolved_test_image,
+            command=command,
+            result=result,
+            output_dir=output_path,
+        )
+        print_success(f"Generated report: {report_path}")
+
+        # Write report to GITHUB_STEP_SUMMARY (if env var exists)
+        write_github_summary(report_path.read_text())
+
         if result["success"]:
             print_success(
                 f"Single-version regression test passed for {resolved_test_image}"
@@ -1059,8 +1071,8 @@ def regression_test(
         )
         print_success(f"Generated regression report: {report_path}")
 
-        summary = get_report_summary(report_path)
-        write_github_summary(summary)
+        # Write report to GITHUB_STEP_SUMMARY (if env var exists)
+        write_github_summary(report_path.read_text())
 
         if regression_detected:
             exit_with_error(

airbyte_ops_mcp/cli/gh.py

@@ -3,17 +3,23 @@
 
 Commands:
     airbyte-ops gh workflow status - Check GitHub Actions workflow status
+    airbyte-ops gh workflow trigger - Trigger a GitHub Actions CI workflow
 """
 
 from __future__ import annotations
 
+import json
+import time
 from typing import Annotated
 
 from cyclopts import App, Parameter
 
 from airbyte_ops_mcp.cli._base import app
 from airbyte_ops_mcp.cli._shared import exit_with_error, print_json
-from airbyte_ops_mcp.mcp.github import check_workflow_status
+from airbyte_ops_mcp.mcp.github_actions import (
+    check_ci_workflow_status,
+    trigger_ci_workflow,
+)
 
 # Create the gh sub-app
 gh_app = App(name="gh", help="GitHub operations.")
@@ -62,10 +68,107 @@ def workflow_status(
             "Must provide either --url OR all of (--owner, --repo, --run-id)."
         )
 
-    result = check_workflow_status(
+    result = check_ci_workflow_status(
         workflow_url=url,
         owner=owner,
         repo=repo,
         run_id=run_id,
     )
     print_json(result.model_dump())
+
+
+@workflow_app.command(name="trigger")
+def workflow_trigger(
+    owner: Annotated[
+        str,
+        Parameter(help="Repository owner (e.g., 'airbytehq')."),
+    ],
+    repo: Annotated[
+        str,
+        Parameter(help="Repository name (e.g., 'airbyte')."),
+    ],
+    workflow_file: Annotated[
+        str,
+        Parameter(help="Workflow file name (e.g., 'connector-regression-test.yml')."),
+    ],
+    workflow_definition_ref: Annotated[
+        str | None,
+        Parameter(
+            help="Branch name or PR number for the workflow definition to use. "
+            "If a PR number is provided, it resolves to the PR's head branch name. "
+            "Defaults to 'main' if not specified."
+        ),
+    ] = None,
+    inputs: Annotated[
+        str | None,
+        Parameter(
+            help='Workflow inputs as a JSON string (e.g., \'{"key": "value"}\').'
+        ),
+    ] = None,
+    wait: Annotated[
+        bool,
+        Parameter(help="Wait for the workflow to complete before returning."),
+    ] = False,
+    wait_seconds: Annotated[
+        int,
+        Parameter(
+            help="Maximum seconds to wait for workflow completion (default: 600)."
+        ),
+    ] = 600,
+) -> None:
+    """Trigger a GitHub Actions CI workflow via workflow_dispatch.
+
+    This command triggers a workflow in any GitHub repository that has workflow_dispatch
+    enabled. It resolves PR numbers to branch names automatically.
+    """
+    # Parse inputs JSON if provided
+    parsed_inputs: dict[str, str] | None = None
+    if inputs:
+        try:
+            parsed_inputs = json.loads(inputs)
+        except json.JSONDecodeError as e:
+            exit_with_error(f"Invalid JSON for --inputs: {e}")
+
+    # Trigger the workflow
+    result = trigger_ci_workflow(
+        owner=owner,
+        repo=repo,
+        workflow_file=workflow_file,
+        workflow_definition_ref=workflow_definition_ref,
+        inputs=parsed_inputs,
+    )
+
+    print_json(result.model_dump())
+
+    # If wait is enabled and we have a run_id, poll for completion
+    if wait and result.run_id:
+        print(f"\nWaiting for workflow to complete (timeout: {wait_seconds}s)...")
+        start_time = time.time()
+        poll_interval = 10  # seconds
+
+        while time.time() - start_time < wait_seconds:
+            status_result = check_ci_workflow_status(
+                owner=owner,
+                repo=repo,
+                run_id=result.run_id,
+            )
+
+            if status_result.status == "completed":
+                print(
+                    f"\nWorkflow completed with conclusion: {status_result.conclusion}"
+                )
+                print_json(status_result.model_dump())
+                return
+
+            elapsed = int(time.time() - start_time)
+            print(f"  Status: {status_result.status} (elapsed: {elapsed}s)")
+            time.sleep(poll_interval)
+
+        print(f"\nTimeout reached after {wait_seconds}s. Workflow still running.")
+        # Print final status
+        final_status = check_ci_workflow_status(
+            owner=owner,
+            repo=repo,
+            run_id=result.run_id,
+        )
+        print_json(final_status.model_dump())

airbyte_ops_mcp/cli/registry.py

@@ -28,11 +28,11 @@ from airbyte_ops_mcp.cli._shared import (
     print_json,
     print_success,
 )
-from airbyte_ops_mcp.github_actions import (
+from airbyte_ops_mcp.github_api import (
     get_file_contents_at_ref,
     resolve_github_token,
 )
-from airbyte_ops_mcp.mcp.github import get_docker_image_info
+from airbyte_ops_mcp.mcp.github_actions import get_docker_image_info
 from airbyte_ops_mcp.mcp.prerelease import (
     compute_prerelease_docker_image_tag,
     publish_connector_to_airbyte_registry,

airbyte_ops_mcp/github_actions.py

@@ -1,72 +1,23 @@
 # Copyright (c) 2025 Airbyte, Inc., all rights reserved.
 """GitHub Actions API utilities.
 
-This module provides core utilities for interacting with GitHub Actions workflows,
-including workflow dispatch, run discovery, and authentication. These utilities
+This module provides utilities for interacting with GitHub Actions workflows,
+including workflow dispatch, run discovery, and job status. These utilities
 are used by MCP tools but are not MCP-specific.
+
+For general GitHub API utilities (authentication, PR info, file contents),
+see the github_api module.
 """
 
 from __future__ import annotations
 
-import os
-import shutil
-import subprocess
 import time
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
 import requests
 
-GITHUB_API_BASE = "https://api.github.com"
-
-
-def resolve_github_token(preferred_env_vars: list[str] | None = None) -> str:
-    """Resolve GitHub token from environment variables or gh CLI.
-
-    Checks environment variables in order of preference, returning the first
-    non-empty value found. If no environment variables are set, attempts to
-    get a token from the gh CLI tool using 'gh auth token'.
-
-    Args:
-        preferred_env_vars: List of environment variable names to check in order.
-            Defaults to ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"].
-
-    Returns:
-        GitHub token string.
-
-    Raises:
-        ValueError: If no GitHub token is found in env vars or gh CLI.
-    """
-    if preferred_env_vars is None:
-        preferred_env_vars = ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"]
-
-    # Check environment variables first
-    for env_var in preferred_env_vars:
-        token = os.getenv(env_var)
-        if token:
-            return token
-
-    # Fall back to gh CLI if available
-    gh_path = shutil.which("gh")
-    if gh_path:
-        try:
-            result = subprocess.run(
-                [gh_path, "auth", "token"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-                check=False,
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                return result.stdout.strip()
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
-            pass
-
-    env_var_list = ", ".join(preferred_env_vars)
-    raise ValueError(
-        f"No GitHub token found. Set one of: {env_var_list} environment variable, "
-        "or authenticate with 'gh auth login'."
-    )
+from airbyte_ops_mcp.github_api import GITHUB_API_BASE, resolve_github_token
 
 
 @dataclass
@@ -106,51 +57,6 @@ class WorkflowJobInfo:
     """ISO 8601 timestamp when the job completed"""
 
 
-def get_file_contents_at_ref(
-    owner: str,
-    repo: str,
-    path: str,
-    ref: str,
-    token: str | None = None,
-) -> str | None:
-    """Fetch file contents from GitHub at a specific ref.
-
-    Uses the GitHub Contents API to retrieve file contents at a specific
-    commit SHA, branch, or tag. This allows reading files without having
-    the repository checked out locally.
-
-    Args:
-        owner: Repository owner (e.g., "airbytehq")
-        repo: Repository name (e.g., "airbyte")
-        path: Path to the file within the repository
-        ref: Git ref (commit SHA, branch name, or tag)
-        token: GitHub API token (optional for public repos, but recommended
-            to avoid rate limiting)
-
-    Returns:
-        File contents as a string, or None if the file doesn't exist.
-
-    Raises:
-        requests.HTTPError: If API request fails (except 404).
-    """
-    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/contents/{path}"
-    headers = {
-        "Accept": "application/vnd.github.raw+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-
-    params = {"ref": ref}
-
-    response = requests.get(url, headers=headers, params=params, timeout=30)
-    if response.status_code == 404:
-        return None
-    response.raise_for_status()
-
-    return response.text
-
-
 def get_workflow_jobs(
     owner: str,
     repo: str,

airbyte_ops_mcp/github_api.py

@@ -1,20 +1,178 @@
 # Copyright (c) 2025 Airbyte, Inc., all rights reserved.
-"""GitHub API utilities for user and comment operations.
+"""GitHub API utilities.
 
-This module provides utilities for interacting with GitHub's REST API
-to retrieve user information and comment details. These utilities are
-used by MCP tools for authorization and audit purposes.
+This module provides core utilities for interacting with GitHub's REST API,
+including authentication, user/comment operations, PR information retrieval,
+and file content fetching. These utilities are used by MCP tools and other
+modules but are not MCP-specific.
 """
 
 from __future__ import annotations
 
+import os
 import re
+import shutil
+import subprocess
 from dataclasses import dataclass
 from urllib.parse import urlparse
 
 import requests
 
-from airbyte_ops_mcp.github_actions import GITHUB_API_BASE, resolve_github_token
+GITHUB_API_BASE = "https://api.github.com"
+
+
+def resolve_github_token(preferred_env_vars: list[str] | None = None) -> str:
+    """Resolve GitHub token from environment variables or gh CLI.
+
+    Checks environment variables in order of preference, returning the first
+    non-empty value found. If no environment variables are set, attempts to
+    get a token from the gh CLI tool using 'gh auth token'.
+
+    Args:
+        preferred_env_vars: List of environment variable names to check in order.
+            Defaults to ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"].
+
+    Returns:
+        GitHub token string.
+
+    Raises:
+        ValueError: If no GitHub token is found in env vars or gh CLI.
+    """
+    if preferred_env_vars is None:
+        preferred_env_vars = ["GITHUB_CI_WORKFLOW_TRIGGER_PAT", "GITHUB_TOKEN"]
+
+    # Check environment variables first
+    for env_var in preferred_env_vars:
+        token = os.getenv(env_var)
+        if token:
+            return token
+
+    # Fall back to gh CLI if available
+    gh_path = shutil.which("gh")
+    if gh_path:
+        try:
+            result = subprocess.run(
+                [gh_path, "auth", "token"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            pass
+
+    env_var_list = ", ".join(preferred_env_vars)
+    raise ValueError(
+        f"No GitHub token found. Set one of: {env_var_list} environment variable, "
+        "or authenticate with 'gh auth login'."
+    )
+
+
+@dataclass
+class PRHeadInfo:
+    """Information about a PR's head commit."""
+
+    ref: str
+    """Branch name of the PR's head"""
+
+    sha: str
+    """Full commit SHA of the PR's head"""
+
+    short_sha: str
+    """First 7 characters of the commit SHA"""
+
+
+def get_pr_head_ref(
+    owner: str,
+    repo: str,
+    pr_number: int,
+    token: str,
+) -> PRHeadInfo:
+    """Get the head ref (branch name) and SHA for a PR.
+
+    This is useful for resolving a PR number to the actual branch name,
+    which is required for workflow_dispatch API calls (which don't accept
+    refs/pull/{pr}/head format).
+
+    Args:
+        owner: Repository owner (e.g., "airbytehq")
+        repo: Repository name (e.g., "airbyte")
+        pr_number: Pull request number
+        token: GitHub API token
+
+    Returns:
+        PRHeadInfo with ref (branch name), sha, and short_sha.
+
+    Raises:
+        ValueError: If PR not found.
+        requests.HTTPError: If API request fails.
+    """
+    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/pulls/{pr_number}"
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+
+    response = requests.get(url, headers=headers, timeout=30)
+    if response.status_code == 404:
+        raise ValueError(f"PR {owner}/{repo}#{pr_number} not found")
+    response.raise_for_status()
+
+    pr_data = response.json()
+    sha = pr_data["head"]["sha"]
+    return PRHeadInfo(
+        ref=pr_data["head"]["ref"],
+        sha=sha,
+        short_sha=sha[:7],
+    )
+
+
+def get_file_contents_at_ref(
+    owner: str,
+    repo: str,
+    path: str,
+    ref: str,
+    token: str | None = None,
+) -> str | None:
+    """Fetch file contents from GitHub at a specific ref.
+
+    Uses the GitHub Contents API to retrieve file contents at a specific
+    commit SHA, branch, or tag. This allows reading files without having
+    the repository checked out locally.
+
+    Args:
+        owner: Repository owner (e.g., "airbytehq")
+        repo: Repository name (e.g., "airbyte")
+        path: Path to the file within the repository
+        ref: Git ref (commit SHA, branch name, or tag)
+        token: GitHub API token (optional for public repos, but recommended
+            to avoid rate limiting)
+
+    Returns:
+        File contents as a string, or None if the file doesn't exist.
+
+    Raises:
+        requests.HTTPError: If API request fails (except 404).
+    """
+    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/contents/{path}"
+    headers = {
+        "Accept": "application/vnd.github.raw+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    params = {"ref": ref}
+
+    response = requests.get(url, headers=headers, params=params, timeout=30)
+    if response.status_code == 404:
+        return None
+    response.raise_for_status()
+
+    return response.text
 
 
 class GitHubCommentParseError(Exception):

airbyte_ops_mcp/mcp/{github.py → github_actions.py}

@@ -15,12 +15,22 @@ from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
 from airbyte_ops_mcp.github_actions import (
-    GITHUB_API_BASE,
     get_workflow_jobs,
+    trigger_workflow_dispatch,
+)
+from airbyte_ops_mcp.github_api import (
+    GITHUB_API_BASE,
+    get_pr_head_ref,
     resolve_github_token,
 )
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
+# Token env vars for workflow triggering (in order of preference)
+WORKFLOW_TRIGGER_TOKEN_ENV_VARS = [
+    "GITHUB_CI_WORKFLOW_TRIGGER_PAT",
+    "GITHUB_TOKEN",
+]
+
 DOCKERHUB_API_BASE = "https://hub.docker.com/v2"
 
 
@@ -36,7 +46,7 @@ class JobInfo(BaseModel):
 
 
 class WorkflowRunStatus(BaseModel):
-    """Response model for check_workflow_status MCP tool."""
+    """Response model for check_ci_workflow_status MCP tool."""
 
     run_id: int
     status: str
@@ -116,7 +126,7 @@ def _get_workflow_run(
     idempotent=True,
     open_world=True,
 )
-def check_workflow_status(
+def check_ci_workflow_status(
     workflow_url: Annotated[
         str | None,
         Field(
@@ -196,6 +206,108 @@ def check_workflow_status(
     )
 
 
+class TriggerCIWorkflowResult(BaseModel):
+    """Response model for trigger_ci_workflow MCP tool."""
+
+    success: bool
+    message: str
+    workflow_url: str
+    run_id: int | None = None
+    run_url: str | None = None
+
+
+@mcp_tool(
+    read_only=False,
+    idempotent=False,
+    open_world=True,
+)
+def trigger_ci_workflow(
+    owner: Annotated[
+        str,
+        Field(description="Repository owner (e.g., 'airbytehq')"),
+    ],
+    repo: Annotated[
+        str,
+        Field(description="Repository name (e.g., 'airbyte')"),
+    ],
+    workflow_file: Annotated[
+        str,
+        Field(description="Workflow file name (e.g., 'connector-regression-test.yml')"),
+    ],
+    workflow_definition_ref: Annotated[
+        str | None,
+        Field(
+            description="Branch name or PR number for the workflow definition to use. "
+            "If a PR number (integer string) is provided, it resolves to the PR's head branch name. "
+            "If a branch name is provided, it is used directly. "
+            "Defaults to the repository's default branch if not specified."
+        ),
+    ] = None,
+    inputs: Annotated[
+        dict[str, str] | None,
+        Field(
+            description="Workflow inputs as a dictionary of string key-value pairs. "
+            "These are passed to the workflow_dispatch event."
+        ),
+    ] = None,
+) -> TriggerCIWorkflowResult:
+    """Trigger a GitHub Actions CI workflow via workflow_dispatch.
+
+    This tool triggers a workflow in any GitHub repository that has workflow_dispatch
+    enabled. It resolves PR numbers to branch names automatically since GitHub's
+    workflow_dispatch API only accepts branch names, not refs/pull/{pr}/head format.
+
+    Requires GITHUB_CI_WORKFLOW_TRIGGER_PAT or GITHUB_TOKEN environment variable
+    with 'actions:write' permission.
+    """
+    # Guard: Check for required token
+    token = resolve_github_token(WORKFLOW_TRIGGER_TOKEN_ENV_VARS)
+
+    # Resolve workflow definition ref
+    # If a PR number is provided (integer string), resolve to the PR's head branch name
+    # Otherwise use the provided branch name or default to repo's default branch
+    if workflow_definition_ref:
+        if workflow_definition_ref.isdigit():
+            # Resolve PR number to branch name via GitHub API
+            pr_head_info = get_pr_head_ref(
+                owner,
+                repo,
+                int(workflow_definition_ref),
+                token,
+            )
+            resolved_ref = pr_head_info.ref
+        else:
+            resolved_ref = workflow_definition_ref
+    else:
+        # Default to main (most common default branch)
+        resolved_ref = "main"
+
+    # Trigger the workflow
+    result = trigger_workflow_dispatch(
+        owner=owner,
+        repo=repo,
+        workflow_file=workflow_file,
+        ref=resolved_ref,
+        inputs=inputs or {},
+        token=token,
+        find_run=True,
+    )
+
+    # Build response message
+    if result.run_id:
+        message = f"Successfully triggered workflow {workflow_file} on {owner}/{repo} (ref: {resolved_ref}). Run ID: {result.run_id}"
+    else:
+        message = f"Successfully triggered workflow {workflow_file} on {owner}/{repo} (ref: {resolved_ref}). Run ID not yet available."
+
+    return TriggerCIWorkflowResult(
+        success=True,
+        message=message,
+        workflow_url=result.workflow_url,
+        run_id=result.run_id,
+        run_url=result.run_url,
+    )
+
+
 class DockerImageInfo(BaseModel):
     """Response model for get_docker_image_info MCP tool."""
 
@@ -282,8 +394,8 @@ def get_docker_image_info(
     )
 
 
-def register_github_tools(app: FastMCP) -> None:
-    """Register GitHub tools with the FastMCP app.
+def register_github_actions_tools(app: FastMCP) -> None:
+    """Register GitHub Actions tools with the FastMCP app.
 
     Args:
         app: FastMCP application instance

airbyte_ops_mcp/mcp/prerelease.py

@@ -18,7 +18,11 @@ import yaml
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
-from airbyte_ops_mcp.github_actions import GITHUB_API_BASE, resolve_github_token
+from airbyte_ops_mcp.github_api import (
+    GITHUB_API_BASE,
+    get_pr_head_ref,
+    resolve_github_token,
+)
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 
 
@@ -87,14 +91,6 @@ def compute_prerelease_docker_image_tag(base_version: str, sha: str) -> str:
     return f"{base_version}-{PRERELEASE_TAG_PREFIX}.{short_sha}"
 
 
-class PRHeadInfo(BaseModel):
-    """Information about a PR's head commit."""
-
-    ref: str
-    sha: str
-    short_sha: str
-
-
 class PrereleaseWorkflowResult(BaseModel):
     """Response model for publish_connector_to_airbyte_registry MCP tool."""
 
@@ -107,47 +103,6 @@ class PrereleaseWorkflowResult(BaseModel):
     docker_image_tag: str | None = None
 
 
-def _get_pr_head_info(
-    owner: str,
-    repo: str,
-    pr_number: int,
-    token: str,
-) -> PRHeadInfo:
-    """Get the head ref and SHA for a PR.
-
-    Args:
-        owner: Repository owner (e.g., "airbytehq")
-        repo: Repository name (e.g., "airbyte")
-        pr_number: Pull request number
-        token: GitHub API token
-
-    Returns:
-        PRHeadInfo with ref, sha, and short_sha.
-
-    Raises:
-        ValueError: If PR not found or API error.
-    """
-    url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/pulls/{pr_number}"
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-
-    response = requests.get(url, headers=headers, timeout=30)
-    if response.status_code == 404:
-        raise ValueError(f"PR {owner}/{repo}#{pr_number} not found")
-    response.raise_for_status()
-
-    pr_data = response.json()
-    sha = pr_data["head"]["sha"]
-    return PRHeadInfo(
-        ref=pr_data["head"]["ref"],
-        sha=sha,
-        short_sha=sha[:7],
-    )
-
-
 def _get_connector_metadata(
     owner: str,
     repo: str,
@@ -305,16 +260,13 @@ def publish_connector_to_airbyte_registry(
 
     # Get the PR's head SHA for computing the docker image tag
     # Note: We no longer pass gitref to the workflow - it derives the ref from PR number
-    head_info = _get_pr_head_info(
-        DEFAULT_REPO_OWNER, target_repo_name, pr_number, token
-    )
+    head_info = get_pr_head_ref(DEFAULT_REPO_OWNER, target_repo_name, pr_number, token)
 
     # Prepare workflow inputs
-    # The workflow uses refs/pull/{pr}/head directly - no gitref needed
-    # Note: The workflow auto-detects modified connectors from the PR
     workflow_inputs = {
         "repo": f"{DEFAULT_REPO_OWNER}/{target_repo_name}",
         "pr": str(pr_number),
+        "connector": connector_name,
     }
 
     # Trigger the workflow on the default branch

airbyte_ops_mcp/mcp/regression_tests.py

@@ -31,11 +31,8 @@ from airbyte.exceptions import (
 from fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
-from airbyte_ops_mcp.github_actions import (
-    GITHUB_API_BASE,
-    resolve_github_token,
-    trigger_workflow_dispatch,
-)
+from airbyte_ops_mcp.github_actions import trigger_workflow_dispatch
+from airbyte_ops_mcp.github_api import GITHUB_API_BASE, resolve_github_token
 from airbyte_ops_mcp.mcp._mcp_utils import mcp_tool, register_mcp_tools
 from airbyte_ops_mcp.mcp.prerelease import ConnectorRepo
 
@@ -285,7 +282,7 @@ class RunRegressionTestsResponse(BaseModel):
     )
     github_run_id: int | None = Field(
         default=None,
-        description="GitHub Actions workflow run ID (use with check_workflow_status)",
+        description="GitHub Actions workflow run ID (use with check_ci_workflow_status)",
     )
     github_run_url: str | None = Field(
         default=None,
@@ -421,6 +418,7 @@ def run_regression_tests(
         workflow_inputs["override_control_image"] = override_control_image
 
     mode_description = "single-version" if skip_compare else "comparison"
+
     try:
         dispatch_result = trigger_workflow_dispatch(
             owner=REGRESSION_TEST_REPO_OWNER,

airbyte_ops_mcp/mcp/server.py

@@ -25,7 +25,7 @@ from airbyte_ops_mcp.mcp.cloud_connector_versions import (
     register_cloud_connector_version_tools,
 )
 from airbyte_ops_mcp.mcp.gcp_logs import register_gcp_logs_tools
-from airbyte_ops_mcp.mcp.github import register_github_tools
+from airbyte_ops_mcp.mcp.github_actions import register_github_actions_tools
 from airbyte_ops_mcp.mcp.github_repo_ops import register_github_repo_ops_tools
 from airbyte_ops_mcp.mcp.prerelease import register_prerelease_tools
 from airbyte_ops_mcp.mcp.prod_db_queries import register_prod_db_query_tools
@@ -59,7 +59,7 @@ def register_server_assets(app: FastMCP) -> None:
     """
     register_server_info_resources(app)
     register_github_repo_ops_tools(app)
-    register_github_tools(app)
+    register_github_actions_tools(app)
     register_prerelease_tools(app)
     register_cloud_connector_version_tools(app)
     register_prod_db_query_tools(app)

airbyte_ops_mcp/regression_tests/ci_output.py

@@ -171,7 +171,7 @@ def _get_github_artifacts_url() -> str | None:
     return f"{run_url}#artifacts"
 
 
-def generate_regression_report(
+def generate_action_test_comparison_report(
     target_image: str,
     control_image: str,
     command: str,
@@ -179,16 +179,17 @@ def generate_regression_report(
     control_result: dict[str, Any],
     output_dir: Path,
 ) -> Path:
-    """Generate a markdown regression test report modeled on legacy HTML reports.
+    """Generate a markdown comparison report for a single action (command).
 
     This creates a comprehensive report with context, message counts comparison,
-    and record counts per stream (for read commands). The structure mirrors the
-    legacy connector_live_tests HTML report.
+    and record counts per stream (for read commands). The report starts with an
+    L2 header containing the command name, making it easy to consolidate multiple
+    command reports into a single document.
 
     Args:
         target_image: The target (new version) connector image.
         control_image: The control (baseline version) connector image.
-        command: The Airbyte command that was run.
+        command: The Airbyte command that was run (e.g., "spec", "check", "discover", "read").
         target_result: Results dict from running target connector.
         control_result: Results dict from running control connector.
         output_dir: Directory to write the report to.
@@ -204,51 +205,22 @@ def generate_regression_report(
     target_record_counts = target_result.get("record_counts_per_stream", {})
     control_record_counts = control_result.get("record_counts_per_stream", {})
 
-    run_id = os.getenv("GITHUB_RUN_ID", "")
-    artifact_name = (
-        f"regression-test-artifacts-{run_id}" if run_id else "regression-test-artifacts"
-    )
-
+    # Extract version tags for the summary table
     target_version = (
         target_image.rsplit(":", 1)[-1] if ":" in target_image else "unknown"
     )
     control_version = (
         control_image.rsplit(":", 1)[-1] if ":" in control_image else "unknown"
     )
-    connector_name = (
-        target_image.rsplit(":", 1)[0] if ":" in target_image else target_image
-    )
-
-    run_url = _get_github_run_url()
-    artifacts_url = _get_github_artifacts_url()
 
+    # Start with L2 header containing the command name (no L1 header)
+    # This allows multiple command reports to be concatenated into a single document
+    # Note: Context block (connector, versions, workflow links) is added at the workflow level
     lines: list[str] = [
-        "# Regression Test Report",
-        "",
-        "## Context",
+        f"## `{command.upper()}` Test Results",
         "",
-        f"- **Test Date:** {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}",
-        f"- **Connector:** `{connector_name}`",
-        f"- **Control Version:** `{control_version}`",
-        f"- **Target Version:** `{target_version}`",
-        f"- **Command:** `{command.upper()}`",
     ]
 
-    if run_url:
-        lines.append(f"- **Workflow Run:** [View Execution]({run_url})")
-    if artifacts_url:
-        lines.append(f"- **Artifacts:** [Download `{artifact_name}`]({artifacts_url})")
-    else:
-        lines.append(f"- **Artifacts:** `{artifact_name}`")
-
-    lines.extend(
-        [
-            "",
-            "## Summary",
-            "",
-        ]
-    )
-
     if regression_detected:
         if target_result["success"] and not control_result["success"]:
             lines.append("**Result:** Target succeeded, control failed (improvement)")
@@ -261,20 +233,24 @@ def generate_regression_report(
     else:
         lines.append("**Result:** Both versions failed")
 
+    # Use emojis for better scanability
+    control_emoji = "✅" if control_result["success"] else "❌"
+    target_emoji = "✅" if target_result["success"] else "❌"
+
     lines.extend(
         [
             "",
-            "| Version | Exit Code | Success |",
-            "|---------|-----------|---------|",
-            f"| Control ({control_version}) | {control_result['exit_code']} | {control_result['success']} |",
-            f"| Target ({target_version}) | {target_result['exit_code']} | {target_result['success']} |",
+            "| Version | Exit Code | Result |",
+            "|---------|-----------|--------|",
+            f"| Control (`{control_version}`) | {control_result['exit_code']} | {control_emoji} |",
+            f"| Target (`{target_version}`) | {target_result['exit_code']} | {target_emoji} |",
             "",
         ]
     )
 
     lines.extend(
         [
-            "## Command Execution Metrics",
+            "### Command Execution Metrics",
             "",
         ]
     )
@@ -282,7 +258,7 @@ def generate_regression_report(
     if target_counts or control_counts:
         lines.extend(
             [
-                "### Message Types",
+                "#### Message Types",
                 "",
                 "| Type | Control | Target | Delta |",
                 "|------|---------|--------|-------|",
@@ -294,14 +270,14 @@ def generate_regression_report(
             target_count = target_counts.get(msg_type, 0)
             delta = target_count - control_count
             lines.append(
-                f"| {msg_type} | {control_count} | {target_count} | {_format_delta(delta)} |"
+                f"| `{msg_type}` | {control_count} | {target_count} | {_format_delta(delta)} |"
             )
         lines.append("")
 
     if target_record_counts or control_record_counts:
         lines.extend(
             [
-                "### Record Count per Stream",
+                "#### Record Count per Stream",
                 "",
                 "| Stream | Control | Target | Delta |",
                 "|--------|---------|--------|-------|",
@@ -330,7 +306,7 @@ def generate_regression_report(
     if control_http or target_http:
         lines.extend(
             [
-                "### HTTP Metrics",
+                "#### HTTP Metrics",
                 "",
                 "| Version | Flow Count | Duplicate Flows |",
                 "|---------|------------|-----------------|",
@@ -340,25 +316,130 @@ def generate_regression_report(
             ]
         )
 
+    # Note: Execution Details section removed as redundant with Summary table
+
+    report_content = "\n".join(lines)
+    report_path = output_dir / "report.md"
+    report_path.write_text(report_content)
+
+    return report_path
+
+
+# Backwards-compatible alias for the old function name
+generate_regression_report = generate_action_test_comparison_report
+
+
+def generate_single_version_report(
+    connector_image: str,
+    command: str,
+    result: dict[str, Any],
+    output_dir: Path,
+) -> Path:
+    """Generate a markdown report for a single-version regression test.
+
+    This creates a report with message counts and record counts per stream for a single
+    connector run. The report starts with an L2 header containing the command name,
+    making it easy to consolidate multiple command reports.
+
+    Args:
+        connector_image: The connector image that was tested.
+        command: The Airbyte command that was run (e.g., "spec", "check", "discover", "read").
+        result: Results dict from running the connector.
+        output_dir: Directory to write the report to.
+
+    Returns:
+        Path to the generated report.md file.
+    """
+    message_counts = result.get("message_counts", {})
+    record_counts = result.get("record_counts_per_stream", {})
+
+    run_id = os.getenv("GITHUB_RUN_ID", "")
+    artifact_name = (
+        f"regression-test-artifacts-{command}-{run_id}"
+        if run_id
+        else f"regression-test-artifacts-{command}"
+    )
+
+    version = (
+        connector_image.rsplit(":", 1)[-1] if ":" in connector_image else "unknown"
+    )
+    connector_name = (
+        connector_image.rsplit(":", 1)[0] if ":" in connector_image else connector_image
+    )
+
+    run_url = _get_github_run_url()
+    artifacts_url = _get_github_artifacts_url()
+
+    # Start with L2 header containing the command name (no L1 header)
+    lines: list[str] = [
+        f"## `{command.upper()}` Test Results",
+        "",
+        "### Context",
+        "",
+        f"- **Test Date:** {datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}",
+        f"- **Connector:** `{connector_name}`",
+        f"- **Version:** `{version}`",
+        f"- **Command:** `{command.upper()}`",
+    ]
+
+    if run_url:
+        lines.append(f"- **Workflow Run:** [View Execution]({run_url})")
+    if artifacts_url:
+        lines.append(f"- **Artifacts:** [Download `{artifact_name}`]({artifacts_url})")
+    else:
+        lines.append(f"- **Artifacts:** `{artifact_name}`")
+
     lines.extend(
         [
-            "## Execution Details",
             "",
-            "### Control",
+            "### Summary",
+            "",
+            f"**Result:** {'PASS' if result['success'] else 'FAIL'}",
             "",
-            f"- **Image:** `{control_image}`",
-            f"- **Exit Code:** {control_result['exit_code']}",
-            f"- **Success:** {control_result['success']}",
-            f"- **Stdout:** `{control_result.get('stdout_file', 'N/A')}`",
-            f"- **Stderr:** `{control_result.get('stderr_file', 'N/A')}`",
+            f"- **Exit Code:** {result['exit_code']}",
+            f"- **Success:** {result['success']}",
             "",
-            "### Target",
+        ]
+    )
+
+    if message_counts:
+        lines.extend(
+            [
+                "### Message Types",
+                "",
+                "| Type | Count |",
+                "|------|-------|",
+            ]
+        )
+        for msg_type in sorted(message_counts.keys()):
+            count = message_counts[msg_type]
+            lines.append(f"| `{msg_type}` | {count} |")
+        lines.append("")
+
+    if record_counts:
+        lines.extend(
+            [
+                "### Record Count per Stream",
+                "",
+                "| Stream | Count |",
+                "|--------|-------|",
+            ]
+        )
+        total = 0
+        for stream in sorted(record_counts.keys()):
+            count = record_counts[stream]
+            total += count
+            lines.append(f"| {stream} | {count} |")
+        lines.append(f"| **Total** | **{total}** |")
+        lines.append("")
+
+    lines.extend(
+        [
+            "### Execution Details",
             "",
-            f"- **Image:** `{target_image}`",
-            f"- **Exit Code:** {target_result['exit_code']}",
-            f"- **Success:** {target_result['success']}",
-            f"- **Stdout:** `{target_result.get('stdout_file', 'N/A')}`",
-            f"- **Stderr:** `{target_result.get('stderr_file', 'N/A')}`",
+            f"- **Image:** `{connector_image}`",
+            f"- **Stdout:** `{result.get('stdout_file', 'N/A')}`",
+            f"- **Stderr:** `{result.get('stderr_file', 'N/A')}`",
             "",
         ]
     )
@@ -373,9 +454,6 @@ def generate_regression_report(
 def get_report_summary(report_path: Path) -> str:
     """Get a brief summary pointing to the full report.
 
-    Args:
-        report_path: Path to the full report.md file.
-
     Returns:
         Brief markdown summary for GITHUB_STEP_SUMMARY.
     """
@@ -393,7 +471,5 @@ def get_report_summary(report_path: Path) -> str:
 
     return f"""## Regression Test Report
 
-Full report available in the **Regression Test Report** check or in artifact {artifact_link}.
-
-See the Checks tab for the complete report with message counts and execution details.
+Full report available in artifact {artifact_link}.
 """