agentic-devtools 0.2.152__py3-none-any.whl → 0.2.154__py3-none-any.whl

agentic_devtools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.152'
-__version_tuple__ = version_tuple = (0, 2, 152)
+__version__ = version = '0.2.154'
+__version_tuple__ = version_tuple = (0, 2, 154)
 
 __commit_id__ = commit_id = None

agentic_devtools/cli/copilot/auto_start.py

@@ -49,11 +49,20 @@ _STATE_KEY = "copilot"
 _TRIGGERED_RUNS_KEY = "auto_start_triggered_runs"
 _MODEL_KEY = "model_id"
 
-# Retry constants for transient Windows file-lock errors (WinError 32).
+# Retry constants for transient Windows file-lock errors (WinError 32) and
+# rapid non-zero exit codes (batch wrapper fails because copilot.ps1 is locked).
 _RETRY_MAX_ATTEMPTS = 5  # retries (6 total tries)
 _RETRY_INITIAL_DELAY_S = 0.5  # first backoff delay in seconds
 _RETRY_BACKOFF_FACTOR = 2.0  # doubling
 _RETRY_MAX_DELAY_S = 4.0  # cap per delay in seconds
+_RAPID_FAILURE_THRESHOLD_S = 5.0  # exit within this = transient failure
+
+# Cleanup retry constants for transient Windows delete/write locks.
+_CLEANUP_RETRYABLE_WINERRORS = {5, 32, 110}
+_CLEANUP_MAX_RETRIES = 3
+_CLEANUP_INITIAL_DELAY_S = 0.1
+_CLEANUP_BACKOFF_FACTOR = 2.0
+_CLEANUP_MAX_DELAY_S = 0.8
 
 
 def _read_model_from_state(state_file_path: Path) -> str | None:
@@ -200,14 +209,35 @@ def _is_retryable_win_error(exc: OSError) -> bool:
     return getattr(exc, "winerror", None) == 32
 
 
