agentic-devtools 0.2.33__tar.gz → 0.2.35__tar.gz

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.33
+Version: 0.2.35
 Summary: AI assistant helper commands for the Dragonfly platform
 Author: Dragonfly Team
 License-Expression: MIT

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.33'
-__version_tuple__ = version_tuple = (0, 2, 33)
+__version__ = version = '0.2.35'
+__version_tuple__ = version_tuple = (0, 2, 35)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/azure_devops/commands.py

@@ -27,6 +27,7 @@ from .helpers import (
     get_repository_id,
     parse_bool_from_state_value,
     parse_json_response,
+    patch_comment,
     print_threads,
     require_requests,
     resolve_thread_by_id,
@@ -36,51 +37,8 @@ from .pull_request_details_commands import (
     _get_pull_request_iterations,
     get_change_tracking_id_for_file,
 )
-
-OVERALL_PR_SUMMARY_HEADING = "## Overall PR Review Summary"
-
-
-def _find_summary_thread_id(
-    requests, headers: Dict[str, str], config: AzureDevOpsConfig, repo_id: str, pull_request_id: int
-) -> Optional[int]:
-    """Find the thread ID of the 'Overall PR Review Summary' thread.
-
-    Checks review-state.json first to get the current review's thread ID,
-    avoiding stale threads from previous reviews of the same PR.
-    Falls back to searching all PR threads when review-state.json is unavailable.
-    """
-    # Prefer the thread ID recorded in review-state.json for this PR,
-    # which is guaranteed to belong to the current review session.
-    try:
-        from .review_state import load_review_state
-
-        review_state = load_review_state(pull_request_id)
-        if review_state.overallSummary and review_state.overallSummary.threadId:
-            return review_state.overallSummary.threadId
-    except (FileNotFoundError, KeyError, AttributeError, OSError, ValueError):
-        pass
-
-    # Fallback: search all threads (may match stale threads from previous reviews)
-    threads_url = config.build_api_url(repo_id, "pullRequests", pull_request_id, "threads")
-    try:
-        response = requests.get(threads_url, headers=headers, timeout=30)
-        response.raise_for_status()
-    except Exception as e:
-        print(f"Warning: Could not search for summary thread: {e}", file=sys.stderr)
-        return None
-    threads = response.json().get("value", [])
-    for thread in threads:
-        for comment in thread.get("comments", []):
-            if OVERALL_PR_SUMMARY_HEADING in (comment.get("content") or ""):
-                thread_id = thread.get("id")
-                if thread_id is None:
-                    print(
-                        "Warning: Found summary thread without an 'id' field; skipping.",
-                        file=sys.stderr,
-                    )
-                    break
-                return thread_id
-    return None
+from .review_state import load_review_state, save_review_state
+from .review_templates import render_overall_summary
 
 
 def _extract_issue_key_from_branch(branch_name: str) -> Optional[str]:
@@ -205,6 +163,44 @@ def reply_to_pull_request_thread() -> None:
         print(f"Thread {thread_id} resolved")
 
 
+def update_review_narrative(pull_request_id: int, content: str) -> None:
+    """Update the Review Narrative in the existing overall PR summary comment in-place.
+
+    Loads the review state for ``pull_request_id``, sets ``narrativeSummary`` to
+    ``content``, re-renders the overall summary, and PATCHes the existing summary
+    comment.  Saves the updated state on success.
+
+    Raises:
+        FileNotFoundError: When review-state.json does not exist for the PR.
+        Exception: For any API or state I/O failure (caller should handle).
+    """
+    from .review_scaffold import build_pr_base_url
+
+    requests = require_requests()
+    config = AzureDevOpsConfig.from_state()
+    pat = get_pat()
+    headers = get_auth_headers(pat)
+
+    review_state = load_review_state(pull_request_id)
+    repo_id = getattr(review_state, "repoId", None)
+    if repo_id:
+        print(f"Using repository ID from review state: {repo_id}")
+    else:
+        print(f"Resolving repository ID for '{config.repository}'...")
+        repo_id = get_repository_id(config.organization, config.project, config.repository)
+
+    review_state.overallSummary.narrativeSummary = content
+    base_url = build_pr_base_url(config, pull_request_id)
+    new_content = render_overall_summary(review_state, base_url)
+
+    thread_id = review_state.overallSummary.threadId
+    comment_id = review_state.overallSummary.commentId
+    print(f"Updating overall PR summary comment (thread {thread_id}, comment {comment_id})...")
+    patch_comment(requests, headers, config, repo_id, pull_request_id, thread_id, comment_id, new_content)
+    save_review_state(review_state)
+    print("Review Narrative updated successfully.")
+
+
 def add_pull_request_comment() -> None:
     """
     Add a new comment to a pull request.
@@ -215,10 +211,6 @@ def add_pull_request_comment() -> None:
     - path (optional): File path for file-level comment
     - line (optional): Line number for line-level comment
     - end_line (optional): End line for multi-line comment
-    - is_pull_request_approval (optional): Whether this is an approval comment.
-          When True and no ``path`` is provided, replies to the existing summary
-          thread instead of creating a new thread.  When ``path`` is set, a normal
-          file-level comment is created regardless of this flag.
     - leave_thread_active (optional): Whether to keep thread active (default: resolve after posting)
     - dry_run (optional): Preview without making API calls
 
@@ -231,10 +223,6 @@ def add_pull_request_comment() -> None:
         agdt-set path "src/main.py"
         agdt-set line 42
         agdt-add-pull-request-comment
-
-        # For approval comment
-        agdt-set is_pull_request_approval true
-        agdt-add-pull-request-comment
     """
     requests = require_requests()
 
@@ -242,10 +230,9 @@ def add_pull_request_comment() -> None:
     content = require_content()
 
     dry_run = is_dry_run()
-    is_approval = parse_bool_from_state("is_pull_request_approval", default=False)
     leave_thread_active = parse_bool_from_state("leave_thread_active", default=False)
 
-    # Optional file context (used for both regular and file-level approval comments)
+    # Optional file context
     path = get_value("path")
     line = get_value("line")
     end_line = get_value("end_line")
@@ -258,9 +245,6 @@ def add_pull_request_comment() -> None:
             line_info = f", Line: {line}" if line else ""
             end_line_info = f"-{end_line}" if end_line else ""
             print(f"[DRY RUN] File: {path}{line_info}{end_line_info}")
-        if is_approval:
-            if not path:
-                print("[DRY RUN] Will reply to existing summary thread if found, otherwise create new thread")
         if not leave_thread_active:
             print("[DRY RUN] Would also resolve the thread after posting")
         print(f"Content:\n{content}")
@@ -272,24 +256,6 @@ def add_pull_request_comment() -> None:
     print(f"Resolving repository ID for '{config.repository}'...")
     repo_id = get_repository_id(config.organization, config.project, config.repository)
 
-    # For PR-level approval comments (no file path), try to reply to the existing summary thread
-    if is_approval and not path:
-        summary_thread_id = _find_summary_thread_id(requests, headers, config, repo_id, pull_request_id)
-        if summary_thread_id:
-            try:
-                comment_url = config.build_api_url(
-                    repo_id, "pullRequests", pull_request_id, "threads", summary_thread_id, "comments"
-                )
-                comment_body = {"content": content, "commentType": "text"}
-                print(f"Posting approval to existing summary thread {summary_thread_id}...")
-                response = requests.post(comment_url, headers=headers, json=comment_body, timeout=30)
-                response.raise_for_status()
-                result = response.json()
-                print(f"Approval reply added (comment ID: {result.get('id')}, thread: {summary_thread_id})")
-                return
-            except Exception as e:
-                print(f"Warning: Could not reply to summary thread, creating new thread: {e}", file=sys.stderr)
-
     # Build thread context for file-level comments
     thread_context = build_thread_context(path, line, end_line)
 
@@ -593,11 +559,11 @@ def get_pull_request_threads() -> None:
 
 def approve_pull_request() -> None:
     """
-    Approve a pull request by posting an approval comment.
+    Approve a pull request by updating the Review Narrative in the overall summary comment.
 
-    This is a convenience wrapper around add_pull_request_comment that automatically
-    sets is_pull_request_approval=True and posts the content as a reply to the
-    existing summary thread (when found), or as a new thread otherwise.
+    Attempts to update the ``narrativeSummary`` field in the existing overall PR summary
+    comment in-place via ``update_review_narrative()``.  Falls back to creating a new
+    PR-level comment thread when review-state.json is unavailable or the update fails.
 
     Reads from state:
     - pull_request_id (required): Pull request ID
@@ -609,13 +575,28 @@ def approve_pull_request() -> None:
         agdt-set content "LGTM! All acceptance criteria met."
         agdt-approve-pull-request
     """
-    # Set approval mode and clear any stale file context from previous file-review
-    # operations, so the approval posts as a PR-level comment, not a file-level one.
-    set_value("is_pull_request_approval", True)
+    pull_request_id = get_pull_request_id(required=True)
+    content = require_content()
+    dry_run = is_dry_run()
+
+    if dry_run:
+        print(f"[DRY RUN] Would update Review Narrative for PR {pull_request_id}")
+        print(f"Content:\n{content}")
+        return
+
+    # Clear stale file context so fallback add_pull_request_comment posts as PR-level
     delete_value("path")
     delete_value("line")
     delete_value("end_line")
-    add_pull_request_comment()
+
+    try:
+        update_review_narrative(pull_request_id, content)
+    except Exception as exc:
+        print(
+            f"Warning: Could not update Review Narrative ({exc}); falling back to new comment.",
+            file=sys.stderr,
+        )
+        add_pull_request_comment()
 
 
 def mark_pull_request_draft() -> None:

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/azure_devops/review_commands.py

@@ -717,15 +717,25 @@ def setup_pull_request_review() -> None:
 
         from ...state import set_bootstrap_state
 
-        set_bootstrap_state(worktree_key=f"PR{pull_request_id}")
+        # Normalize Jira issue key once and use consistently for scoping and state.
+        if isinstance(jira_issue_key, str):
+            jira_issue_key_norm = jira_issue_key.strip() or None
+        else:
+            jira_issue_key_norm = None
+
+        # Ensure all subsequent uses in this function see the normalized value.
+        jira_issue_key = jira_issue_key_norm
+
+        worktree_key = jira_issue_key if jira_issue_key else f"PR{pull_request_id}"
+        set_bootstrap_state(worktree_key=worktree_key)
 
         # Re-set context keys that were read from the old (_unscoped) state
         # directory.  set_bootstrap_state() may have changed the resolved
         # state dir, so downstream commands (e.g., get_pull_request_details)
         # that call get_value() would find an empty scoped state.json.
         set_value("pull_request_id", str(pull_request_id))
-        if jira_issue_key:
-            set_value("jira.issue_key", jira_issue_key)
+        if jira_issue_key_norm:
+            set_value("jira.issue_key", jira_issue_key_norm)
         if include_reviewed:
             set_value("include_reviewed", "true")
         if review_model_id:

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/azure_devops/review_scaffold.py

@@ -22,6 +22,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import quote
 
 from .config import AzureDevOpsConfig
+from .helpers import patch_thread_status
 from .review_attribution import build_commit_file_url, build_commit_pr_url
 from .review_state import (
     FileEntry,
@@ -1078,6 +1079,20 @@ def _fresh_scaffold(
     except Exception as exc:
         print(f"Warning: Could not post initial activity log entry: {exc}", file=sys.stderr)
 
+    # Always resolve the activity log thread so it doesn't block merging
+    try:
+        patch_thread_status(
+            requests_module=requests_module,
+            headers=headers,
+            config=config,
+            repo_id=repo_id,
+            pull_request_id=pull_request_id,
+            thread_id=activity_log_thread_id,
+            status="closed",
+        )
+    except Exception as exc:
+        print(f"Warning: Could not resolve activity log thread: {exc}", file=sys.stderr)
+
     print(f"Scaffolding complete. Review state saved for PR {pull_request_id}.")
     return review_state
 

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/azure_devops/review_templates.py

@@ -4,7 +4,7 @@ Provides functions to generate and regenerate full markdown content for
 file summaries and the overall PR summary at each status.
 """
 
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 
 from .review_attribution import format_status, render_attribution_line
 from .review_state import (
@@ -48,14 +48,6 @@ def build_discussion_url(base_url: str, thread_id: int, comment_id: int) -> str:
     return f"{base_url}?discussionId={thread_id}&commentId={comment_id}"
 
 
-def _file_display_path(file_entry: FileEntry) -> str:
-    """Get the display path for a file entry (e.g. /src/app.py)."""
-    folder = file_entry.folder
-    if not folder or folder.lower() == "root":
-        return f"/{file_entry.fileName}"
-    return f"/{folder}/{file_entry.fileName}"
-
-
 def _format_severity_counts(suggestions: List[SuggestionEntry]) -> str:
     """Format severity counts as a human-readable string (e.g. '2 High, 1 Medium')."""
     counts: Dict[str, int] = {"high": 0, "medium": 0, "low": 0}
@@ -162,7 +154,6 @@ def render_file_summary(
     Returns:
         Markdown string for the file review summary.
     """
-    complete_path = _file_display_path(file_entry)
     status = file_entry.status
     status_display = format_status(status, use_emoji=True)
 
@@ -176,8 +167,6 @@ def render_file_summary(
         lines += [attribution, ""]
 
     lines += [
-        f"*Complete Path:* {complete_path}",
-        "",
         f"*Status:* {status_display}",
         "",
         "### Summary of Changes",
@@ -257,8 +246,8 @@ def render_overall_summary(
     Returns:
         Markdown string for the overall PR review summary.
     """
-    # Build per-status, per-folder file groups: status → folder → [FileEntry]
-    status_folder_files: Dict[str, Dict[str, List[FileEntry]]] = {
+    # Build per-status, per-folder file groups: status → folder → [(full_path, FileEntry)]
+    status_folder_files: Dict[str, Dict[str, List[Tuple[str, FileEntry]]]] = {
         ReviewStatus.NEEDS_WORK.value: {},
         ReviewStatus.IN_PROGRESS.value: {},
         ReviewStatus.APPROVED.value: {},
@@ -266,12 +255,12 @@ def render_overall_summary(
     }
 
     known_statuses = set(status_folder_files.keys())
-    for fe in state.files.values():
+    for file_key, fe in state.files.items():
         # Normalize unknown statuses into the unreviewed bucket so every
         # file appears in a rendered section.
         status = fe.status if fe.status in known_statuses else ReviewStatus.UNREVIEWED.value
         folder = fe.folder if fe.folder else "root"
-        status_folder_files[status].setdefault(folder, []).append(fe)
+        status_folder_files[status].setdefault(folder, []).append((file_key, fe))
 
     # Overall status derived from file statuses, with the same unknown→unreviewed
     # normalization so the header status matches the rendered sections.
@@ -309,13 +298,12 @@ def render_overall_summary(
         lines.extend(["", f"### {section_title}"])
         for folder_name in sorted(folder_files.keys()):
             lines.append(f"- {folder_name}")
-            for fe in sorted(folder_files[folder_name], key=_file_display_path):
+            for file_key, fe in sorted(folder_files[folder_name], key=lambda x: x[0]):
                 # Use the section status for emoji so unknown statuses
                 # normalized into Unreviewed still get the ⏳ prefix.
                 file_emoji = _STATUS_EMOJI.get(status_val, "")
                 url = build_discussion_url(base_url, fe.threadId, fe.commentId)
-                display = _file_display_path(fe)
-                item = f"   - {file_emoji} [{display}]({url})"
+                item = f"   - {file_emoji} [{file_key}]({url})"
                 if status_val == ReviewStatus.NEEDS_WORK.value:
                     counts = _format_severity_counts(fe.suggestions)
                     if counts:

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/cert_utils.py

@@ -113,14 +113,21 @@ def ensure_ca_bundle(
 ) -> Optional[str]:
     """Ensure a CA bundle PEM file exists for *hostname* and return its path.
 
-    The certificate chain is fetched exactly once and cached.  Subsequent
-    calls return the cached path immediately when the cache contains at
-    least one certificate — even if only the server cert was available.
+    When a complete certificate chain is successfully fetched and written to
+    the cache file, subsequent calls return the cached path immediately as
+    long as the cache contains at least two certificates (leaf + at least
+    one CA).  Single-cert (leaf-only) caches are treated as invalid and
+    trigger a re-fetch, because a leaf certificate cannot validate itself
+    and will always fail SSL verification.
 
     On the *first* fetch the function prefers ``openssl`` (which usually
     retrieves the full chain including the root CA).  If ``openssl``
     fails to return any certificates, the :mod:`ssl` module is used as a
-    fallback to obtain at least the server certificate.
+    fallback — but since the :mod:`ssl` module can only retrieve the server
+    certificate (not the chain), a leaf-only result is **not** cached and
+    ``None`` is returned instead.  In any case where no complete chain can
+    be cached (because only a leaf certificate is available or the cache
+    file cannot be written), future calls may re-fetch the certificates.
 
     All certificate fetching targets port 443 (standard HTTPS).  For
     non-standard ports, use :func:`fetch_certificate_chain_openssl` or
@@ -133,7 +140,9 @@ def ensure_ca_bundle(
         force: When ``True``, delete any existing cached file and re-fetch.
 
     Returns:
-        Absolute path to the cached PEM file, or ``None`` if fetching failed.
+        Absolute path to the cached PEM file, or ``None`` if a complete chain
+        (leaf + at least one CA certificate) could not be obtained or the
+        cache file could not be written.
     """
     if cache_file is None:
         # Sanitize hostname to prevent path traversal (e.g. "../" in hostname).
@@ -145,37 +154,69 @@ def ensure_ca_bundle(
     if force and cache_file.exists():
         try:
             cache_file.unlink()
-        except OSError:
-            pass
-
-    # Return cached file when it already contains at least one certificate.
-    # We accept single-cert caches to avoid re-fetching on every call for
-    # hosts that only ever yield one cert (e.g. ssl-module fallback).
-    if cache_file.exists():
+        except OSError as exc:
+            # Even if deletion fails, skip using the existing cache when force=True.
+            print(
+                f"  ⚠ Could not delete CA bundle cache at {cache_file} during forced refresh: {exc}. "
+                "The existing file may still be referenced by external tools (for example, an npmrc cafile). "
+                "Consider removing or replacing it manually.",
+                file=sys.stderr,
+            )
+
+    # Return cached file only when it contains a full chain (>= 2 certs).
+    # A single-cert (leaf-only) cache cannot be used as a CA bundle and will
+    # always fail SSL verification, so treat it as invalid and re-fetch.
+    if cache_file.exists() and not force:
         try:
             existing = cache_file.read_text(encoding="utf-8")
         except (OSError, UnicodeDecodeError):
             # Treat unreadable or undecodable cache as missing and refetch.
             existing = ""
-        if count_certificates_in_pem(existing) >= 1:
+        if count_certificates_in_pem(existing) >= 2:
             return str(cache_file)
+        # Stale/leaf-only cache — remove it before refetching so it doesn't
+        # linger on disk and get picked up by external configs (e.g. npmrc cafile).
+        try:
+            cache_file.unlink()
+        except OSError as exc:
+            print(
+                f"  ⚠ Could not delete stale CA bundle cache at {cache_file}: {exc}. "
+                "The invalid file may still be referenced by external tools (for example, an npmrc cafile). "
+                "Consider removing or replacing it manually.",
+                file=sys.stderr,
+            )
 
     # Prefer openssl — it retrieves the full chain including the root CA
     cert_chain = fetch_certificate_chain_openssl(hostname)
     if cert_chain and count_certificates_in_pem(cert_chain) >= 2:
-        cache_file.parent.mkdir(parents=True, exist_ok=True)
-        cache_file.write_text(cert_chain, encoding="utf-8")
-        return str(cache_file)
-
-    # Fallback: ssl module (server cert only — may not work as a CA bundle)
+        try:
+            cache_file.parent.mkdir(parents=True, exist_ok=True)
+            cache_file.write_text(cert_chain, encoding="utf-8")
+            return str(cache_file)
+        except OSError as exc:
+            print(
+                f"  ⚠ Could not cache CA bundle for {hostname}: {exc}. Will use requests' default CA bundle.",
+                file=sys.stderr,
+            )
+            return None
+
+    # Fallback: ssl module (only if openssl returned nothing at all).
+    # The ssl module can only retrieve the server (leaf) certificate, not the
+    # full chain, so we only try it when openssl gave us nothing at all.
     if not cert_chain:
         cert_chain = fetch_certificate_chain_ssl(hostname)
 
-    if cert_chain:
-        cache_file.parent.mkdir(parents=True, exist_ok=True)
-        cache_file.write_text(cert_chain, encoding="utf-8")
-        return str(cache_file)
+    # If we only have a leaf cert (from either method), do not cache it.
+    # A leaf cert cannot validate itself, so it would always fail verification.
+    if cert_chain and count_certificates_in_pem(cert_chain) < 2:
+        print(
+            f"  ⚠ Only leaf certificate retrieved for {hostname}; "
+            "chain is incomplete. Will use requests' default CA bundle.",
+            file=sys.stderr,
+        )
+        return None
 
+    # cert_chain is None — both methods failed
     return None
 
 

{agentic_devtools-0.2.33 → agentic_devtools-0.2.35}/agentic_devtools/cli/copilot/auto_start.py

@@ -10,6 +10,7 @@ Responsibilities
 1. Validate ``--worktree-path`` is an existing directory — exit 1 if not.
 2. Check for the sentinel file — exit early (0) if already triggered.
 3. Check copilot CLI availability — exit 1 if unavailable (before creating sentinel).
+3b. Check ``agdt-advance-workflow`` reachability — exit 1 if not found on PATH.
 4. Build copilot args — exit 1 if the prompt exceeds argv limits.
 5. Create the sentinel file atomically (``O_CREAT|O_EXCL``) — exit 0 without
    starting a session if another process already created it (race-free guard).
@@ -24,6 +25,7 @@ from __future__ import annotations
 
 import argparse
 import os
+import shutil
 import subprocess
 import sys
 
@@ -85,6 +87,7 @@ def copilot_auto_start_cmd(argv: list[str] | None = None) -> None:
     2. Sentinel check — exit 0 immediately if already triggered (best-effort
        stale task cleanup first).
     3. Pre-flight: check copilot CLI availability; exit 1 if not available.
+    3b. Pre-flight: check ``agdt-advance-workflow`` reachability; exit 1 if not found.
     4. Build copilot args; exit 1 if prompt exceeds argv limits.
     5. Create sentinel file atomically (``O_CREAT|O_EXCL``); exit 0 without
        running if another concurrent invocation already created it.
@@ -155,6 +158,20 @@ def copilot_auto_start_cmd(argv: list[str] | None = None) -> None:
         )
         sys.exit(1)
 
+    # 3b. Pre-flight: bail out early if agdt-* CLI commands are not on PATH.
+    #     This check prevents a confusing "command not found" error inside the
+    #     Copilot session after it has already started.
+    if not shutil.which("agdt-advance-workflow"):
+        print(
+            "agdt-copilot-auto-start: error: agdt-advance-workflow not found on PATH; "
+            "agentic-devtools CLI commands are not available. "
+            "Ensure agentic-devtools is installed and the Scripts directory is on your PATH. "
+            "Install options: 'pip install agentic-devtools', 'pipx install agentic-devtools', "
+            "or see the managed install at $HOME/.agdt/bin (or %USERPROFILE%\\.agdt\\bin on Windows).",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
     # 4. Build copilot args — bail out early if the prompt exceeds argv length limits.
     copilot_args = build_copilot_args(start_prompt, interactive=True)
     if copilot_args is None:
@@ -217,8 +234,7 @@ def copilot_auto_start_cmd(argv: list[str] | None = None) -> None:
         sys.exit(1)
     except OSError as exc:
         print(
-            f"agdt-copilot-auto-start: error: failed to run Copilot CLI"
-            f" (worktree path: {worktree_path}): {exc}",
+            f"agdt-copilot-auto-start: error: failed to run Copilot CLI (worktree path: {worktree_path}): {exc}",
             file=sys.stderr,
         )
         try: