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

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

@@ -87,10 +87,10 @@ class ApplySuggestionsAction:
             snapshot.review_state == "CHANGES_REQUESTED"
             or (snapshot.review_state == "COMMENTED" and snapshot.copilot_review_inline_count != 0)
         )
-        has_unresolved_prior_threads = snapshot.unresolved_threads > 0
-        preconditions["has_actionable_review"] = has_actionable_review or has_unresolved_prior_threads
+        has_repairable_threads = snapshot.repairable_threads > 0
+        preconditions["has_actionable_review"] = has_actionable_review or has_repairable_threads
 
-        if not has_actionable_review and not has_unresolved_prior_threads:
+        if not has_actionable_review and not has_repairable_threads:
             return ActionResult(
                 name=self.name,
                 decision=ActionDecision.SKIP,

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

@@ -9,7 +9,7 @@ from agentic_devtools.cli.ci.guards import (
     check_deduplication,
     is_duplicate_trigger,
 )
-from agentic_devtools.cli.ci.models import ReviewInfo
+from agentic_devtools.cli.ci.models import ReviewCommentInfo, ReviewInfo
 from agentic_devtools.cli.ci.pipeline.deferral import read_active_suppressed_deferral
 from agentic_devtools.cli.ci.pipeline.exclusion import ExclusionContext
 from agentic_devtools.cli.ci.pipeline.gate_verdict import (
@@ -17,10 +17,14 @@ from agentic_devtools.cli.ci.pipeline.gate_verdict import (
     REASON_NEW_CCR_NOT_APPROVED,
     REASON_SUPPRESSED_COMMENTS,
     REASON_UNPARSED_SUPPRESSION,
-    select_prior_actionable_reviews,
+    is_copilot_or_synthetic_review,
 )
 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.pipeline.snapshot import (
+    REPAIRABLE_REVIEW_STATES,
+    DerivedState,
+    PRStateSnapshot,
+)
 from agentic_devtools.cli.ci.provider import CIPlatformProvider
 from agentic_devtools.cli.github.ccr_review_format import parse_suppressed_count
 
@@ -98,16 +102,13 @@ def _is_copilot_review_actionable(snapshot: PRStateSnapshot) -> bool:
     return _actionable_copilot_review_id(snapshot) > 0
 
 
-def _list_prior_actionable_copilot_reviews(snapshot: PRStateSnapshot) -> list[ReviewInfo]:
-    """Return actionable Copilot reviews not already owned by the gate verdict.
-
-    Provenance is scoped to the gate verdict's ``review_id`` (not HEAD's commit
-    SHA) via the shared :func:`select_prior_actionable_reviews` predicate, so a
-    HEAD move alone (e.g. ``squash``/``takeover``) cannot change the selection.
-    """
-    verdict = snapshot.copilot_gate_verdict
-    verdict_review_id = verdict.review_id if verdict is not None else 0
-    return select_prior_actionable_reviews(snapshot.reviews, verdict_review_id)
+def _list_repairable_copilot_reviews(snapshot: PRStateSnapshot) -> list[ReviewInfo]:
+    """Return Copilot/synthetic reviews that can own repairable unresolved threads."""
+    return [
+        review
+        for review in snapshot.reviews
+        if is_copilot_or_synthetic_review(review) and review.state in REPAIRABLE_REVIEW_STATES
+    ]
 
 
 def _declared_suppressed_counts_by_review(snapshot: PRStateSnapshot, review_ids: list[int]) -> dict[int, int]:
@@ -134,11 +135,77 @@ def _has_stuck_prior_review_threads(snapshot: PRStateSnapshot) -> bool:
     return (
         snapshot.ci_status == "passing"
         and snapshot.copilot_review_id == 0
-        and snapshot.unresolved_threads > 0
-        and bool(_list_prior_actionable_copilot_reviews(snapshot))
+        and snapshot.repairable_threads > 0
+        and bool(_list_repairable_copilot_reviews(snapshot))
     )
 
 
+def _select_repairable_thread_owner_reviews(
+    provider: CIPlatformProvider,
+    snapshot: PRStateSnapshot,
+    repairable_reviews: list[ReviewInfo],
+) -> tuple[list[ReviewInfo], dict[int, list[ReviewCommentInfo]]]:
+    """Return reviews that own unresolved repairable threads, plus fetched comments."""
+    thread_lookup = getattr(provider, "list_review_threads_by_thread_id", None)
+    if not callable(thread_lookup):
+        return repairable_reviews, {}
+
+    try:
+        thread_states = thread_lookup(snapshot.pr_number)
+    except Exception as exc:
+        logger.warning(
+            "PR #%d: Failed to derive repairable-thread ownership from thread state: %s",
+            snapshot.pr_number,
+            exc,
+        )
+        return repairable_reviews, {}
+
+    if not isinstance(thread_states, dict):
+        return repairable_reviews, {}
+
+    # Validate the entire mapping before processing: fall back to all candidates on any
+    # malformed entry so a mixed valid/malformed mapping never silently excludes an owning
+    # review from the repair payload.
+    for state in thread_states.values():
+        if not (
+            isinstance(state, tuple)
+            and len(state) == 2
+            and type(state[0]) is bool
+            and isinstance(state[1], tuple)
+            and all(type(c) is int and c >= 0 for c in state[1])
+        ):
+            logger.warning(
+                "PR #%d: Malformed thread state entry detected; falling back to all repairable reviews.",
+                snapshot.pr_number,
+            )
+            return repairable_reviews, {}
+
+    unresolved_comment_ids = {comment_id for state in thread_states.values() if not state[0] for comment_id in state[1]}
+    if not unresolved_comment_ids:
+        return repairable_reviews, {}
+
+    owner_ids: set[int] = set()
+    comments_by_review_id: dict[int, list[ReviewCommentInfo]] = {}
+    for review in repairable_reviews:
+        try:
+            comments = provider.list_review_comments(snapshot.pr_number, review.id)
+        except Exception as exc:
+            logger.warning(
+                "PR #%d: Failed to derive repairable-thread ownership from review %d comments: %s",
+                snapshot.pr_number,
+                review.id,
+                exc,
+            )
+            return repairable_reviews, {}
+        comments_by_review_id[review.id] = comments
+        if any(comment.id in unresolved_comment_ids for comment in comments if comment.id >= 0):
+            owner_ids.add(review.id)
+
+    if not owner_ids:
+        return repairable_reviews, comments_by_review_id
+    return [review for review in repairable_reviews if review.id in owner_ids], comments_by_review_id
+
+
 class DispatchRepairAction:
     """Dispatch a repair when CI fails or actionable review feedback exists.
 
@@ -252,23 +319,74 @@ class DispatchRepairAction:
 
         actionable_review_id = _actionable_copilot_review_id(snapshot)
         review_actionable = actionable_review_id > 0
-        prior_reviews = _list_prior_actionable_copilot_reviews(snapshot)
-        prior_reviews.sort(
+        repairable_reviews = _list_repairable_copilot_reviews(snapshot)
+        repairable_reviews.sort(
             key=lambda r: (
                 r.submitted_at if isinstance(r.submitted_at, str) else "",
                 r.id,
             ),
             reverse=True,
         )
+        repairable_owner_reviews = repairable_reviews
+        ownership_comments_cache: dict[int, list[ReviewCommentInfo]] = {}
         stuck_prior_threads = _has_stuck_prior_review_threads(snapshot)
+        if stuck_prior_threads and repairable_reviews:
+            repairable_owner_reviews, ownership_comments_cache = _select_repairable_thread_owner_reviews(
+                provider,
+                snapshot,
+                repairable_reviews,
+            )
         ci_failing = snapshot.ci_status == "failing"
         ci_passing = snapshot.ci_status == "passing"
         # Use the *effective* actionable review id (the review the gate evaluated),
         # which may differ from ``copilot_review_id`` for a new-CCR review or a
         # prior-commit review selected by diff-hash freshness.
-        review_context_id = (
-            actionable_review_id if review_actionable else (prior_reviews[0].id if stuck_prior_threads else 0)
-        )
+        review_context_id = actionable_review_id
+        # True when the multi-owner loop below already checked is_duplicate_trigger for the
+        # chosen review_context_id; suppresses the redundant general check that follows.
+        _review_context_dedup_checked = False
+        if not review_actionable and stuck_prior_threads and repairable_owner_reviews:
+            # Find the first owner review that does not already have an active trigger
+            # marker.  Picking [0] blindly stalls the pipeline permanently when [0] is
+            # already marked but a later owner has never been dispatched.
+            chosen_id = 0
+            all_owners_duplicated = True
+            for _candidate in repairable_owner_reviews:
+                try:
+                    if not is_duplicate_trigger(provider, snapshot.pr_number, _candidate.id):
+                        chosen_id = _candidate.id
+                        all_owners_duplicated = False
+                        _review_context_dedup_checked = True
+                        break
+                except Exception as _exc:
+                    logger.warning(
+                        "PR #%d: Review-ID dedup check failed for candidate review %d: %s",
+                        snapshot.pr_number,
+                        _candidate.id,
+                        _exc,
+                    )
+                    # Fail-open: use this candidate and proceed with dispatch.
+                    # Mark as checked so the general dedup block below does not retry
+                    # the same call on a transient API error.
+                    chosen_id = _candidate.id
+                    all_owners_duplicated = False
+                    _review_context_dedup_checked = True
+                    break
+            if all_owners_duplicated:
+                _all_ids = [r.id for r in repairable_owner_reviews]
+                logger.info(
+                    "PR #%d: Trigger comment already exists for all repairable owner reviews %s — skipping",
+                    snapshot.pr_number,
+                    _all_ids,
+                )
+                return ActionResult(
+                    name=self.name,
+                    decision=ActionDecision.SKIP,
+                    details=f"Repair already dispatched for all repairable owner reviews: {_all_ids}",
+                )
+            # Invariant: all_owners_duplicated is False only when a candidate break set chosen_id.
+            assert chosen_id > 0  # noqa: S101
+            review_context_id = chosen_id
         if review_context_id > 0:
             # Check for an active suppressed-comment deferral marker only when the
             # deferred review is the sole repair reason.  CI failures and stuck
@@ -295,25 +413,27 @@ class DispatchRepairAction:
                         exc,
                     )
 
-            # Check review-ID level deduplication first (FR-012).
-            # Applies to both normal actionable reviews on HEAD and stuck prior-review
-            # thread repairs (where review context is from a prior commit review).
-            try:
-                if is_duplicate_trigger(provider, snapshot.pr_number, review_context_id):
-                    logger.info(
-                        "PR #%d: Trigger comment already exists for review_id=%d — skipping",
-                        snapshot.pr_number,
-                        review_context_id,
-                    )
-                    return ActionResult(
-                        name=self.name,
-                        decision=ActionDecision.SKIP,
-                        details=f"Repair already dispatched for review_id={review_context_id}",
-                    )
-            except Exception as exc:
-                logger.warning("PR #%d: Review-ID dedup check failed: %s", snapshot.pr_number, exc)
-                # Fail-open: proceed with dispatch on transient API failures; the
-                # review-ID dedup guard is best-effort and should not block repair.
+            # Check review-ID level deduplication (FR-012).
+            # Applies to normal actionable reviews on HEAD and stuck prior-review thread
+            # repairs.  Skipped when the multi-owner loop above already confirmed that
+            # review_context_id is not duplicated, to avoid a redundant double call.
+            if not _review_context_dedup_checked:
+                try:
+                    if is_duplicate_trigger(provider, snapshot.pr_number, review_context_id):
+                        logger.info(
+                            "PR #%d: Trigger comment already exists for review_id=%d — skipping",
+                            snapshot.pr_number,
+                            review_context_id,
+                        )
+                        return ActionResult(
+                            name=self.name,
+                            decision=ActionDecision.SKIP,
+                            details=f"Repair already dispatched for review_id={review_context_id}",
+                        )
+                except Exception as exc:
+                    logger.warning("PR #%d: Review-ID dedup check failed: %s", snapshot.pr_number, exc)
+                    # Fail-open: proceed with dispatch on transient API failures; the
+                    # review-ID dedup guard is best-effort and should not block repair.
 
         dedup_kwargs = {"max_dispatches": 1} if ci_failing and not (review_actionable or stuck_prior_threads) else {}
 
@@ -388,12 +508,9 @@ class DispatchRepairAction:
         declared_author_comment_counts_by_review: dict[int, int] = {}
         if review_repair_needed and review_context_id:
             if stuck_prior_threads:
-                prior_ids = [r.id for r in prior_reviews]
-                # When the verdict review is also actionable, include it alongside the prior
-                # reviews so its comments appear in the repair payload.  Deduplicate in case
-                # review_context_id is already present in prior_ids.
-                extra = [review_context_id] if review_actionable and review_context_id not in prior_ids else []
-                review_ids = prior_ids + extra
+                review_ids = [r.id for r in repairable_owner_reviews]
+                if review_context_id not in review_ids:
+                    review_ids.append(review_context_id)
             else:
                 review_ids = [review_context_id]
             declared_author_comment_counts_by_review = _declared_suppressed_counts_by_review(snapshot, review_ids)
@@ -401,7 +518,10 @@ class DispatchRepairAction:
             seen_comment_keys: set[tuple[int, int]] = set()
             for review_id in review_ids:
                 try:
-                    for comment in provider.list_review_comments(snapshot.pr_number, review_id):
+                    comments = ownership_comments_cache.get(review_id)
+                    if comments is None:
+                        comments = provider.list_review_comments(snapshot.pr_number, review_id)
+                    for comment in comments:
                         dedup_key = (review_id, comment.id) if comment.id < 0 else (0, comment.id)
                         if dedup_key in seen_comment_keys:
                             continue

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

@@ -111,7 +111,7 @@ class ResolveThreadsAction:
         from agentic_devtools.cli.ci.pipeline.gate_verdict import select_prior_actionable_reviews
 
         verdict = snapshot.copilot_gate_verdict
-        verdict_review_id = verdict.review_id if verdict is not None else 0
+        verdict_review_id = verdict.review_id if verdict is not None and verdict.review_id > 0 else None
         prior_reviews = select_prior_actionable_reviews(snapshot.reviews, verdict_review_id)
 
         if not prior_reviews:
@@ -175,23 +175,36 @@ class ResolveThreadsAction:
         # same source the snapshot uses. The provider's thread-signals cache is
         # invalidated by the resolve/unresolve mutations, so this observes the
         # post-resolution state.
-        requeried, degraded = count_unresolved_prior_threads(
-            provider, snapshot.pr_number, snapshot.reviews, verdict_review_id
+        requeried_blocking, requeried_repairable, degraded, unknown_provenance = count_unresolved_prior_threads(
+            provider,
+            snapshot.pr_number,
+            snapshot.reviews,
+            verdict_review_id,
+            verdict=verdict,
         )
         if degraded:
             # Thread state is unavailable — fail closed with the conservative
             # pre-re-query estimate and the helper's degraded sentinel rather
             # than trusting an unknown count.
-            unresolved_total = max(requeried, unresolved, snapshot.unresolved_threads - resolved, 0)
+            unresolved_total = max(requeried_blocking, unresolved, snapshot.unresolved_threads - resolved, 0)
+            # ``resolved`` is a per-review aggregate and can double-count the same
+            # underlying thread across reviews. Preserve the previously measured
+            # repairable inventory when re-query is degraded instead of subtracting
+            # this non-deduplicated value.
+            repairable_total = max(requeried_repairable, snapshot.repairable_threads, 0)
         else:
-            unresolved_total = requeried
+            unresolved_total = requeried_blocking
+            repairable_total = requeried_repairable
+
         derived.set("unresolved_threads", unresolved_total)
-        # Propagate the re-query's degraded status so downstream actions
-        # (approve, merge) know whether the thread count is authoritative.
+        derived.set("repairable_threads", repairable_total)
+        # Propagate the re-query's degraded and unknown_provenance status so downstream
+        # actions (approve, merge) know whether the thread count is authoritative.
         # A failed re-query after a healthy snapshot must mark state as degraded
         # (not leave the snapshot's False in place); a successful re-query
         # replaces whatever the snapshot held.
         derived.set("unresolved_threads_degraded", degraded)
+        derived.set("unresolved_threads_unknown_provenance", unknown_provenance)
 
         details = f"Resolved {resolved} thread(s), {unresolved_total} left open"
         if suppressed:

agentic_devtools/cli/ci/pipeline/gate_verdict.py

@@ -503,7 +503,7 @@ def copilot_review_gate_passed(
     )
 
 
-def select_prior_actionable_reviews(reviews: list[ReviewInfo], verdict_review_id: int) -> list[ReviewInfo]:
+def select_prior_actionable_reviews(reviews: list[ReviewInfo], verdict_review_id: int | None) -> list[ReviewInfo]:
     """Return actionable Copilot/synthetic reviews not already owned by the gate verdict.
 
     This is the **single** definition of the "which reviews count as prior" predicate.
@@ -520,11 +520,11 @@ def select_prior_actionable_reviews(reviews: list[ReviewInfo], verdict_review_id
     thread (e.g. ``squash``/``takeover`` minting a new commit SHA) does not change
     the selection, unlike a HEAD-commit-SHA comparison.
 
-    Fails closed: when *verdict_review_id* is ``<= 0`` (no verdict evaluated, or
-    evaluation failed), every actionable review is treated as prior — i.e. this
-    degenerates to counting all of them, never fewer. Input order is preserved.
+    Fails closed: when provenance is unknown (``verdict_review_id`` is ``None`` or
+    ``<= 0``) every actionable review is treated as prior — i.e. this degenerates
+    to counting all of them, never fewer. Input order is preserved.
     """
-    if verdict_review_id <= 0:
+    if verdict_review_id is None or verdict_review_id <= 0:
         return [r for r in reviews if is_copilot_or_synthetic_review(r) and r.state in _ACTIONABLE_PRIOR_REVIEW_STATES]
     return [
         r

agentic_devtools/cli/ci/pipeline/snapshot.py

@@ -61,6 +61,17 @@ class PRStateSnapshot:
             mapping omitted selected comments, or a review's comments could not be
             listed), so ``unresolved_threads`` is unknown. The gate fails closed on this signal and
             the run summary reports "degraded / unknown" instead of a fabricated integer.
+        unresolved_threads_unknown_provenance: Whether the gate-verdict review ID could not be
+            resolved when ``unresolved_threads`` was computed, so the count covers *all*
+            actionable reviews (the conservative count-all floor) rather than being scoped
+            to reviews whose ID differs from the verdict's owner. The count is still
+            authoritative — it is the maximum possible value — but consumers can use this
+            flag to emit extra diagnostics. No additional gate blocking is required: the
+            count-all strategy is already the most conservative possible reading.
+        repairable_threads: Number of all unresolved Copilot review threads from any
+            actionable Copilot review (current or prior). Unlike ``unresolved_threads``,
+            this is independent of the gate verdict and is used solely to determine if
+            there is repairable work, decoupled from whether those threads are blocking.
         labels: List of labels on the PR.
         is_draft: Whether the PR is a draft.
         mergeable: Whether the PR is mergeable (None if unknown).
@@ -134,6 +145,8 @@ class PRStateSnapshot:
     copilot_review_pending: bool = False
     unresolved_threads: int = 0
     unresolved_threads_degraded: bool = False
+    repairable_threads: int = 0
+    unresolved_threads_unknown_provenance: bool = False
     labels: list[str] = field(default_factory=list)
     is_draft: bool = False
     mergeable: bool | None = None
@@ -195,6 +208,7 @@ class DerivedState:
 
 
 _DEFAULT_ACTIONABLE_CHECK_NAMES = DEFAULT_ACTIONABLE_CHECK_NAMES
+REPAIRABLE_REVIEW_STATES = frozenset({"CHANGES_REQUESTED", "COMMENTED", "APPROVED"})
 
 
 def build_pr_state_snapshot(
@@ -336,8 +350,19 @@ def build_pr_state_snapshot(
     # as "prior". When the verdict evaluation above failed closed, its review_id
     # defaults to 0, so this degrades explicitly to count-all — the same
     # fail-closed direction the verdict itself takes on exception.
-    unresolved_threads, unresolved_threads_degraded = count_unresolved_prior_threads(
-        provider, pr_number, reviews, copilot_gate_verdict.review_id
+    effective_verdict_review_id = (
+        copilot_gate_verdict.review_id
+        if copilot_gate_verdict is not None and copilot_gate_verdict.review_id > 0
+        else None
+    )
+    unresolved_threads, repairable_threads, unresolved_threads_degraded, unresolved_threads_unknown_provenance = (
+        count_unresolved_prior_threads(
+            provider,
+            pr_number,
+            reviews,
+            effective_verdict_review_id,
+            verdict=copilot_gate_verdict,
+        )
     )
 
     # Whether the Copilot review actually evaluated by the gate still matches HEAD.
@@ -404,6 +429,8 @@ def build_pr_state_snapshot(
         copilot_review_pending=copilot_review_pending,
         unresolved_threads=unresolved_threads,
         unresolved_threads_degraded=unresolved_threads_degraded,
+        repairable_threads=repairable_threads,
+        unresolved_threads_unknown_provenance=unresolved_threads_unknown_provenance,
         labels=list(pr_meta.labels),
         is_draft=pr_meta.is_draft,
         mergeable=pr_meta.mergeable,
@@ -472,38 +499,93 @@ def _is_copilot_review_pending(requested_reviewers: list[str]) -> bool:
     return any(is_copilot_login(reviewer) for reviewer in requested_reviewers)
 
 
+def _effective_thread_owner_verdict_id(
+    verdict_review_id: int | None,
+    verdict: CopilotGateVerdict | None,
+) -> int | None:
+    """Resolve the effective thread-owner review ID for merge-gate provenance.
+
+    ``None`` represents unknown provenance, which is the fail-closed signal for
+    the count-all path. When a verdict object is present it is authoritative:
+    a positive ``verdict.review_id`` is used, otherwise provenance remains
+    unknown. The legacy integer is used only when no verdict object is supplied.
+    """
+    if verdict is not None:
+        if verdict.review_id > 0:
+            return verdict.review_id
+        return None
+    if verdict_review_id is not None and verdict_review_id > 0:
+        return verdict_review_id
+    return None
+
+
 def count_unresolved_prior_threads(
     provider: CIPlatformProvider,
     pr_number: int,
     reviews: list[ReviewInfo],
-    verdict_review_id: int,
-) -> tuple[int, bool]:
-    """Count unresolved Copilot or trusted synthetic review threads not owned by the gate verdict.
-
-    Returns a ``(count, degraded)`` pair. ``count`` is the number of distinct
-    review threads from genuine Copilot or trusted synthetic reviews — other than
-    the one the gate verdict already accounts for (``verdict_review_id``) — whose
-    provider-reported state is unresolved.
+    verdict_review_id: int | None,
+    *,
+    verdict: CopilotGateVerdict | None = None,
+) -> tuple[int, int, bool, bool]:
+    """Count unresolved Copilot or trusted synthetic review threads.
+
+    Returns a ``(blocking_count, repairable_count, degraded, unknown_provenance)`` tuple.
+    ``blocking_count`` (unresolved_threads) is the number of distinct review threads
+    from genuine Copilot or trusted synthetic reviews — other than the one the gate
+    verdict already accounts for (``verdict_review_id``) — whose provider-reported
+    state is unresolved.
+
+    ``repairable_count`` (repairable_threads) is the total number of unresolved
+    threads from ALL genuine or trusted Copilot reviews (including APPROVED reviews),
+    regardless of whether they are owned by the gate verdict. This decoupled count
+    allows the repair agent to detect genuinely repairable state even when a gate
+    block zeroes out the blocking count.
 
     Provenance is scoped to ``verdict_review_id``, not to HEAD's commit SHA: this
     keeps the count HEAD-independent, so a HEAD move that touches no review or
     thread (e.g. ``squash``/``takeover`` minting a new commit) cannot change it.
     When ``verdict_review_id <= 0`` (no verdict evaluated, or evaluation failed
-    closed), this explicitly degenerates to counting every actionable review —
-    the same fail-closed direction the verdict itself takes.
+    closed), this explicitly degenerates to counting every actionable review for
+    the blocking count — the same fail-closed direction the verdict itself takes.
 
     When the provider cannot report review-thread state (the capability is
     missing, the lookup failed, the returned mapping omits selected comments, or
-    a review's comments could not be listed), ``degraded`` is True: the count
-    falls back to the minimum blocking floor of ``1`` so a capability-less
-    provider can never present as "0 unresolved threads" and silently open the
-    merge gate. Every such degradation is logged, so no thread is ever dropped
-    from the count without a diagnostic.
+    a review's comments could not be listed), ``degraded`` is True. Degradation is
+    tracked separately for blocking and repairable inventories:
+    ``blocking_count`` is floored to ``1`` only when blocking inventory is unknown,
+    while ``repairable_count`` is floored to ``1`` when repairable inventory is
+    unknown and no unresolved repairable threads were measured. This prevents
+    false-open merge gates and also prevents repair dispatch from stalling behind
+    an unknown-but-possible repairable inventory.
+    Every degradation is logged, so no thread is ever dropped from the count
+    without a diagnostic.
     """
-    prior_copilot_reviews = select_prior_actionable_reviews(reviews, verdict_review_id)
-    if not prior_copilot_reviews:
+    effective_review_id = _effective_thread_owner_verdict_id(verdict_review_id, verdict)
+    unknown_provenance = effective_review_id is None
+    if unknown_provenance:
+        logger.warning(
+            "PR #%d: no concrete thread-owner provenance for prior actionable reviews; "
+            "falling back to count-all (conservative floor — not a query failure)",
+            pr_number,
+        )
+
+    # All genuine/trusted Copilot reviews are candidates for repairable-thread counting,
+    # regardless of their verdict state (APPROVED reviews can still have unresolved threads).
+    all_copilot_reviews = [
+        r for r in reviews if is_copilot_or_synthetic_review(r) and r.state in REPAIRABLE_REVIEW_STATES
+    ]
+    if not all_copilot_reviews:
         # Nothing to report on — no capability was needed, so this is not degraded.
-        return 0, False
+        return 0, 0, False, unknown_provenance
+
+    # Blocking classification still uses the filtered (CHANGES_REQUESTED/COMMENTED) set.
+    blocking_review_ids = {r.id for r in select_prior_actionable_reviews(reviews, effective_review_id)}
+
+    def _unknown_inventory_fallback(unknown_provenance: bool) -> tuple[int, int, bool, bool]:
+        blocking_floor = 1 if blocking_review_ids else 0
+        # We have at least one repairable review candidate, but inventory is
+        # unknown; fail closed so repair paths do not stall.
+        return blocking_floor, 1, True, unknown_provenance
 
     thread_lookup = getattr(provider, "list_review_threads_by_thread_id", None)
     if not callable(thread_lookup):
@@ -512,7 +594,7 @@ def count_unresolved_prior_threads(
             " — failing closed with an unknown-thread count",
             pr_number,
         )
-        return 1, True
+        return _unknown_inventory_fallback(unknown_provenance)
 
     try:
         thread_states = thread_lookup(pr_number)
@@ -522,14 +604,14 @@ def count_unresolved_prior_threads(
             " — failing closed with an unknown-thread count",
             pr_number,
         )
-        return 1, True
+        return _unknown_inventory_fallback(unknown_provenance)
     except Exception as exc:
         logger.warning(
             "PR #%d: review-thread state unavailable (%s) — failing closed with an unknown-thread count",
             pr_number,
             str(exc)[:200],
         )
-        return 1, True
+        return _unknown_inventory_fallback(unknown_provenance)
 
     if not isinstance(thread_states, dict):
         logger.warning(
@@ -539,7 +621,7 @@ def count_unresolved_prior_threads(
             pr_number,
             type(thread_states).__name__,
         )
-        return 1, True
+        return _unknown_inventory_fallback(unknown_provenance)
 
     comment_to_thread: dict[int, str] = {}
     for thread_key, state in thread_states.items():
@@ -552,7 +634,7 @@ def count_unresolved_prior_threads(
                 pr_number,
                 thread_key,
             )
-            return 1, True
+            return _unknown_inventory_fallback(unknown_provenance)
         if not isinstance(state, tuple) or len(state) != 2 or type(state[0]) is not bool:
             logger.warning(
                 "PR #%d: review-thread state unavailable "
@@ -563,7 +645,7 @@ def count_unresolved_prior_threads(
                 thread_key,
                 state,
             )
-            return 1, True
+            return _unknown_inventory_fallback(unknown_provenance)
         comment_ids = state[1]
         if not isinstance(comment_ids, tuple):
             logger.warning(
@@ -572,7 +654,7 @@ def count_unresolved_prior_threads(
                 " — failing closed with an unknown-thread count",
                 pr_number,
             )
-            return 1, True
+            return _unknown_inventory_fallback(unknown_provenance)
         for comment_id in comment_ids:
             if type(comment_id) is not int:
                 logger.warning(
@@ -584,7 +666,7 @@ def count_unresolved_prior_threads(
                     thread_key,
                     comment_id,
                 )
-                return 1, True
+                return _unknown_inventory_fallback(unknown_provenance)
             mapped_thread = comment_to_thread.get(comment_id)
             if mapped_thread is not None and mapped_thread != thread_key:
                 logger.warning(
@@ -597,27 +679,34 @@ def count_unresolved_prior_threads(
                     mapped_thread,
                     thread_key,
                 )
-                return 1, True
+                return _unknown_inventory_fallback(unknown_provenance)
             comment_to_thread[comment_id] = thread_key
 
-    total_unresolved = 0
-    missing_thread_state = False
-    comments_unavailable = False
-    counted_thread_ids: set[str] = set()
-    for prior_review in prior_copilot_reviews:
+    total_blocking = 0
+    total_repairable = 0
+    blocking_inventory_unknown = False
+    repairable_inventory_unknown = False
+    counted_blocking_thread_ids: set[str] = set()
+    counted_repairable_thread_ids: set[str] = set()
+
+    for review in all_copilot_reviews:
+        is_blocking = review.id in blocking_review_ids
         try:
-            comments = provider.list_review_comments(pr_number, prior_review.id)
+            comments = provider.list_review_comments(pr_number, review.id)
             for comment in comments:
                 if comment.id < 0:
                     continue  # Skip synthetic review-body entries
                 if comment.id in comment_to_thread:
                     thread_id = comment_to_thread[comment.id]
-                    if thread_id in counted_thread_ids:
-                        continue
-                    counted_thread_ids.add(thread_id)
                     is_resolved = thread_states[thread_id][0]
+
                     if not is_resolved:
-                        total_unresolved += 1
+                        if thread_id not in counted_repairable_thread_ids:
+                            counted_repairable_thread_ids.add(thread_id)
+                            total_repairable += 1
+                        if is_blocking and thread_id not in counted_blocking_thread_ids:
+                            counted_blocking_thread_ids.add(thread_id)
+                            total_blocking += 1
                     continue
 
                 logger.warning(
@@ -625,28 +714,32 @@ def count_unresolved_prior_threads(
                     pr_number,
                     comment.id,
                 )
-                missing_thread_state = True
+                repairable_inventory_unknown = True
+                if is_blocking:
+                    blocking_inventory_unknown = True
         except Exception as exc:
             logger.warning(
                 "PR #%d: failed to list review comments for review %d (%s) — failing closed",
                 pr_number,
-                prior_review.id,
+                review.id,
                 str(exc)[:200],
             )
-            comments_unavailable = True
+            repairable_inventory_unknown = True
+            if is_blocking:
+                blocking_inventory_unknown = True
 
-    if missing_thread_state:
-        return max(total_unresolved, 1), True
-    if comments_unavailable:
-        if total_unresolved == 0:
+    if repairable_inventory_unknown or blocking_inventory_unknown:
+        if repairable_inventory_unknown and total_repairable == 0:
             logger.warning(
-                "PR #%d: no unresolved threads were measured and at least one review fetch failed"
-                " — applying the blocking floor of 1 unresolved thread",
+                "PR #%d: no unresolved repairable threads were measured and at least one review inventory "
+                "is unknown — applying the repairable floor of 1 unresolved thread",
                 pr_number,
             )
-            return 1, True
-        return total_unresolved, True
-    return total_unresolved, False
+            total_repairable = 1
+        if blocking_inventory_unknown:
+            total_blocking = max(1, total_blocking)
+        return total_blocking, total_repairable, True, unknown_provenance
+    return total_blocking, total_repairable, False, unknown_provenance
 
 
 def _count_commits(provider: CIPlatformProvider, *, base_branch: str, head_sha: str) -> int:

{agentic_devtools-0.2.415.dist-info → agentic_devtools-0.2.417.dist-info}/METADATA

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

{agentic_devtools-0.2.415.dist-info → agentic_devtools-0.2.417.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentic_devtools/__init__.py,sha256=J_Zw_vWKghk-cLmqI83hXQmSiS8zMhGIHM5WPLDkZuo,242
-agentic_devtools/_version.py,sha256=yIi8ocqIsuh2cqu1EnYhgjeImc0-nP0OgjnFW9ZTHzw,524
+agentic_devtools/_version.py,sha256=X7xzJ5LaWItIS7kP80cFtX-9DK9edflj5atOwis4Joo,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
@@ -169,25 +169,25 @@ agentic_devtools/cli/ci/pipeline/command.py,sha256=RJ_QUhQjSyEobqDUQnPuVMl0-rBWK
 agentic_devtools/cli/ci/pipeline/deferral.py,sha256=Dga-CQevmTe1PYeUpvptZxbvD3g8jl7Q5kqgZSAY2dg,18305
 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=LbjuLnb9-EchE-lIFx2g5FYg_kwEPqUJSFMlHadGntw,43993
+agentic_devtools/cli/ci/pipeline/gate_verdict.py,sha256=stMgkDzVmn4Tr0yoyfPs7RXe7BpAWkecWFbY1baXEQg,44021
 agentic_devtools/cli/ci/pipeline/models.py,sha256=GVhAXMbIEhkuECYUdk6WgZ7-lOOb5sCFn9MfG50iSqY,2456
 agentic_devtools/cli/ci/pipeline/runner.py,sha256=YfK9QBFQg0ri0kCvYBek3LiQm7Mxv4pXPxiaC5PmIjk,13805
 agentic_devtools/cli/ci/pipeline/session_detector.py,sha256=dWJyZIv7NcJNUl7TIsYqNfzNmZu3vAxHaQp1wMqe70o,8926
-agentic_devtools/cli/ci/pipeline/snapshot.py,sha256=MgW38vpAQhWmYnBUvbMFjaeWAxr9Bo_C8SAbyCrqj-Q,33686
+agentic_devtools/cli/ci/pipeline/snapshot.py,sha256=MQ_drAJKZQ24pLJ7ZqDJk-feeg2dZlykTZMe11RfX0o,39144
 agentic_devtools/cli/ci/pipeline/suggestions.py,sha256=nM4w1hfDFkT5_DAMMJMDZnFIvKhcvK1ainxcnAU_FkM,26777
 agentic_devtools/cli/ci/pipeline/summary.py,sha256=ILCNHE845oiqGM6CA8NjaVKBVyxLNu5xTG8GXdhOy_U,13321
 agentic_devtools/cli/ci/pipeline/actions/__init__.py,sha256=rY6e3yk5ybMINMSdtWvcwZI8I9GGxQAQ90J_dSjipr8,1577
-agentic_devtools/cli/ci/pipeline/actions/apply_suggestions.py,sha256=WCtCoJE679587gqgLsoSO5dwEEoGdECuZoKgoc3ah5E,21215
+agentic_devtools/cli/ci/pipeline/actions/apply_suggestions.py,sha256=Y71W3QliyyAHpVGvOvipEezPW3KliYAqu5SW2ux-HBk,21197
 agentic_devtools/cli/ci/pipeline/actions/approve.py,sha256=AHTm8Mf1kMaQcrS303ZalMaKzpEfYrtMdWDrisWT6kQ,9080
 agentic_devtools/cli/ci/pipeline/actions/defer_suppressed.py,sha256=EZZMXyopk6oBQCjTRi769EsFGfTUeCqwfzBNNgeREHA,16178
 agentic_devtools/cli/ci/pipeline/actions/dispatch_conflict_resolution.py,sha256=Dl6EoagioHq74bLURRB_5Mi36Od6JHkbRuG5_za_goc,13754
-agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py,sha256=g9pMNrTc18ays-pRih4sLPI6rj5UTky1t1dA9jnwOA4,21521
+agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py,sha256=T_4Iz01GWyCm72h2BRlMW7vSfAh0NTFgkMqbBJMVzIA,26813
 agentic_devtools/cli/ci/pipeline/actions/guards.py,sha256=UIkTgv5_aKqSVNRFlvl_JiAdFswm1uV5VJJfgu5FmFc,4101
 agentic_devtools/cli/ci/pipeline/actions/merge.py,sha256=MPQxTMaDWpeZBzge2tx8htCNCjYDpF_bV5A0AofllBc,16778
 agentic_devtools/cli/ci/pipeline/actions/publish.py,sha256=A00Lk-vZKnhOCN2O5mkks0tayr7NA5eZfUA95CUP7gs,3990
 agentic_devtools/cli/ci/pipeline/actions/rebase.py,sha256=FGykjl5xi9Bg8nq2AE6IB7skdmKJ7Z4iOT4bd2K3B2U,5256
 agentic_devtools/cli/ci/pipeline/actions/request_review.py,sha256=-BInEFbX7rHY_wKna-ksa5cQV_Arxi7w1Jg1kNdBltE,9173
-agentic_devtools/cli/ci/pipeline/actions/resolve_threads.py,sha256=orY7RsqrMsvOmGDa7R-Z96itSFj9N5DICertZdekwOo,9687
+agentic_devtools/cli/ci/pipeline/actions/resolve_threads.py,sha256=zMt9oZGQgYSBeAqYwOawt0UA0KY846D0jsOPMQetLus,10448
 agentic_devtools/cli/ci/pipeline/actions/squash.py,sha256=woloutgBoaEkZMO6HcLoChCV3S-yeD7T22ygePciRx0,10894
 agentic_devtools/cli/ci/pipeline/actions/takeover.py,sha256=ms0coVGuT7peZ3XKbYzqzwrAwqwyyvfPzCsPXLPXKws,6394
 agentic_devtools/cli/ci/pipeline/discovery/__init__.py,sha256=QNdOYvl_wK6qcWOvNJR-wm8EtWD_DPn4barKF5RSmfU,752
@@ -949,8 +949,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.415.dist-info/METADATA,sha256=0YFc2rqKU6aEqndgc0b1TPrbskguyu3vIIraNawyBCg,33466
-agentic_devtools-0.2.415.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-agentic_devtools-0.2.415.dist-info/entry_points.txt,sha256=1xH6yqltFD5Gs3qbHN9zpKwwG3nXpWoC7x0w1Ip7LCw,11726
-agentic_devtools-0.2.415.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.415.dist-info/RECORD,,
+agentic_devtools-0.2.417.dist-info/METADATA,sha256=SHsp34rERnK4tBljYrlOjd_ChdoqFZzZdw7ua1FqsK0,33466
+agentic_devtools-0.2.417.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+agentic_devtools-0.2.417.dist-info/entry_points.txt,sha256=1xH6yqltFD5Gs3qbHN9zpKwwG3nXpWoC7x0w1Ip7LCw,11726
+agentic_devtools-0.2.417.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.417.dist-info/RECORD,,