+def _is_retryable_cleanup_win_error(exc: OSError) -> bool:
+    """Return ``True`` for transient Windows cleanup lock errors.
+
+    Covers common transient lock/access-denied cleanup failures:
+    - 5   (``ERROR_ACCESS_DENIED``)
+    - 32  (``ERROR_SHARING_VIOLATION``)
+    - 110 (``ERROR_OPEN_FAILED``)
+    """
+    return getattr(exc, "winerror", None) in _CLEANUP_RETRYABLE_WINERRORS
+
+
 def _run_copilot_with_retry(
     copilot_args: list[str],
     cwd: str,
 ) -> subprocess.CompletedProcess:
     """Run the Copilot CLI with retry logic for transient Windows file locks.
 
-    Wraps ``subprocess.run`` with exponential backoff retries specifically for
-    ``OSError`` with ``winerror == 32`` (Windows ``ERROR_SHARING_VIOLATION``).
+    Wraps ``subprocess.run`` with exponential backoff retries for two failure
+    modes:
+
+    1. ``OSError`` with ``winerror == 32`` (Windows ``ERROR_SHARING_VIOLATION``)
+       raised directly by ``subprocess.run`` when the binary itself is locked.
+    2. Rapid non-zero exit codes from Windows batch wrappers (process exits within
+       ``_RAPID_FAILURE_THRESHOLD_S`` seconds).  This handles the case where
+       a ``.bat`` wrapper starts successfully but the underlying script
+       (``copilot.ps1``) is locked by another process (e.g., the VS Code
+       Copilot Chat extension during activation).  The batch exits non-zero
+       almost immediately, which is distinguishable from a legitimate session
+       failure (which would take several seconds at minimum).
 
     Non-retryable errors (``FileNotFoundError``, other ``OSError`` variants)
     are re-raised immediately without retry.
@@ -217,7 +247,9 @@ def _run_copilot_with_retry(
         cwd: Working directory for the subprocess.
 
     Returns:
-        The ``CompletedProcess`` on success.
+        The ``CompletedProcess`` result from the final attempt. This may have
+        a non-zero ``returncode`` when retries are exhausted for rapid
+        non-zero exits from Windows batch wrappers.
 
     Raises:
         FileNotFoundError: If the binary or cwd is missing (not retried).
@@ -232,7 +264,36 @@ def _run_copilot_with_retry(
 
     for attempt in range(1, total_tries + 1):
         try:
-            return subprocess.run(copilot_args, cwd=cwd)  # noqa: S603
+            t0 = time.monotonic()
+            result = subprocess.run(copilot_args, cwd=cwd)  # noqa: S603
+            elapsed = time.monotonic() - t0
+
+            command_name = copilot_args[0].lower() if copilot_args else ""
+            is_batch_wrapper = command_name.endswith((".bat", ".cmd"))
+            # A rapid non-zero exit is only treated as transient for Windows
+            # batch wrappers, where .bat -> .ps1 handoff can fail while
+            # copilot.ps1 is temporarily locked by VS Code's extension.
+            if result.returncode != 0 and elapsed < _RAPID_FAILURE_THRESHOLD_S and is_batch_wrapper:
+                if attempt == total_tries:
+                    print(
+                        f"agdt-copilot-auto-start: error: retry budget exhausted "
+                        f"after {total_tries} attempts (rapid exit code "
+                        f"{result.returncode} in {elapsed:.1f}s)",
+                        file=sys.stderr,
+                    )
+                    return result
+                print(
+                    f"agdt-copilot-auto-start: warning: copilot exited rapidly "
+                    f"(code={result.returncode}, {elapsed:.1f}s < {_RAPID_FAILURE_THRESHOLD_S}s, "
+                    f"attempt {attempt}/{total_tries}), "
+                    f"retrying in {delay:.1f}s (likely transient batch-wrapper file lock)",
+                    file=sys.stderr,
+                )
+                time.sleep(delay)
+                delay = min(delay * _RETRY_BACKOFF_FACTOR, _RETRY_MAX_DELAY_S)
+                continue
+
+            return result
         except FileNotFoundError:
             raise
         except OSError as exc:
@@ -272,8 +333,9 @@ def _cleanup_auto_start_task(
     Delegates to :func:`~agentic_devtools.cli.vscode_tasks.remove_auto_start_task`.
 
     Errors are caught so that cleanup failure never changes the caller's exit
-    code.  Transient Windows file-lock errors (``winerror == 32``) emit a
-    warning to stderr; all other errors are silently ignored.
+    code. Transient Windows cleanup lock errors (``winerror`` in ``[5, 32, 110]``)
+    are retried up to 3 times with exponential backoff; all failures are
+    otherwise silently ignored.
 
     Args:
         worktree_path: Absolute path to the worktree directory.
@@ -288,25 +350,41 @@ def _cleanup_auto_start_task(
     """
     vscode_dir = os.path.join(worktree_path, ".vscode")
     tasks_path = os.path.join(vscode_dir, "tasks.json")
-    try:
-        remove_auto_start_task(
-            tasks_path,
-            vscode_dir,
-            task_label,
-            delete_if_empty=created_new,
-        )
-    except OSError as exc:
-        if _is_retryable_win_error(exc):
+    if _CLEANUP_MAX_RETRIES < 0:
+        return
+    attempts = _CLEANUP_MAX_RETRIES + 1
+    delay = _CLEANUP_INITIAL_DELAY_S
+    attempt = 1
+    while attempt <= attempts:  # pragma: no branch
+        try:
+            remove_auto_start_task(
+                tasks_path,
+                vscode_dir,
+                task_label,
+                delete_if_empty=created_new,
+            )
+            return
+        except OSError as exc:
+            if not _is_retryable_cleanup_win_error(exc) or attempt == attempts:
+                # Best-effort cleanup: any failure must not affect caller exit code.
+                return
             print(
                 f"agdt-copilot-auto-start: warning: cleanup encountered transient "
-                f"file lock (winerror=32), skipping: {exc}",
+                f"file lock (attempt {attempt}/{attempts}, "
+                f"winerror={getattr(exc, 'winerror', '?')}), "
+                f"retrying in {delay:.1f}s: {exc}",
                 file=sys.stderr,
             )
