agentic-devtools 0.2.330__py3-none-any.whl → 0.2.332__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.330'
-__version_tuple__ = version_tuple = (0, 2, 330)
+__version__ = version = '0.2.332'
+__version_tuple__ = version_tuple = (0, 2, 332)
 
 __commit_id__ = commit_id = None

agentic_devtools/cli/ci/github_provider.py

@@ -59,6 +59,7 @@ from agentic_devtools.cli.ci.resolution.tiers.outdated import OutdatedTier
 from agentic_devtools.cli.ci.resolution.tiers.sdk_evaluation import SdkEvaluationTier
 from agentic_devtools.cli.ci.retry import RetryableError, retry_with_backoff
 from agentic_devtools.cli.git.commit_template import _derive_issue_link_from_key, resolve_commit_message_from_template
+from agentic_devtools.cli.github.ccr_review_format import extract_suppressed_comment_entries
 from agentic_devtools.cli.subprocess_utils import run_safe
 from agentic_devtools.config import load_platform_config
 from agentic_devtools.state import get_state_dir
@@ -272,35 +273,19 @@ query($owner: String!, $name: String!, $endCursor: String!) {
 }
 """
 
-# Regex to extract the <details> block containing suppressed comments.
-# Uses DOTALL so `.*?` spans newlines.
-_SUPPRESSED_DETAILS_RE = re.compile(
-    r"<details>\s*<summary>[^<]*suppressed due to low confidence[^<]*</summary>(.*?)</details>",
-    re.DOTALL | re.IGNORECASE,
-)
-
-# Regex to extract individual entries within the suppressed block.
-# Each entry starts with a bold or code-formatted file path, followed by body text.
-# Matches patterns like:
-#   **path/to/file.py**: body text
-#   `path/to/file.py`: body text
-#   **`path/to/file.py`**: body text
-_SUPPRESSED_ENTRY_RE = re.compile(
-    r"(?:\*\*`?|`)"  # opening bold/code marker
-    r"([^`*\n]+?)"  # file path (captured)
-    r"(?:`?\*\*|`)"  # closing bold/code marker
-    r"\s*:?\s*"  # optional colon separator
-    r"(.*?)(?=\n(?:\*\*`?|`)[^`*\n]+?(?:`?\*\*|`)\s*:?|\Z)",  # body (captured, up to next entry or end)
-    re.DOTALL,
-)
-
 
+# Suppressed-comment recovery from a Copilot review body.
 def _parse_suppressed_from_review_body(review_body: str) -> list[ReviewCommentInfo]:
-    """Parse suppressed comments from a Copilot review body HTML.
+    """Parse suppressed comments from a Copilot review body.
 
-    Extracts comments from the ``<details>`` block with summary containing
-    "suppressed due to low confidence". Each entry is expected to have a bold
-    or code-formatted file path followed by comment body text.
+    Delegates block/entry extraction to the shared CCR parser
+    (:func:`agentic_devtools.cli.github.ccr_review_format.extract_suppressed_comment_entries`),
+    which understands **both** the legacy ``<details><summary>… suppressed …</summary>``
+    format and the new CCR private-preview format (a
+    ``### Comments suppressed due to low confidence (N)`` heading inside a
+    ``<details><summary>Review details</summary>`` block).  Each recovered
+    ``(path, body)`` pair is wrapped as a ``ReviewCommentInfo`` with
+    ``is_suppressed=True`` and a unique negative sentinel ID.
 
     Args:
         review_body: Full review body text (may contain HTML).
@@ -309,29 +294,9 @@ def _parse_suppressed_from_review_body(review_body: str) -> list[ReviewCommentIn
         List of ``ReviewCommentInfo`` with ``is_suppressed=True`` and negative
         sentinel IDs. Returns empty list if no suppressed block is found.
     """
-    if not review_body:
-        return []
-
-    match = _SUPPRESSED_DETAILS_RE.search(review_body)
-    if not match:
-        return []
-
-    block_content = match.group(1).strip()
-    if not block_content:
-        return []
-
     entries: list[ReviewCommentInfo] = []
     sentinel_id = -1
-
-    for entry_match in _SUPPRESSED_ENTRY_RE.finditer(block_content):
-        path = entry_match.group(1).strip()
-        body = entry_match.group(2).strip()
-
-        if not path:
-            path = "(unknown file)"
-        if not body:
-            continue
-
+    for path, body in extract_suppressed_comment_entries(review_body):
         entries.append(
             ReviewCommentInfo(
                 id=sentinel_id,
@@ -343,24 +308,6 @@ def _parse_suppressed_from_review_body(review_body: str) -> list[ReviewCommentIn
         )
         sentinel_id -= 1
 
-    # If we found a details block but no structured entries, try a line-based
-    # fallback: treat each non-empty line as a standalone comment.
-    if not entries:
-        for line in block_content.splitlines():
-            line = line.strip()
-            if not line:
-                continue
-            entries.append(
-                ReviewCommentInfo(
-                    id=sentinel_id,
-                    path="(unknown file)",
-                    body=line,
-                    html_url="",
-                    is_suppressed=True,
-                )
-            )
-            sentinel_id -= 1
-
     return entries
 
 

agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py

@@ -11,18 +11,48 @@ from agentic_devtools.cli.ci.guards import (
 )
 from agentic_devtools.cli.ci.models import COPILOT_LOGINS, ReviewInfo
 from agentic_devtools.cli.ci.pipeline.exclusion import ExclusionContext
+from agentic_devtools.cli.ci.pipeline.gate_verdict import (
+    REASON_HAS_COMMENTS,
+    REASON_NEW_CCR_NOT_APPROVED,
+    REASON_SUPPRESSED_COMMENTS,
+)
 from agentic_devtools.cli.ci.pipeline.models import ActionDecision, ActionResult
 from agentic_devtools.cli.ci.pipeline.snapshot import DerivedState, PRStateSnapshot
 from agentic_devtools.cli.ci.provider import CIPlatformProvider
 
 logger = logging.getLogger(__name__)
 
+#: Gate-verdict reasons that mean the HEAD Copilot review carries actionable
+#: feedback in its *body* (posted comments, suppressed/low-confidence comments,
+#: or a new-CCR-format "Not ready to approve" verdict).  Freshness reasons
+#: (awaiting-fresh, content-changed) are deliberately excluded — they call for a
+#: *new* review, not a repair dispatch.
+_CONTENT_BLOCKING_GATE_REASONS: frozenset[str] = frozenset(
+    {
+        REASON_HAS_COMMENTS,
+        REASON_SUPPRESSED_COMMENTS,
+        REASON_NEW_CCR_NOT_APPROVED,
+    }
+)
+
 
 def _is_copilot_review_actionable(snapshot: PRStateSnapshot) -> bool:
     """Return True if the Copilot review on HEAD is actionable.
 
-    Actionable means CHANGES_REQUESTED, or COMMENTED with inline comments.
-    Unknown inline counts fail closed and are treated as actionable.
+    Actionable means:
+
+    * ``CHANGES_REQUESTED`` on HEAD, or
+    * ``COMMENTED`` on HEAD with inline comments (unknown inline counts fail
+      closed and are treated as actionable), or
+    * ``COMMENTED`` on HEAD with **zero** counted inline comments but a
+      content-blocking gate verdict for that same review.
+
+    The third branch closes a new-CCR-format gap: the private-preview format can
+    block the gate purely from the review body (a "Not ready to approve" verdict
+    heading, or body-only suppressed comments) while exposing no inline comments
+    through the API.  Without it, such a PR is blocked by the gate yet never
+    triggers repair — a permanent stall.  Freshness reasons are excluded because
+    they require a *new* review, not a repair.
     """
     if snapshot.review_state == "CHANGES_REQUESTED" and snapshot.copilot_review_id > 0:
         return True
@@ -32,6 +62,16 @@ def _is_copilot_review_actionable(snapshot: PRStateSnapshot) -> bool:
         and snapshot.copilot_review_inline_count != 0
     ):
         return True
+    verdict = snapshot.copilot_gate_verdict
+    if (
+        snapshot.review_state == "COMMENTED"
+        and snapshot.copilot_review_id > 0
+        and verdict is not None
+        and not verdict.passed
+        and verdict.reason in _CONTENT_BLOCKING_GATE_REASONS
+        and verdict.review_id == snapshot.copilot_review_id
+    ):
+        return True
     return False
 
 

agentic_devtools/cli/ci/pipeline/gate_verdict.py

@@ -21,6 +21,12 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from agentic_devtools.cli.ci.models import COPILOT_LOGINS, ReviewInfo
+from agentic_devtools.cli.github.ccr_review_format import (
+    VERDICT_NOT_APPROVE,
+    parse_reported_comment_count,
+    parse_suppressed_count,
+    parse_verdict,
+)
 
 if TYPE_CHECKING:
     from agentic_devtools.cli.ci.provider import CIPlatformProvider
@@ -51,6 +57,9 @@ REASON_HAS_COMMENTS = "copilot_review_has_comments"
 #: Copilot's review body reports suppressed/low-confidence comments > 0.
 REASON_SUPPRESSED_COMMENTS = "copilot_review_suppressed_comments"
 
+#: New CCR format review body has a "Not ready to approve" verdict heading.
+REASON_NEW_CCR_NOT_APPROVED = "copilot_review_new_format_not_approved"
+
 #: PR diff content changed since the prior-commit review.
 REASON_CONTENT_CHANGED = "copilot_review_content_changed_since_review"
 
@@ -131,40 +140,6 @@ def _select_latest_prior_review(reviews: list[ReviewInfo], head_sha: str) -> Rev
     return max(candidates, key=lambda r: (r.submitted_at, r.id))
 
 
-def _parse_body_comment_count(body: str) -> int | None:
-    """Parse Copilot's self-reported comment count from *body*.
-
-    Matches:
-    - ``"generated no comments"``
-    - ``"generated no new comments"`` (re-review phrasing)
-    - ``"generated N comment(s)"``
-
-    Returns:
-        An integer count, or ``None`` when the body format is unrecognised.
-    """
-    if re.search(r"generated no( new)? comments", body, re.IGNORECASE):
-        return 0
-    m = re.search(r"generated (\d+) comment", body, re.IGNORECASE)
-    if m:
-        return int(m.group(1))
-    return None
-
-
-def _parse_suppressed_count(body: str) -> int:
-    """Parse the suppressed / low-confidence comment count from *body*.
-
-    Matches ``Suppressed (N)`` and ``Low confidence (N)`` as reported by
-    Copilot in the review summary text.
-    """
-    m = re.search(r"[Ss]uppressed[^.(]*\((\d+)\)", body)
-    if m:
-        return int(m.group(1))
-    m = re.search(r"[Ll]ow confidence[^.(]*\((\d+)\)", body)
-    if m:
-        return int(m.group(1))
-    return 0
-
-
 def _evaluate_synthetic_review(
     review: ReviewInfo,
     provider: CIPlatformProvider,
@@ -271,14 +246,33 @@ def _evaluate_standard_review(
 ) -> CopilotGateVerdict:
     """Evaluate a standard (non-synthetic) Copilot review.
 
-    Parses ``"generated N comments"`` and ``"Suppressed (N)"`` from the review
-    body.  When the body format is unrecognised, falls back to the API inline
-    comment count (fail-closed).
+    Handles both the legacy CCR body format (``"generated N comments"``,
+    ``"Suppressed (N)"``) and the new-style CCR private-preview format with a
+    ``### <emoji> <verdict>`` heading and ``**Comments generated:** N new``
+    metrics footer.  When the body format is unrecognised, falls back to the
+    API inline comment count (fail-closed).
     """
     body = review.body
 
-    body_comment_count = _parse_body_comment_count(body)
-    suppressed_count = _parse_suppressed_count(body)
+    # --- New CCR format: check verdict heading first ---
+    # "### 🟡 Not ready to approve" → block immediately regardless of comment counts.
+    # "### ✅ Ready to approve"      → proceed with comment-count checks below.
+    new_ccr_verdict = parse_verdict(body)
+    if new_ccr_verdict == VERDICT_NOT_APPROVE:
+        suppressed_count = parse_suppressed_count(body)
+        detail_parts = ["Copilot review heading indicates 'Not ready to approve'"]
+        if suppressed_count > 0:
+            detail_parts.append(f"{suppressed_count} suppressed/low-confidence comment(s)")
+        return CopilotGateVerdict(
+            passed=False,
+            reason=REASON_NEW_CCR_NOT_APPROVED,
+            review_id=review.id,
+            suppressed_count=suppressed_count,
+            details="; ".join(detail_parts),
+        )
+
+    body_comment_count = parse_reported_comment_count(body)
+    suppressed_count = parse_suppressed_count(body)
 
     if body_comment_count is None:
         # Body format unrecognised — fall back to the API inline count.

agentic_devtools/cli/github/ccr_review_format.py

@@ -0,0 +1,279 @@
+"""Canonical parsers for Copilot Code Review (CCR) review bodies.
+
+This module is the **single source of truth** for extracting structured
+information from a Copilot Code Review body.  It understands two body formats:
+
+**Legacy format** — prose summary with:
+
+- ``"generated N comment(s)"`` / ``"generated no comments"`` phrasing.
+- ``Suppressed (N)`` / ``Low confidence (N)`` counts.
+- A ``<details><summary>… suppressed due to low confidence …</summary>…</details>``
+  block whose entries are ``**path**: body`` / ``` `path`: body ``` lines.
+
+**New CCR private-preview format** — a ``### <emoji> <verdict>`` heading
+(``### 🟡 Not ready to approve`` / ``### ✅ Ready to approve``) followed by a
+``<details><summary>Review details</summary>`` block containing:
+
+- A ``### Comments suppressed due to low confidence (N)`` heading, whose entries
+  are ``**path:line**`` on one line followed by a ``* body`` bullet (and, often,
+  a fenced code block).
+- A metrics footer (``- **Files reviewed:** …``, ``- **Comments generated:** N``,
+  ``- **Review effort level:** …``).
+
+Centralising this logic keeps every consumer in the AI PR loop consistent:
+
+- :mod:`agentic_devtools.cli.ci.pipeline.gate_verdict` (approval/merge gate)
+- :mod:`agentic_devtools.cli.ci.github_provider` (suppressed-comment recovery
+  for repair dispatch)
+- :mod:`agentic_devtools.cli.github.copilot_review_status` (poll-ready
+  review-status classification)
+
+Public API
+----------
+- :data:`VERDICT_NOT_APPROVE`, :data:`VERDICT_APPROVE` — verdict constants.
+- :data:`UNKNOWN_FILE` — placeholder path for unattributed suppressed comments.
+- :func:`parse_verdict` — new-format ``### <verdict>`` heading → verdict.
+- :func:`parse_reported_comment_count` — self-reported posted-comment count.
+- :func:`parse_suppressed_count` — self-reported suppressed/low-confidence count.
+- :func:`extract_suppressed_comment_entries` — ``(path, body)`` pairs for every
+  recoverable suppressed comment (both formats).
+"""
+
+from __future__ import annotations
+
+import re
+
+# ---------------------------------------------------------------------------
+# Public constants
+# ---------------------------------------------------------------------------
+
+#: Verdict returned when the new-format heading blocks approval.
+VERDICT_NOT_APPROVE = "not_approve"
+
+#: Verdict returned when the new-format heading approves.
+VERDICT_APPROVE = "approve"
+
+#: Placeholder path used when a suppressed comment cannot be attributed to a file.
+UNKNOWN_FILE = "(unknown file)"
+
+# ---------------------------------------------------------------------------
+# Verdict heading
+# ---------------------------------------------------------------------------
+
+#: Matches any ``###``-level (or deeper) heading line; the heading text is captured.
+_HEADING_RE = re.compile(r"^#{3,}\s+(.+?)\s*$", re.MULTILINE)
+
+
+def parse_verdict(body: str) -> str | None:
+    """Parse the review verdict from a new-style CCR heading.
+
+    Scans for ``###``-level headings introduced by the new CCR private-preview
+    format (e.g. ``### 🟡 Not ready to approve``, ``### ✅ Ready to approve``)
+    and returns the verdict from the first heading that expresses one.
+
+    ``"not ready to approve"`` is checked before ``"ready to approve"`` so the
+    substring match cannot mis-classify a blocking heading as approving.
+
+    Args:
+        body: Full review body text.
+
+    Returns:
+        :data:`VERDICT_NOT_APPROVE` when a blocking verdict heading is found,
+        :data:`VERDICT_APPROVE` when an approving verdict heading is found, or
+        ``None`` when no recognised CCR verdict heading is present (in which
+        case callers should fall back to their existing logic).
+    """
+    if not body:
+        return None
+    for match in _HEADING_RE.finditer(body):
+        heading_text = match.group(1).strip().lower()
+        if "not ready to approve" in heading_text:
+            return VERDICT_NOT_APPROVE
+        if "ready to approve" in heading_text:
+            return VERDICT_APPROVE
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Reported comment count
+# ---------------------------------------------------------------------------
+
+#: Legacy "generated no [new] comments" phrasing → count 0.
+_GENERATED_NONE_RE = re.compile(r"generated no( new)? comments", re.IGNORECASE)
+
+#: Legacy "generated N comment(s)" phrasing → count N.
+_GENERATED_N_RE = re.compile(r"generated (\d+) comment", re.IGNORECASE)
+
+#: New CCR metrics-footer "**Comments generated:** N [new]" → count N.
+#: The trailing "new" qualifier is optional — some reviews report a bare count
+#: (``**Comments generated:** 4``) while re-reviews report ``0 new``.
+_METRICS_GENERATED_RE = re.compile(
+    r"Comments generated[^:\n]*:\s*\*{0,2}\s*(\d+)(?:\s+new)?\b",
+    re.IGNORECASE,
+)
+
+
+def parse_reported_comment_count(body: str) -> int | None:
+    """Parse Copilot's self-reported posted-comment count from *body*.
+
+    Matches, in priority order:
+
+    - ``"generated no comments"`` / ``"generated no new comments"`` → ``0``
+    - ``"generated N comment(s)"`` → ``N``
+    - ``"**Comments generated:** N [new]"`` (new CCR metrics footer) → ``N``
+
+    Args:
+        body: Full review body text.
+
+    Returns:
+        An integer count, or ``None`` when no recognised count pattern is
+        present (callers fail closed on ``None``).
+    """
+    if not body:
+        return None
+    if _GENERATED_NONE_RE.search(body):
+        return 0
+    match = _GENERATED_N_RE.search(body)
+    if match:
+        return int(match.group(1))
+    match = _METRICS_GENERATED_RE.search(body)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Suppressed / low-confidence count
+# ---------------------------------------------------------------------------
+
+#: "… suppressed … (N)" — matches both the legacy ``<summary>`` text and the
+#: new-format ``### Comments suppressed due to low confidence (N)`` heading.
+_SUPPRESSED_COUNT_RE = re.compile(r"[Ss]uppressed[^.(]*\((\d+)\)")
+
+#: "… low confidence … (N)" fallback phrasing.
+_LOW_CONFIDENCE_COUNT_RE = re.compile(r"[Ll]ow confidence[^.(]*\((\d+)\)")
+
+
+def parse_suppressed_count(body: str) -> int:
+    """Parse the suppressed / low-confidence comment count from *body*.
+
+    Matches ``Suppressed (N)`` (including the new format's
+    ``### Comments suppressed due to low confidence (N)`` heading) and, as a
+    fallback, ``Low confidence (N)``.
+
+    Args:
+        body: Full review body text.
+
+    Returns:
+        The parsed count, or ``0`` when no suppressed-count pattern is present.
+    """
+    if not body:
+        return 0
+    match = _SUPPRESSED_COUNT_RE.search(body)
+    if match:
+        return int(match.group(1))
+    match = _LOW_CONFIDENCE_COUNT_RE.search(body)
+    if match:
+        return int(match.group(1))
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Suppressed comment entries
+# ---------------------------------------------------------------------------
+
+#: Legacy: the ``<details>`` block whose ``<summary>`` names the suppressed set.
+_LEGACY_SUPPRESSED_BLOCK_RE = re.compile(
+    r"<details>\s*<summary>[^<]*suppressed due to low confidence[^<]*</summary>(.*?)</details>",
+    re.DOTALL | re.IGNORECASE,
+)
+
+#: New format: content after the ``### Comments suppressed …`` heading, bounded
+#: before the next heading, the metrics footer, or the ``</details>`` close so the
+#: footer lines (``- **Files reviewed:** …``) are never captured as entries.
+_NEW_SUPPRESSED_BLOCK_RE = re.compile(
+    r"#{2,}\s+Comments?\s+suppressed\s+due\s+to\s+low\s+confidence[^\n]*\n"
+    r"(.*?)"
+    r"(?=\n\s*#{2,}\s"  # next heading
+    r"|\n\s*[-*]\s+\*\*(?:Files reviewed|Comments generated|Review effort)"  # metrics footer
+    r"|</details>"  # end of the Review details block
+    r"|\Z)",
+    re.DOTALL | re.IGNORECASE,
+)
+
+#: A single suppressed entry: a bold/code file path followed by body text.
+#: Matches ``**path**: body``, ``` `path`: body ```, ``**`path`**: body``, and the
+#: new format's ``**path:line**`` header followed by a ``* body`` bullet.
+_SUPPRESSED_ENTRY_RE = re.compile(
+    r"(?:\*\*`?|`)"  # opening bold/code marker
+    r"([^`*\n]+?)"  # file path (captured)
+    r"(?:`?\*\*|`)"  # closing bold/code marker
+    r"\s*:?\s*"  # optional colon separator
+    r"(.*?)(?=\n(?:\*\*`?|`)[^`*\n]+?(?:`?\*\*|`)\s*:?|\Z)",  # body up to next entry or end
+    re.DOTALL,
+)
+
+
+def _find_suppressed_block(body: str) -> str | None:
+    """Return the suppressed-comment block content for either format, or ``None``.
+
+    Prefers the legacy ``<details>`` block; falls back to the new-format
+    ``### Comments suppressed …`` section.  Returns ``None`` when neither is
+    present or the located block is empty.
+    """
+    legacy = _LEGACY_SUPPRESSED_BLOCK_RE.search(body)
+    if legacy:
+        return legacy.group(1).strip() or None
+    new = _NEW_SUPPRESSED_BLOCK_RE.search(body)
+    if new:
+        return new.group(1).strip() or None
+    return None
+
+
+def extract_suppressed_comment_entries(body: str) -> list[tuple[str, str]]:
+    """Extract ``(path, body)`` pairs for suppressed comments in *body*.
+
+    Handles both the legacy ``<details>`` block and the new-format
+    ``### Comments suppressed …`` section.  When a structured entry has no file
+    path, :data:`UNKNOWN_FILE` is used.  When the block contains no structured
+    entries at all, each non-blank line becomes a standalone
+    ``(UNKNOWN_FILE, line)`` fallback comment.
+
+    Args:
+        body: Full review body text (may contain HTML/Markdown).
+
+    Returns:
+        A list of ``(path, comment_body)`` tuples in document order.  Empty when
+        no suppressed block is found or the block yields no non-empty content.
+    """
+    if not body:
+        return []
+
+    block_content = _find_suppressed_block(body)
+    if not block_content:
+        return []
+
+    entries: list[tuple[str, str]] = []
+    for entry_match in _SUPPRESSED_ENTRY_RE.finditer(block_content):
+        path = entry_match.group(1).strip() or UNKNOWN_FILE
+        entry_body = entry_match.group(2).strip()
+        # The new CCR format renders each comment as a markdown bullet
+        # (``* comment``); strip a single leading bullet marker so the recovered
+        # comment text is clean.  Legacy bodies carry no bullet, so this is a
+        # no-op for them.
+        if entry_body[:2] in ("* ", "- "):
+            entry_body = entry_body[2:].strip()
+        if not entry_body:
+            continue
+        entries.append((path, entry_body))
+
+    # If the block matched but produced no structured entries, treat each
+    # non-empty line as a standalone comment (fail-open recovery).
+    if not entries:
+        for line in block_content.splitlines():
+            stripped = line.strip()
+            if not stripped:
+                continue
+            entries.append((UNKNOWN_FILE, stripped))
+
+    return entries

agentic_devtools/cli/github/copilot_review_status.py

@@ -3,8 +3,10 @@
 This module provides the ``agdt-gh-copilot-review-status`` CLI command that
 fetches reviews via the ``gh`` CLI REST API, filters to the Copilot reviewer
 bot on the current head commit, counts inline and suppressed (minimized)
-comments via GraphQL cursor pagination, classifies the review status, and
-returns structured JSON to stdout while writing state keys.
+comments via GraphQL cursor pagination, additionally parses the review **body**
+for the new CCR private-preview format (a "Not ready to approve" verdict and
+body-only suppressed comments that are not GitHub-minimized), classifies the
+review status, and returns structured JSON to stdout while writing state keys.
 
 Public API
 ----------
@@ -25,6 +27,12 @@ from typing import Any
 
 from ...state import get_value, set_value
 from ..subprocess_utils import run_safe
+from .ccr_review_format import (
+    VERDICT_NOT_APPROVE,
+    parse_reported_comment_count,
+    parse_suppressed_count,
+    parse_verdict,
+)
 from .repo_resolution import resolve_github_repo
 
 # ---------------------------------------------------------------------------
@@ -282,14 +290,42 @@ def _count_suppressed_comments(review_node_id: str) -> int:
     return suppressed_count
 
 
-def _classify_review_status(review_state: str, inline_count: int, suppressed_count: int) -> tuple[str, str]:
+def _classify_review_status(
+    review_state: str,
+    inline_count: int,
+    suppressed_count: int,
+    *,
+    not_approved: bool = False,
+    body_comment_count: int | None = None,
+) -> tuple[str, str]:
     """Classify the overall Copilot review status.
 
+    Args:
+        review_state: The review's ``state`` (``APPROVED`` / ``COMMENTED`` /
+            ``CHANGES_REQUESTED`` / …). The new CCR private-preview reviews are
+            always ``COMMENTED``, so the ``not_approved`` body verdict — not the
+            review state — is what makes them blocking.
+        inline_count: Copilot-authored inline review comments (REST).
+        suppressed_count: Suppressed/low-confidence comments, merged across
+            GraphQL-minimized comments and the review body so the new format's
+            body-only suppressed comments are counted.
+        not_approved: ``True`` when the review body carries a new-format
+            "Not ready to approve" verdict heading — always treated as feedback
+            regardless of comment counts or review state.
+        body_comment_count: Copilot's self-reported posted-comment count parsed
+            from the review body (``None`` when unrecognised); a positive value
+            is treated as feedback even when the REST inline count is 0.
+
     Returns:
         A ``(status, action_required)`` tuple.
     """
+    # A new-format "Not ready to approve" verdict is always blocking feedback,
+    # even with 0 inline/suppressed comments (prose-only verdict).
+    if not_approved:
+        return ("has-feedback", "address-copilot-review")
+
     # Feedback check has highest priority
-    if inline_count > 0 or suppressed_count > 0:
+    if inline_count > 0 or suppressed_count > 0 or (body_comment_count or 0) > 0:
         return ("has-feedback", "address-copilot-review")
 
     if review_state == "CHANGES_REQUESTED":
@@ -350,6 +386,7 @@ def get_copilot_review_status(pr_number: int, repo: str, head_sha: str) -> dict[
     review_node_id: str | None = review.get("node_id")
     review_state: str = review.get("state", "")
     submitted_at: str | None = review.get("submitted_at")
+    review_body: str = review.get("body") or ""
 
     inline_count = _count_inline_comments(pr_number, repo, review_id)
 
@@ -362,7 +399,20 @@ def get_copilot_review_status(pr_number: int, repo: str, head_sha: str) -> dict[
             file=sys.stderr,
         )
 
-    status, action_required = _classify_review_status(review_state, inline_count, suppressed_count)
+    # New CCR private-preview format: the verdict and suppressed comments live in
+    # the review *body*, not as GitHub-minimized comments. Merge the body-derived
+    # signals so a body-only "Not ready to approve" review is not misread as clean.
+    not_approved = parse_verdict(review_body) == VERDICT_NOT_APPROVE
+    body_comment_count = parse_reported_comment_count(review_body)
+    suppressed_count = max(suppressed_count, parse_suppressed_count(review_body))
+
+    status, action_required = _classify_review_status(
+        review_state,
+        inline_count,
+        suppressed_count,
+        not_approved=not_approved,
+        body_comment_count=body_comment_count,
+    )
 
     review_url = f"https://github.com/{repo}/pull/{pr_number}#pullrequestreview-{review_id}"
 

agentic_devtools/cli/setup/commands.py

@@ -17,7 +17,7 @@ import os
 import re
 import sys
 from pathlib import Path
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import urlparse
 
 from agentic_devtools.cli.cert_utils import ensure_ca_bundle as _ensure_ca_bundle
@@ -33,6 +33,9 @@ try:
 except ImportError:
     _VALID_ISSUE_ADAPTERS = frozenset({"jira", "github", "markdown"})
 
+if TYPE_CHECKING:  # pragma: no cover - typing-only import
+    from agentic_devtools.skill_injector import InjectionSummary
+
 _MANAGED_BIN_DIR = Path.home() / ".agdt" / "bin"
 
 _BANNER = """\
@@ -807,6 +810,57 @@ def _generate_setup_scripts(git_root: Path) -> None:
     print(msg)
 
 
+def _resolve_injection_axes(git_root: Path) -> tuple[str | None, str | None]:
+    """Resolve filter-capable skill-injection axes from the persisted platform config.
+
+    Reads the raw ``platform`` section from the repo's
+    ``.github/agdt-config.json`` (via :func:`load_repo_config`, which never
+    raises and returns ``{}`` when the file is absent or malformed) and maps it
+    to a filter-capable ``(issue_adapter, code_hosting)`` pair via
+    :func:`resolve_platform_context`.
+
+    Returns ``(None, None)`` — legacy inject-all — when:
+
+    - no config exists yet (a first-time setup run before platform detection has
+      written a config in a prior/earlier step),
+    - the ``platform`` section is absent or not a mapping, or
+    - neither axis holds a confidently-resolved, filter-capable value
+      (``jira``/``github`` adapter, ``github``/``azure_devops`` hosting).
+
+    A returned ``None`` axis means "inject-all for that axis"; when both axes are
+    ``None`` injection is byte-identical to the legacy inject-all behavior.
+    """
+    from agentic_devtools.config import load_repo_config  # noqa: PLC0415
+    from agentic_devtools.skill_classification import resolve_platform_context  # noqa: PLC0415
+
+    raw_config = load_repo_config(str(git_root))
+    return resolve_platform_context(raw_config.get("platform"))
+
+
+def _format_injection_summary(
+    summary: "InjectionSummary",
+    issue_adapter: str | None,
+    code_hosting: str | None,
+) -> str:
+    """Build the success line printed after a skill-injection pass.
+
+    When both axes are ``None`` (legacy inject-all), no filter was applied and
+    the pruned count is always zero, so the line omits the prune/platform
+    detail.  When at least one axis is resolved, the line reports how many files
+    were pruned and which axes constrained injection (an unresolved axis renders
+    as ``unrestricted``).
+    """
+    if issue_adapter is None and code_hosting is None:
+        return f"  ✓ Injected {summary.injected} agent/prompt skills (no platform filter applied)"
+
+    adapter_label = issue_adapter if issue_adapter is not None else "unrestricted"
+    hosting_label = code_hosting if code_hosting is not None else "unrestricted"
+    return (
+        f"  ✓ Injected {summary.injected} agent/prompt skills, pruned {summary.pruned} "
+        f"(issue_adapter={adapter_label}, code_hosting={hosting_label})"
+    )
+
+
 def setup_cmd() -> None:
     """Full setup: install Copilot CLI + GitHub CLI, then verify all dependencies.
 
@@ -1263,26 +1317,47 @@ def setup_cmd() -> None:
             # best-effort optional feature: guard the import so that agdt-setup still
             # works even if the module is missing or uses syntax/features not supported
             # by the current interpreter.
-            inject_skills = None  # type: ignore[assignment]
+            inject_skills_with_summary = None  # type: ignore[assignment]
             try:
-                from agentic_devtools.skill_injector import inject_skills as _inject_skills
+                from agentic_devtools.skill_injector import (  # noqa: PLC0415
+                    inject_skills_with_summary as _inject_with_summary,
+                )
 
-                inject_skills = _inject_skills
+                inject_skills_with_summary = _inject_with_summary
             except (SyntaxError, ImportError) as exc:
                 print(
                     f"  ⚠ Failed to import skill injector ({exc!r}) — skipping agent/prompt skill injection",
                     file=sys.stderr,
                 )
 
-            if inject_skills is not None and inject_skills(git_root):
-                print("  ✓ Injected agent/prompt skills into .github/agents/ and .github/prompts/")
-                repo_mutations_succeeded = True
-            elif inject_skills is not None:
-                print(
-                    "  ⚠ Failed to inject agent/prompt skills — this may be due to"
-                    " directory permissions or missing/corrupted bundled skills",
-                    file=sys.stderr,
+            if inject_skills_with_summary is not None:
+                # Resolve filter-capable platform axes from the persisted config
+                # (written by an earlier platform-detection run). Both axes are
+                # None — and injection is byte-identical to the legacy inject-all —
+                # only when the config is absent, the platform section is missing
+                # or non-mapping, or neither axis holds a confidently-resolved
+                # value ({jira,github} adapter / {github,azure_devops} hosting).
+                # Note: if a prior run already wrote load_platform_config()
+                # defaults (e.g. issue_adapter="jira") into
+                # .github/agdt-config.json, those persisted values ARE
+                # filter-capable and can activate the issue-adapter axis here.
+                # Defaults are NOT applied at injection time — only values
+                # already present in the file matter.
+                inj_issue_adapter, inj_code_hosting = _resolve_injection_axes(git_root)
+                inj_success, inj_summary = inject_skills_with_summary(
+                    git_root,
+                    issue_adapter=inj_issue_adapter,
+                    code_hosting=inj_code_hosting,
                 )
+                if inj_success:
+                    print(_format_injection_summary(inj_summary, inj_issue_adapter, inj_code_hosting))
+                    repo_mutations_succeeded = True
+                else:
+                    print(
+                        "  ⚠ Failed to inject agent/prompt skills — this may be due to"
+                        " directory permissions or missing/corrupted bundled skills",
+                        file=sys.stderr,
+                    )
 
             # ── Platform & Workflow Setup ──────────────────────────────
             if not args.system_only:

agentic_devtools/skill_classification.py

@@ -1,6 +1,6 @@
 """Classification reader for context-aware conditional skill injection.
 
-Provides a ``Classification`` dataclass and two public functions:
+Provides a ``Classification`` dataclass and three public functions:
 
 - ``parse_classification(frontmatter)`` — defensively reads the ``agdt`` block
   from a frontmatter mapping and returns a ``Classification``.  Never raises,
@@ -8,6 +8,9 @@ Provides a ``Classification`` dataclass and two public functions:
 - ``should_inject(classification, *, issue_adapter, code_hosting)`` — pure
   predicate deciding whether a skill should be injected given resolved platform
   values.
+- ``resolve_platform_context(platform)`` — maps a raw ``platform`` config
+  section to the filter-capable ``(issue_adapter, code_hosting)`` axes to
+  forward to injection.  Never raises, never mutates the input.
 """
 
 from __future__ import annotations
@@ -19,7 +22,7 @@ from typing import Any
 
 from agentic_devtools.config import VALID_CODE_HOSTING, VALID_ISSUE_ADAPTERS
 
-__all__ = ["Classification", "parse_classification", "should_inject"]
+__all__ = ["Classification", "parse_classification", "resolve_platform_context", "should_inject"]
 
 
 @dataclass(frozen=True)
@@ -38,6 +41,14 @@ class Classification:
 _TRUE_TOKENS: frozenset[str] = frozenset({"true", "yes", "on", "1"})
 _FALSE_TOKENS: frozenset[str] = frozenset({"false", "no", "off", "0"})
 
+# Filter-capable platform values.  Only these confidently-resolved values
+# activate an injection axis; every other value — the non-filter-capable
+# catch-alls (``markdown`` for issue_adapter, ``other`` for code_hosting), an
+# absent key, a non-string value, or a non-mapping ``platform`` section — leaves
+# that axis unrestricted (``None``), yielding legacy inject-all for that axis.
+_FILTER_CAPABLE_ISSUE_ADAPTERS: frozenset[str] = frozenset({"jira", "github"})
+_FILTER_CAPABLE_CODE_HOSTING: frozenset[str] = frozenset({"github", "azure_devops"})
+
 
 def _coerce_always(value: Any) -> bool:
     """Coerce an ``always`` field value to bool using an explicit allowlist.
@@ -209,3 +220,41 @@ def should_inject(
             return False
 
     return True
+
+
+def resolve_platform_context(platform: Any) -> tuple[str | None, str | None]:
+    """Resolve filter-capable ``(issue_adapter, code_hosting)`` from a platform config.
+
+    Reads a *raw* ``platform`` config section (the value of the ``platform`` key
+    in ``.github/agdt-config.json``) and returns the pair of resolved injection
+    axes suitable for forwarding to :func:`inject_skills`.  Only
+    *confidently-resolved, filter-capable* values activate an axis:
+
+    - ``issue_adapter`` ∈ {``jira``, ``github``}
+    - ``code_hosting`` ∈ {``github``, ``azure_devops``}
+
+    Every other input leaves that axis unrestricted (``None``):
+
+    - non-filter-capable catch-all values (``markdown`` for the adapter axis,
+      ``other`` for the hosting axis),
+    - absent keys,
+    - non-string values, and
+    - a non-mapping ``platform`` argument (including ``None``).
+
+    A ``None`` axis means "inject-all for that axis"; when *both* axes are
+    ``None`` injection is byte-identical to the legacy inject-all behavior.
+
+    The function is pure: it never raises and never mutates *platform*.
+    """
+    if not isinstance(platform, Mapping):
+        return None, None
+
+    raw_adapter = platform.get("issue_adapter")
+    issue_adapter = (
+        raw_adapter if isinstance(raw_adapter, str) and raw_adapter in _FILTER_CAPABLE_ISSUE_ADAPTERS else None
+    )
+
+    raw_hosting = platform.get("code_hosting")
+    code_hosting = raw_hosting if isinstance(raw_hosting, str) and raw_hosting in _FILTER_CAPABLE_CODE_HOSTING else None
+
+    return issue_adapter, code_hosting

agentic_devtools/skill_injector.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import re
 import shutil
 import warnings
+from dataclasses import dataclass
 from pathlib import Path
 
 import yaml
@@ -345,12 +346,32 @@ def _normalize_platform_arg(
 # ---------------------------------------------------------------------------
 
 
-def inject_skills(
+@dataclass(frozen=True)
+class InjectionSummary:
+    """Counts describing the outcome of a skill-injection pass.
+
+    Attributes:
+        injected: Total number of managed ``agdt.*`` skill files selected for
+            injection across both kinds (agents + prompts), de-duplicated by
+            flattened filename within each kind and excluding the generated
+            ``agdt.README.md`` manifests.  This is a best-effort count and can
+            include files counted before a later write-time ``OSError``.
+        pruned: Total number of source files removed by the classification
+            filter across both kinds.  Always ``0`` when neither platform axis
+            is resolved (legacy inject-all), because filtering is skipped
+            entirely in that case.
+    """
+
+    injected: int
+    pruned: int
+
+
+def inject_skills_with_summary(
     git_root: Path | None,
     *,
     issue_adapter: str | None = None,
     code_hosting: str | None = None,
-) -> bool:
+) -> tuple[bool, InjectionSummary]:
     """Mirror bundled agent/prompt files into the target repo.
 
     Places files directly into ``{git_root}/.github/agents/`` and
@@ -375,16 +396,21 @@ def inject_skills(
             :class:`RuntimeWarning`.
 
     Returns:
-        ``True`` when both kinds (agents/prompts) were injected successfully.
-        Returns ``False`` when:
+        A ``(success, summary)`` tuple.  ``success`` is ``True`` when both
+        kinds (agents/prompts) were injected successfully, and ``False`` when:
         - ``git_root`` is ``None``,
         - a source directory for a required kind cannot be resolved,
         - a ``UnicodeDecodeError`` occurs while reading source files (non-UTF8
           content), or
         - an ``OSError`` occurs while writing mirrored files or manifests.
+        ``summary`` is an :class:`InjectionSummary` carrying best-effort counts
+        of injected and pruned files (populated even on the ``OSError`` path).
     """
     if git_root is None:
-        return False
+        return False, InjectionSummary(injected=0, pruned=0)
+
+    injected_total = 0
+    pruned_total = 0
 
     # Normalize both axes: strip whitespace; treat empty strings and
     # unrecognised values as None (unresolved / inject-all for that axis).
@@ -447,6 +473,7 @@ def inject_skills(
             # README manifest reflect only actually-injected files.
             fm_cache: dict[Path, dict[str, object]] = {}
             if issue_adapter is not None or code_hosting is not None:
+                pre_filter_count = len(source_files)
                 filtered: list[Path] = []
                 for src in source_files:
                     try:
@@ -466,6 +493,7 @@ def inject_skills(
                         fm_cache[src] = fm
                         filtered.append(src)
                 source_files = filtered
+                pruned_total += pre_filter_count - len(source_files)
 
             # Build set of flattened filenames for stale-cleanup comparison.
             # Also detect duplicate flat names — would cause silent overwriting.
@@ -503,6 +531,8 @@ def inject_skills(
                 flat_name_origins[flat_name] = src
                 source_rel_names.add(flat_name)
 
+            injected_total += len(source_rel_names)
+
             # Copy files, flattening subdirectory structure into filenames.
             # Iterate the de-duplicated mapping so each flat_name is written
             # exactly once (the last source wins, consistent with the warning).
@@ -548,6 +578,36 @@ def inject_skills(
                 encoding="utf-8",
             )
 
-        return overall_success
+        return overall_success, InjectionSummary(injected=injected_total, pruned=pruned_total)
     except OSError:
-        return False
+        return False, InjectionSummary(injected=injected_total, pruned=pruned_total)
+
+
+# Private-name alias kept for internal/test imports that reference
+# ``_inject_skills_with_summary``.
+_inject_skills_with_summary = inject_skills_with_summary
+
+
+def inject_skills(
+    git_root: Path | None,
+    *,
+    issue_adapter: str | None = None,
+    code_hosting: str | None = None,
+) -> bool:
+    """Mirror bundled agent/prompt files into the target repo (bool wrapper).
+
+    Thin backward-compatible wrapper around
+    :func:`inject_skills_with_summary` that discards the
+    :class:`InjectionSummary` and returns only the success flag.  See
+    :func:`inject_skills_with_summary` for full argument and behavior details.
+
+    Returns:
+        ``True`` when both kinds (agents/prompts) were injected successfully,
+        ``False`` otherwise (see :func:`inject_skills_with_summary`).
+    """
+    success, _summary = inject_skills_with_summary(
+        git_root,
+        issue_adapter=issue_adapter,
+        code_hosting=code_hosting,
+    )
+    return success

{agentic_devtools-0.2.330.dist-info → agentic_devtools-0.2.332.dist-info}/METADATA

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

{agentic_devtools-0.2.330.dist-info → agentic_devtools-0.2.332.dist-info}/RECORD

@@ -1,12 +1,12 @@
 agentic_devtools/__init__.py,sha256=J_Zw_vWKghk-cLmqI83hXQmSiS8zMhGIHM5WPLDkZuo,242
-agentic_devtools/_version.py,sha256=yw4gh-3pxmSlDvPv-VudqAFGlEfaXnJoT9K9vnHE8cM,524
+agentic_devtools/_version.py,sha256=W05wKAPL9NTr_eL2ykSOaNckhAZGNqg5k74bBouriC0,524
 agentic_devtools/agdt_gitignore.py,sha256=aBPBQe7M0GLH8NIp1NsyN9ZiO80fNGOi46IcT5A4SK4,1569
 agentic_devtools/background_tasks.py,sha256=IVC1XJKQzPBP8wCRNCZX_iZCg9FJY_GBUzddSJj7xqw,17473
 agentic_devtools/config.py,sha256=DEVxTVZhsQbVQwO9qdB_1h19aBpjMzF6xJY_ePYLGLs,15629
 agentic_devtools/context_budget.py,sha256=db4w2KzH9Q6rS4k99uyY6eDB7550P8S-ppYV6hYN5nY,13385
 agentic_devtools/file_locking.py,sha256=bhVMxmMKiDn9fYmbAYzIjVfWHG-_br5IfHg7zN5XhHE,6747
-agentic_devtools/skill_classification.py,sha256=_bYuSraEHXGxZ5uq8EMDa3Eh4CuEWW6WtNfCo1V7d9w,7108
-agentic_devtools/skill_injector.py,sha256=W_jMOhsbeKRwozBUbONk0YyETbKtAVgOTAPfcPYBffI,23775
+agentic_devtools/skill_classification.py,sha256=hCeojZ-q33h4pbjs7IuQ2jUWZ3xAOrlSrHOiiQ0sLws,9473
+agentic_devtools/skill_injector.py,sha256=Hjeu9uyoSxiG89jCWlblrm95jnJk5auoTmxm13hDDM4,26226
 agentic_devtools/state.py,sha256=Gy0IQI8rOmwN3sq88HX-OG1wLjyWzZrWwNEyN49DW14,65708
 agentic_devtools/submission_manager.py,sha256=XrKEjxzyH2rX-3HOqIk6KVEjDKAyvjiFzQtg7PyF81w,22056
 agentic_devtools/submission_processor.py,sha256=H05p3juE0q2N4Ru034ig-KG9CLkK2h2u7W45surZP9E,15927
@@ -136,7 +136,7 @@ agentic_devtools/cli/ci/agent_assignment.py,sha256=UFlSNju1exEjDvrzHfiQ5snGcd2ka
 agentic_devtools/cli/ci/commands.py,sha256=Y4dJUuPF9zfXCggyXM_fctatTYqoZ3l0WmvujU-RD6o,6465
 agentic_devtools/cli/ci/delete_review_comments_command.py,sha256=Fqv8zl33oY5z0BmUbyxDAoRxJen8TtgHa1WHDRVaXTU,8237
 agentic_devtools/cli/ci/exceptions.py,sha256=zpKWOgnBbHHQgAQRvdRW4VFnE_qdgqgmo8r1H-x47l4,1086
-agentic_devtools/cli/ci/github_provider.py,sha256=Qqsn6-nguIgB0KZJ_R1XmbR5V0PQtTx9EL7_3Fx8Xtc,202343
+agentic_devtools/cli/ci/github_provider.py,sha256=296yPPaNFtedDM1o_aa6JAVOs8t_qGOVSR1EiXyXznE,200944
 agentic_devtools/cli/ci/guards.py,sha256=-kfmTMb4KoMeyHFTUJjfDWoXbNZ3waX-9NdBrq1Bcy4,26927
 agentic_devtools/cli/ci/job_logs.py,sha256=s3Ufinl2WQPVISq8g11ZXU5GJ0WCKDmZlbyGJzvJEVU,9911
 agentic_devtools/cli/ci/logging_config.py,sha256=Tw_h8LB709gbMd0WZMATLAPIJ1r_c_nE18Bi4bvldHA,2340
@@ -161,7 +161,7 @@ agentic_devtools/cli/ci/pipeline/command.py,sha256=CmsncrER2mgFYz8QAl5NbVzaCLdoH
 agentic_devtools/cli/ci/pipeline/deferral.py,sha256=bNw5znZ0k_fhP1AdPo6hgZ9y-q86JrE-v_nBf1XJBSM,8241
 agentic_devtools/cli/ci/pipeline/exceptions.py,sha256=4UXy2weeQZex_lp4sILNxlYfGjetxbR-tjms2ReT4iw,451
 agentic_devtools/cli/ci/pipeline/exclusion.py,sha256=mrOG5G1-m3U-GM4YgtMTuzmoj02TXB6GbNxemRoLtV4,931
-agentic_devtools/cli/ci/pipeline/gate_verdict.py,sha256=PpZCakSiKSwzyLCodJ_mTIR4LB11sIHtSwldsk9SZn0,17723
+agentic_devtools/cli/ci/pipeline/gate_verdict.py,sha256=Fv_sOYIYGtJ5AczBxjTaI6rVOUYlCpfMSSl8kdO8C18,17997
 agentic_devtools/cli/ci/pipeline/models.py,sha256=L7qhU286K9TB6b_g6N9G-_aeYkDHRVM1JJ1Q0dWrt5U,2166
 agentic_devtools/cli/ci/pipeline/runner.py,sha256=lUJNXPZKbI7Tfkj_xC2-_Im4RqkRbh-vsMbRCJCATlo,9657
 agentic_devtools/cli/ci/pipeline/session_detector.py,sha256=dWJyZIv7NcJNUl7TIsYqNfzNmZu3vAxHaQp1wMqe70o,8926
@@ -171,7 +171,7 @@ agentic_devtools/cli/ci/pipeline/summary.py,sha256=CCvIPuje1hYvR1OIgogF-2SN5au_S
 agentic_devtools/cli/ci/pipeline/actions/__init__.py,sha256=HbtdDtLr_ut8qWedTCRuZujKHWqo8lJfymxPpLoDF5E,1292
 agentic_devtools/cli/ci/pipeline/actions/apply_suggestions.py,sha256=HuCdn-cFvMJ_inEEBXI1A6eOE9voUBk7DRkiJGgxvtc,21149
 agentic_devtools/cli/ci/pipeline/actions/approve.py,sha256=CZKPihPg6L1o_8AymoGsnX5BfujCbYB8q5xr8VQ6YY8,6584
-agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py,sha256=eo-DTOBbnN3xw4yXKRe2yJczK8CluaEgCkpBX3IOc-0,14533
+agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py,sha256=8WCjpLsTSdTUCQCo4XBQI2EMTepuIbNHQo4YaIipeq8,16194
 agentic_devtools/cli/ci/pipeline/actions/guards.py,sha256=UIkTgv5_aKqSVNRFlvl_JiAdFswm1uV5VJJfgu5FmFc,4101
 agentic_devtools/cli/ci/pipeline/actions/merge.py,sha256=LOfPoYITFrvpO9H5UJHiXnbykStT0J3GnCmfJiGDVrA,9925
 agentic_devtools/cli/ci/pipeline/actions/publish.py,sha256=A00Lk-vZKnhOCN2O5mkks0tayr7NA5eZfUA95CUP7gs,3990
@@ -240,7 +240,8 @@ agentic_devtools/cli/github/__init__.py,sha256=HmNZ0PuYe8owe8qS5j5C1MzrKi772eGCM
 agentic_devtools/cli/github/apply_thread_autofix.py,sha256=PBJ8MwWaB92lCBOOzc-3S7ykYf5i2CswFUo-4XUneL0,32037
 agentic_devtools/cli/github/async_commands.py,sha256=2drgrnay85RVR_oj1j7-qdBv-uusAvgvUbKwvNmO6o0,33688
 agentic_devtools/cli/github/browser_apply_autofix.py,sha256=j13V7djjMrdOJikYaK8x4z1soe9Su6wQ6zq7L1uXCS8,19441
-agentic_devtools/cli/github/copilot_review_status.py,sha256=g5CG1x5ojCKrOsYB5MaKLgX8M4aeYewUMqngN6Oc1yQ,15646
+agentic_devtools/cli/github/ccr_review_format.py,sha256=2VDug2ApSjBmU5Hk53Nd8jIjR4Y6ciL91qw_w79IyOs,11028
+agentic_devtools/cli/github/copilot_review_status.py,sha256=2infcWJe_bg4vLHDI6XHLL863lQJybnMqc7anuG63Cw,17987
 agentic_devtools/cli/github/issue_commands.py,sha256=bZYs_0n-T3V4WlG2BX-xK4qH9uqk4e20fpvWWf3ZV6w,19964
 agentic_devtools/cli/github/issue_dedup.py,sha256=g9HEX3tbAbZjt_Z9FN8WXD_d-mhDUajrS2Gne7nJ1EY,3432
 agentic_devtools/cli/github/issue_dedup_integration.py,sha256=C9-0nMds7jZOKweNMT09yONcvtH6X6k88TH3yOpsnvc,14433
@@ -300,7 +301,7 @@ agentic_devtools/cli/segments/commands.py,sha256=ah0sdZXSVQ-L2G0RtwJ6iEYLmred8cN
 agentic_devtools/cli/setup/__init__.py,sha256=-VWMVxm_3UrXEqbxRZi-dG8Wbzq8H4o4HsJP9RAHbaI,1520
 agentic_devtools/cli/setup/autorun.py,sha256=vJfXqTIL-JxbUZUvymq2CQsKfftpkRYvvgdNjYSBmbg,6868
 agentic_devtools/cli/setup/autorun_resolution.py,sha256=w0lOKbVH7h_uOOd5XSm9CUZBXkhns197K-SoILSDKGQ,3034
-agentic_devtools/cli/setup/commands.py,sha256=_YU2f0Bh3DUt8XRyN5JBSf74MawSQ9zOMFbDn_0KEmE,83973
+agentic_devtools/cli/setup/commands.py,sha256=XaqhbjxASRYgzlg-cqO_JR3zXDHngFockyohJSgKRWw,87854
 agentic_devtools/cli/setup/commit_template_setup.py,sha256=DRcLUWxIZrfiu5BaoH_qo6bZBFQlp9cdiAmweTM3c_A,4886
 agentic_devtools/cli/setup/copilot-instructions.md,sha256=UGAHBwSMRPY1d4vd_HySkF5-d7D5iVfNWF0rcwBkrZw,1083
 agentic_devtools/cli/setup/copilot_cli_installer.py,sha256=yHGDQ32K5jLykD5RuY3lmk2FH7k36fsqrZxnKazurLg,10056
@@ -888,8 +889,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.330.dist-info/METADATA,sha256=JwWbNGOi0QUWoBNeBH3jwqzH5wsKvDFnYYnTme03SSk,29796
-agentic_devtools-0.2.330.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-agentic_devtools-0.2.330.dist-info/entry_points.txt,sha256=Xs0VhRkREzs61FdX63Ed1qa1-WDeBppn7BvMdRIYYZ4,11395
-agentic_devtools-0.2.330.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.330.dist-info/RECORD,,
+agentic_devtools-0.2.332.dist-info/METADATA,sha256=2BJ-K1TYEWIAepVS_EtES8e15vcoX5DWhAWiTDoQOKU,29796
+agentic_devtools-0.2.332.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentic_devtools-0.2.332.dist-info/entry_points.txt,sha256=Xs0VhRkREzs61FdX63Ed1qa1-WDeBppn7BvMdRIYYZ4,11395
+agentic_devtools-0.2.332.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.332.dist-info/RECORD,,