-        # Best-effort cleanup: any failure must not affect the caller's exit code.
-    except Exception:
-        # Best-effort cleanup: any failure must be silently ignored so it cannot
-        # affect the caller's exit code.
-        pass
+            try:
+                time.sleep(delay)
+            except KeyboardInterrupt:
+                return
+            delay = min(delay * _CLEANUP_BACKOFF_FACTOR, _CLEANUP_MAX_DELAY_S)
+            attempt += 1
+        except Exception:
+            # Best-effort cleanup: any failure must be silently ignored so it cannot
+            # affect the caller's exit code.
+            return
 
 
 def copilot_auto_start_cmd(argv: list[str] | None = None) -> None:

agentic_devtools/cli/copilot/session.py

@@ -156,6 +156,8 @@ class CopilotSessionResult:
             when this object is returned).
         process: The :class:`subprocess.Popen` handle for non-interactive
             sessions; ``None`` for interactive sessions.
+        log_file: Absolute path to the session log file for non-interactive
+            sessions; ``None`` for interactive sessions.
     """
 
     session_id: str
@@ -164,6 +166,7 @@ class CopilotSessionResult:
     start_time: str
     pid: int | None = field(default=None)
     process: subprocess.Popen | None = field(default=None, repr=False)  # type: ignore[type-arg]
+    log_file: str | None = field(default=None)
 
 
 # ---------------------------------------------------------------------------
@@ -175,17 +178,25 @@ def _get_copilot_binary() -> str | None:
     """Return the path to the copilot binary, or ``None`` if not found.
 
     Checks (in order):
-    1. The standalone ``copilot`` binary on the system ``PATH``.
-    2. The managed install at ``~/.agdt/bin/copilot[.exe]``.
+    1. The managed install at ``~/.agdt/bin/copilot[.exe]``.
+    2. The standalone ``copilot`` binary on the system ``PATH``.
+
+    The managed install is preferred because it is a direct executable that
+    avoids the ``.bat`` → ``copilot.ps1`` indirection used by the VS Code
+    Copilot Chat extension's bundled CLI.  On Windows, that ``.ps1`` file can
+    be temporarily locked by the extension during activation, causing transient
+    ``ERROR_SHARING_VIOLATION`` failures that are invisible to
+    ``subprocess.run`` (they manifest as non-zero exit codes from the batch
+    wrapper rather than ``OSError``).
 
     Returns:
         Absolute path string when found, ``None`` otherwise.
     """
+    if _MANAGED_COPILOT.is_file():
+        return str(_MANAGED_COPILOT)
     system_path = shutil.which("copilot")
     if system_path:
         return system_path
-    if _MANAGED_COPILOT.is_file():
-        return str(_MANAGED_COPILOT)
     return None
 
 
@@ -921,6 +932,7 @@ def start_copilot_session(
             start_time=start_time,
             pid=process.pid,
             process=process,
+            log_file=str(log_file_path),
         )
 
     _persist_session_state(result, model=model)

agentic_devtools/cli/workflows/commands.py

@@ -394,6 +394,17 @@ Examples:
     clear_state_for_workflow_initiation(preserve_run_id=bool(skip_copilot_session))
     set_value("copilot.model_id", model)
 
+    # Remove any stale VS Code auto-start task from a previous workflow to
+    # prevent a duplicate Copilot session from firing on folderOpen/reload.
+    # This is belt-and-suspenders alongside the cleanup in
+    # _start_copilot_session_for_workflow — the earlier we remove the stale
+    # task, the smaller the window for a race where VS Code reloads and fires
+    # the old task before we start the new session.
+    repo_root_early = get_git_repo_root() or os.getcwd()
+    from .worktree_setup import _cleanup_stale_auto_start_task_for_worktree
+
+    _cleanup_stale_auto_start_task_for_worktree(repo_root_early)
+
     # Set provided values in state using the NORMALIZED identifiers.  When both issue_key
     # and pull_request_id are provided, write jira.issue_key FIRST so that the engine-side
     # priority guard in set_value() (which checks the loaded state dict) sees the issue key

agentic_devtools/cli/workflows/worktree_setup.py

@@ -14,6 +14,7 @@ import platform
 import shutil
 import subprocess
 import sys
+import threading
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -1455,6 +1456,27 @@ def _remove_stale_auto_start_task(
     remove_auto_start_task(tasks_path, vscode_dir, task_label, delete_if_empty=delete_if_empty)
 
 
+def _cleanup_stale_auto_start_task_for_worktree(worktree_path: str) -> None:
+    """Remove any stale auto-start task from a worktree's ``.vscode/tasks.json``.
+
+    Best-effort helper that derives the paths from *worktree_path* and
+    delegates to :func:`_remove_stale_auto_start_task`.  Called before
+    starting a new Copilot session to prevent a leftover ``runOn: folderOpen``
+    task from a previous workflow from spawning a duplicate session when
+    VS Code reloads.
+
+    All errors are silently caught so this never prevents the caller from
+    proceeding.
+    """
+    try:
+        vscode_dir = os.path.join(worktree_path, ".vscode")
+        tasks_path = os.path.join(vscode_dir, "tasks.json")
+        if os.path.isfile(tasks_path):
+            _remove_stale_auto_start_task(tasks_path, vscode_dir, _AUTO_START_TASK_LABEL)
+    except Exception:
+        pass
+
+
 class WorktreeStateContext:
     """Context manager for cross-worktree state resolution.
 
@@ -2347,18 +2369,26 @@ def _start_copilot_session_for_workflow(
     # where stdin/stdout are redirected to DEVNULL/log files).
     has_tty = getattr(sys.stdin, "isatty", lambda: False)() and getattr(sys.stdout, "isatty", lambda: False)()
 
-    # --- Auto-start injection confirmed: skip background fallback ------------
+    # --- Auto-start injection confirmed: delayed verification fallback ------
     # When the caller confirms the auto-start task was successfully injected
-    # into tasks.json, trust that VS Code will execute it (possibly after a
-    # trust/permission dialog).  Do NOT start a duplicate background session.
-    # The previous 15-second timeout was insufficient for scenarios where
-    # VS Code shows a workspace trust or task permission dialog before
-    # executing the runOn:folderOpen task.
+    # into tasks.json, we trust that VS Code *will probably* execute it.
+    # However, the task can still fail (e.g., copilot binary locked, permission
+    # dialog dismissed, VS Code crash).  Instead of blindly returning True,
+    # we spawn a non-daemon thread that waits for the run ID to appear in state
+    # (proving the task ran).  If it doesn't appear within the grace period,
+    # the thread starts a non-interactive background session as a safety net.
     if autostart_injected and not has_tty:
         print(
             "\n--- VS Code auto-start task was successfully injected. "
-            "Trusting VS Code to handle the Copilot session "
-            "(no background fallback will be started). ---"
+            f"A delayed verification (up to {_AUTOSTART_VERIFICATION_DELAY_S:.0f}s) "
+            "will confirm it ran and may keep this task running; if not, a "
+            "background fallback session will be started automatically. ---"
+        )
+        _spawn_delayed_autostart_verification(
+            worktree_path=worktree_path,
+            start_prompt=start_prompt,
+            workflow_name=workflow_name,
+            model=model,
         )
         return True
 
@@ -2460,6 +2490,12 @@ def _start_copilot_session_for_workflow(
 
     effective_interactive = interactive and is_vscode_available() and has_tty
 
+    # Remove any stale auto-start task from tasks.json BEFORE starting a new
+    # session. A leftover runOn:folderOpen task from a previous workflow
+    # invocation can fire when VS Code reloads, causing a duplicate Copilot
+    # session alongside the one we are about to start. See #1742.
+    _cleanup_stale_auto_start_task_for_worktree(worktree_path)
+
     print(
         f"\n--- Starting gh copilot session for {workflow_name} "
         f"(mode: {'interactive' if effective_interactive else 'non-interactive'}) ---"
@@ -2475,12 +2511,24 @@ def _start_copilot_session_for_workflow(
 
         state_dir = get_state_dir()
         os.environ["AGENTIC_DEVTOOLS_STATE_DIR"] = str(state_dir)
-        start_copilot_session(
+        session_result = start_copilot_session(
             prompt=start_prompt,
             working_directory=worktree_path,
             interactive=effective_interactive,
             model=model,
         )
+        # Open the log file in VS Code for non-interactive sessions so the
+        # user can watch Copilot output in real time.  Skip in CI (no VS Code
+        # or no TTY on the *original* caller — here we check is_vscode_available
+        # which is False in headless CI).
+        if (
+            not effective_interactive
+            and session_result is not None
+            and session_result.log_file
+            and is_vscode_available()
+            and not _in_test_environment()
+        ):
+            _open_log_in_vscode(session_result.log_file, worktree_path)
         return True
 
 
@@ -2758,6 +2806,128 @@ def _start_copilot_session_for_update_jira_issue(
 _PENDING_AUTO_START_FILENAME = "pending-auto-start.json"
 _FOCUS_SETTLE_SECONDS: float = 2.0
 
+# Grace period (seconds) for the delayed auto-start verification.
+# VS Code may show a workspace trust or task permission dialog before
+# executing runOn:folderOpen, so the window must be generous.
+_AUTOSTART_VERIFICATION_DELAY_S: float = 45.0
+_AUTOSTART_VERIFICATION_POLL_S: float = 3.0
+
+
+def _spawn_delayed_autostart_verification(
+    worktree_path: str,
+    start_prompt: str,
+    workflow_name: str,
+    model: str | None = None,
+) -> None:
+    """Spawn a non-daemon thread that verifies the VS Code auto-start task ran.
+
+    After a grace period, the thread checks whether the auto-start task
+    wrote its run ID into ``copilot.auto_start_triggered_runs``.  If not,
+    it starts a non-interactive background Copilot session as a fallback
+    and opens the log file in VS Code (when available).
+
+    The thread is non-daemon so it keeps the parent process alive until
+    verification completes (at most ``_AUTOSTART_VERIFICATION_DELAY_S``
+    seconds).  If a fallback session is started, the session's non-daemon
+    tee-thread keeps the process alive for the duration of the Copilot
+    subprocess.
+
+    **Safety guard**: This function is a no-op inside test environments
+    (``PYTEST_CURRENT_TEST`` set) to prevent threads from outliving test
+    cases and accidentally spawning real Copilot sessions.
+    """
+    if _in_test_environment():
+        return
+
+    state_file_path, state_run_id = _resolve_state_context_in_worktree(worktree_path, include_run_id=True)
+
+    def _verify_and_fallback() -> None:
+        import time
+
+        from agentic_devtools.cli.copilot.auto_start import _is_run_triggered
+
+        # Prefer the run_id from state when available; fall back to the pending marker written during injection.
+        current_run_id = state_run_id.strip()
+        if not current_run_id:
+            marker_path = os.path.join(worktree_path, ".vscode", _PENDING_AUTO_START_FILENAME)
+            try:
+                if os.path.isfile(marker_path):
+                    with open(marker_path, encoding="utf-8") as fh:
+                        marker = json.load(fh)
+                    if isinstance(marker, dict):
+                        run_id_value = marker.get("run_id")
+                        if isinstance(run_id_value, str):
+                            current_run_id = run_id_value.strip()
+            except (OSError, json.JSONDecodeError, ValueError):
+                current_run_id = ""
+
+        if state_file_path is None or not current_run_id:
+            # Cannot verify — fall through to start fallback immediately
+            print(
+                "\n--- Delayed verification: no state file or run ID available. "
+                "Starting background fallback Copilot session. ---",
+                file=sys.stderr,
+            )
+        else:
+            # Poll for the run ID until the grace period expires.
+            elapsed = 0.0
+            while elapsed < _AUTOSTART_VERIFICATION_DELAY_S:
+                if _is_run_triggered(state_file_path, current_run_id):
+                    # Auto-start task confirmed running — no fallback needed.
+                    return
+                time.sleep(_AUTOSTART_VERIFICATION_POLL_S)
+                elapsed += _AUTOSTART_VERIFICATION_POLL_S
+
+            print(
+                f"\n--- Delayed verification: VS Code auto-start task did NOT run "
+                f"within {_AUTOSTART_VERIFICATION_DELAY_S:.0f}s. "
+                f"Starting background fallback Copilot session for {workflow_name}. ---",
+                file=sys.stderr,
+            )
+
+        # Start the fallback non-interactive session.
+        try:
+            from ..copilot.session import start_copilot_session
+
+            # Pin state writes to the target worktree state dir when available.
+            target_state_dir = os.path.dirname(state_file_path) if state_file_path else None
+            previous_state_dir = os.environ.get("AGENTIC_DEVTOOLS_STATE_DIR")
+            if target_state_dir:
+                os.environ["AGENTIC_DEVTOOLS_STATE_DIR"] = target_state_dir
+            try:
+                session_result = start_copilot_session(
+                    prompt=start_prompt,
+                    working_directory=worktree_path,
+                    interactive=False,
+                    model=model,
+                )
+            finally:
+                if target_state_dir:
+                    if previous_state_dir is None:
+                        os.environ.pop("AGENTIC_DEVTOOLS_STATE_DIR", None)
+                    else:
+                        os.environ["AGENTIC_DEVTOOLS_STATE_DIR"] = previous_state_dir
+            # Open log in VS Code so the user can monitor.
+            if (
+                session_result is not None
+                and session_result.log_file
+                and is_vscode_available()
+                and not _in_test_environment()
+            ):
+                _open_log_in_vscode(session_result.log_file, worktree_path)
+        except Exception as exc:
+            print(
+                f"Warning: delayed fallback Copilot session failed: {exc}",
+                file=sys.stderr,
+            )
+
+    thread = threading.Thread(
+        target=_verify_and_fallback,
+        name="autostart-verification",
+        daemon=False,
+    )
+    thread.start()
+
 
 def _write_pending_auto_start_marker(
     worktree_path: str,
@@ -2847,6 +3017,49 @@ def _focus_vscode_window(worktree_path: str) -> bool:
     return True
 
 
+def _open_log_in_vscode(log_file_path: str, worktree_path: str) -> None:
+    """Open the Copilot session log file in VS Code for live monitoring.
+
+    Uses ``code <log_file_path>`` to request opening the file in VS Code.
+    The CLI decides which window receives the file (often the most recently
+    active window). Best-effort: errors are printed to stderr but never raised.
+
+    Args:
+        log_file_path: Absolute path to the ``.log`` file.
+        worktree_path: The worktree root (used for context in messages).
+    """
+    try:
+        log_file_path = os.path.abspath(log_file_path)
+        use_shell = platform.system() == "Windows"
+        if use_shell and any(ch in log_file_path for ch in "&|<>^%"):
+            print(
+                "Warning: refusing to open log file in VS Code on Windows because "
+                f"path contains cmd.exe metacharacters: {log_file_path!r}",
+                file=sys.stderr,
+            )
+            return
+        proc = subprocess.run(
+            ["code", log_file_path],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+            shell=use_shell,
+        )
+        if proc.returncode == 0:
+            print(f"--- Opened Copilot session log in VS Code: {log_file_path} (worktree: {worktree_path}) ---")
+        else:
+            print(
+                f"Warning: 'code' exited with {proc.returncode} when opening log file "
+                f"{log_file_path!r} (worktree: {worktree_path}).",
+                file=sys.stderr,
+            )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        print(
+            f"Warning: could not open log file in VS Code: {exc} (worktree: {worktree_path}, file: {log_file_path!r})",
+            file=sys.stderr,
+        )
+
+
 def _try_terminal_send_fallback(worktree_path: str, expected_run_id: str | None = None) -> bool:
     """Attempt to start the Copilot session via VS Code terminal sendSequence.
 

{agentic_devtools-0.2.152.dist-info → agentic_devtools-0.2.154.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.152
+Version: 0.2.154
 Summary: Agentic devtools integrate Jira, DevOps & more
 Author: ayaiayorg
 License-Expression: MIT

{agentic_devtools-0.2.152.dist-info → agentic_devtools-0.2.154.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentic_devtools/__init__.py,sha256=J_Zw_vWKghk-cLmqI83hXQmSiS8zMhGIHM5WPLDkZuo,242
-agentic_devtools/_version.py,sha256=QR6RgQM2XLjvmCHvQe6iRYZ8ysRf1j2G_xGWowWyMu8,524
+agentic_devtools/_version.py,sha256=a3-860ghbqgShvATariWvr3uQTtn4SgO05rdw4MFYhE,524
 agentic_devtools/agdt_gitignore.py,sha256=Jcc9BUiCIqCG9tUuHc5Jua5tPT_QtTnEK6Gr0v_RrKQ,1559
 agentic_devtools/background_tasks.py,sha256=QCiCSTcU8HSFa_g_fa2NWXhhRZU4zo6YgsPSIVVmdOU,16971
 agentic_devtools/config.py,sha256=X6zv8Twviv9LMiV7TYy_6SQeNezJHV8lBNvIxLkOqLY,8049
@@ -145,8 +145,8 @@ agentic_devtools/cli/ci/tracker/renderer.py,sha256=6LhId0Ehfcmn_BAtrH69z9Cl4xBfQ
 agentic_devtools/cli/config/__init__.py,sha256=1KFPaXnhgP1ZBvIxxLAethaCeY5RzTM2GwU-xnt69ro,271
 agentic_devtools/cli/config/project_config.py,sha256=NjFW3Ds0vUxotGSJwp7Z4zktFItTvRp2pQ0PDdWwYIE,3193
 agentic_devtools/cli/copilot/__init__.py,sha256=FFlmM67FbXNTKvWDm4ySOUXL6DvZMnyMWNrGa_ALiq4,562
-agentic_devtools/cli/copilot/auto_start.py,sha256=FATVY0_IDrcTSndEtjchKOZB_hJMlG0pRvBIj9HO7yU,29763
-agentic_devtools/cli/copilot/session.py,sha256=q35FPVOlADYjSTtFpW0aHIDAOzQxqlVrUroo731rrbM,39112
+agentic_devtools/cli/copilot/auto_start.py,sha256=0T3tIFw3R18_KPZ-00i9HsyG5Z1dccHZmLXqYEiB8xM,33522
+agentic_devtools/cli/copilot/session.py,sha256=7v6Wx24Edf3pAkEu4eFbxrp_vIJFAQ4xLPZq73m_ghI,39821
 agentic_devtools/cli/git/__init__.py,sha256=ACoWYDgm8AMjk2wJ_Ycc5CY7xCXJQtfB55HzM-yx8WA,2538
 agentic_devtools/cli/git/agdt_branch.py,sha256=4qHH1dxYr3LraAB2Q6_fjgLrI3KrPCvXu-uOsJryN7M,37373
 agentic_devtools/cli/git/async_commands.py,sha256=DdvoMsqcVh5T78wXoFQO2m1B61QC-QPDsy6bwZ9VBDk,9883
@@ -258,11 +258,11 @@ agentic_devtools/cli/workflows/advancement.py,sha256=bxrF4L0r6LTu9Di6Ll6PUEFLAYA
 agentic_devtools/cli/workflows/applied_suggestions.py,sha256=vRDYk5nokfMtmiQzCanBTBmRRFWIPNZILJDQ4hIb7nE,9306
 agentic_devtools/cli/workflows/base.py,sha256=pgdzP5M3CKXTg1mVMqUz2t-C_NMCKbptmiM-iUgbsBg,10966
 agentic_devtools/cli/workflows/checklist.py,sha256=3JMY-pvqb6wUpG2XXSFNnYiGYO9aM9O96Z6GW-4qb_s,9998
-agentic_devtools/cli/workflows/commands.py,sha256=qSxjCl4sn3jRvR7I8MB5QS-wOOZxUU-mUQtdKnChWhc,142548
+agentic_devtools/cli/workflows/commands.py,sha256=Bto2FM7oFTKlYkP2mT0o20ARS9R4ivPD_mOOccRDk1E,143166
 agentic_devtools/cli/workflows/engine_resolution.py,sha256=HUYMGERXCyJJgc0RgWg5w7JdpHGPjdXfnPkZAqMn5iI,2309
 agentic_devtools/cli/workflows/manager.py,sha256=BxSDix8IV6QQhawIMvfIN0iOKbkFFxAauwONlkse9uU,28721
 agentic_devtools/cli/workflows/preflight.py,sha256=vljErnXSvtgbN9m5zArGjZ4iemk6LajPj2mqGkyqGbs,12233
-agentic_devtools/cli/workflows/worktree_setup.py,sha256=m7FV-gFjest05WRwHTY1jviclpxeMF_w7hxn7XSC24Q,156708
+agentic_devtools/cli/workflows/worktree_setup.py,sha256=gpGwpqUlR41JvEiUNZsIzZ2dP1KV0pdh18Hdc-Ub75k,166019
 agentic_devtools/context/__init__.py,sha256=Rrk10DQHFnkFiFd1w9EFwBPo36tV-HJqjgaANm_3mg0,427
 agentic_devtools/context/models.py,sha256=tsKM6x_yAHkWcJOzNrgMaqkXyDxR1mVZyC5Dbu_rIdE,1518
 agentic_devtools/context/nodes.py,sha256=cexQ92RbPddTWV8zwLTK4EPEfVGZZk4Sp-nzblgE3wo,4951
@@ -600,8 +600,8 @@ agentic_devtools/_bundled_skills/prompts/speckit.plan.prompt.md,sha256=IJja5r2Sd
 agentic_devtools/_bundled_skills/prompts/speckit.specify.prompt.md,sha256=eyzE3GRi2hyW30a6xPYOU7q6MJf0skrD-baEGURYqpg,31
 agentic_devtools/_bundled_skills/prompts/speckit.tasks.prompt.md,sha256=iPxXwon5nV6dNcJV8-JoP3PssKUVXctNiG-C9SsRhB8,29
 agentic_devtools/_bundled_skills/prompts/speckit.taskstoissues.prompt.md,sha256=L5Y21PMSoUcPAAdHy2Jnf-wGVdi04jV_pPvyOJZfpm0,37
-agentic_devtools-0.2.152.dist-info/METADATA,sha256=2nIhlupv7NmOkNC5dRNiAJq115Rmo1FbZnOHWDkIQa8,29269
-agentic_devtools-0.2.152.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-agentic_devtools-0.2.152.dist-info/entry_points.txt,sha256=CDSdq-zuDsv3AHT2rcY6EBRdtL1tsV_Q3shNW1AP7Ec,9329
-agentic_devtools-0.2.152.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.152.dist-info/RECORD,,
+agentic_devtools-0.2.154.dist-info/METADATA,sha256=wE2Q9F0IF2bwtMB211fHD4BN9T6hpTFu14bPxXvygXY,29269
+agentic_devtools-0.2.154.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+agentic_devtools-0.2.154.dist-info/entry_points.txt,sha256=CDSdq-zuDsv3AHT2rcY6EBRdtL1tsV_Q3shNW1AP7Ec,9329
+agentic_devtools-0.2.154.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.154.dist-info/RECORD,,