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

agentic_devtools/cli/ci/agent_task_lifecycle.py

@@ -134,3 +134,146 @@ def select_task_lifecycle_timestamp(task: AgentTaskLifecycle) -> datetime | None
     if session_timestamp is not None:
         timestamps.append(session_timestamp)
     return max(timestamps, default=None)
+
+
+def _agent_task_lifecycle_detail_value(record: Mapping[str, object], *keys: str) -> object:
+    """Return the first matching record or metadata alias."""
+    for key in keys:
+        if key in record:
+            return record[key]
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict):
+        for key in keys:
+            if key in metadata:
+                return metadata[key]
+    return None
+
+
+def _map_agent_task_lifecycle_session(
+    task: Mapping[str, object],
+    session: object,
+    *,
+    task_id: str,
+    task_state: str,
+    top_level_session_record: bool,
+) -> tuple[AgentTaskSessionLifecycle | None, tuple[str, ...]]:
+    """Normalize one session record while preserving identity and malformed-data facts."""
+    if not isinstance(session, dict):
+        return None, (f"malformed-session:{task_id}",)
+    reasons: list[str] = []
+    session_id_value = _agent_task_lifecycle_detail_value(session, "session_id", "sessionId") or (
+        _agent_task_lifecycle_detail_value(task, "session_id", "sessionId")
+        if top_level_session_record
+        else _agent_task_lifecycle_detail_value(session, "id")
+    )
+    if not isinstance(session_id_value, str) or not session_id_value:
+        reasons.append(f"missing-session-id:{task_id}")
+        session_id_value = ""
+    session_state_value = _agent_task_lifecycle_detail_value(session, "state", "status")
+    if top_level_session_record:
+        session_state_value = task_state
+    started, session_created_at, idle = session_lifecycle_timestamp_values(
+        session,
+        include_created=not top_level_session_record,
+        fallback=task if top_level_session_record else None,
+    )
+    session_state = session_state_value if isinstance(session_state_value, str) else ""
+    session_head_sha = _agent_task_lifecycle_detail_value(session, "head_sha", "headSha")
+    head_sha = session_head_sha if isinstance(session_head_sha, str) else ""
+    session_run_id = _agent_task_lifecycle_detail_value(session, "workflow_run_id", "workflowRunId", "run_id", "runId")
+    run_id = (
+        str(session_run_id) if isinstance(session_run_id, (str, int)) and not isinstance(session_run_id, bool) else ""
+    )
+    session_values = (session_state, started, session_created_at, idle, head_sha, run_id)
+    if not session_id_value and not any(session_values):
+        return None, tuple(reasons)
+    return (
+        AgentTaskSessionLifecycle(
+            session_id=session_id_value,
+            state=session_state,
+            started_at=started,
+            idle_at=idle,
+            head_sha=head_sha,
+            workflow_run_id=run_id,
+            created_at=session_created_at,
+        ),
+        tuple(reasons),
+    )
+
+
+def _map_agent_task_lifecycle_sessions(
+    task: Mapping[str, object],
+    detail: Mapping[str, object],
+    *,
+    task_id: str,
+    task_state: str,
+) -> tuple[tuple[AgentTaskSessionLifecycle, ...], tuple[str, ...]]:
+    """Normalize nested or singleton sessions and return task-scoped diagnostics."""
+    session_records = detail.get("sessions", task.get("sessions"))
+    reasons: list[str] = []
+    top_level_session_record = False
+    if not isinstance(session_records, list):
+        if session_records is not None:
+            reasons.append(f"malformed-session:{task_id}")
+        top_level_session_record = bool(
+            _agent_task_lifecycle_detail_value(detail, "session_id", "sessionId")
+            or has_session_activity_timestamp(detail, fallback=task)
+        )
+        session_records = [detail] if top_level_session_record else []
+    sessions: list[AgentTaskSessionLifecycle] = []
+    for session in session_records:
+        normalized, diagnostics = _map_agent_task_lifecycle_session(
+            task,
+            session,
+            task_id=task_id,
+            task_state=task_state,
+            top_level_session_record=top_level_session_record,
+        )
+        reasons.extend(diagnostics)
+        if normalized is not None:
+            sessions.append(normalized)
+    return tuple(sessions), tuple(reasons)
+
+
+def _map_agent_task_lifecycle_detail(
+    task: Mapping[str, object],
+    detail: Mapping[str, object],
+    *,
+    task_id: str,
+    repository: str,
+    pr_number: int,
+    task_pr_number: int | None,
+    head_branch: str,
+) -> tuple[AgentTaskLifecycle, tuple[str, ...]]:
+    """Normalize one fetched task detail record and retain task-scoped diagnostics."""
+    state_value = _agent_task_lifecycle_detail_value(detail, "state", "status")
+    if not isinstance(state_value, str) or not state_value.strip():
+        state_value = _agent_task_lifecycle_detail_value(task, "state", "status")
+    state = state_value if isinstance(state_value, str) else ""
+    created_at = select_valid_timestamp_alias(detail, "created_at", "createdAt", fallback=task)
+    started_at = select_valid_timestamp_alias(detail, "started_at", "startedAt", fallback=task)
+    idle_at = select_valid_timestamp_alias(detail, "idle_at", "idleAt", "idle_since", "idleSince", fallback=task)
+    sessions, reasons = _map_agent_task_lifecycle_sessions(
+        task,
+        detail,
+        task_id=task_id,
+        task_state=state,
+    )
+    task_head_sha = _agent_task_lifecycle_detail_value(detail, "head_sha", "headSha")
+    task_run_id = _agent_task_lifecycle_detail_value(detail, "workflow_run_id", "workflowRunId", "run_id", "runId")
+    lifecycle = AgentTaskLifecycle(
+        task_id=task_id,
+        repository=repository,
+        pr_number=task_pr_number if task_pr_number is not None else pr_number,
+        head_branch=head_branch,
+        state=state,
+        created_at=created_at,
+        sessions=sessions,
+        head_sha=task_head_sha if isinstance(task_head_sha, str) else "",
+        workflow_run_id=str(task_run_id)
+        if isinstance(task_run_id, (str, int)) and not isinstance(task_run_id, bool)
+        else "",
+        started_at=started_at,
+        idle_at=idle_at,
+    )
+    return lifecycle, reasons

agentic_devtools/cli/ci/cooldown.py

@@ -23,12 +23,8 @@ from agentic_devtools.cli.ci.credential_roles import (
     REPO_VARIABLE_WRITER_PAT,
 )
 from agentic_devtools.cli.shared.retry import (
-    DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
     DEFAULT_RATE_LIMIT_MAX_DELAY,
-    DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
     ProviderRateLimitError,
-    RateLimitDelay,
-    calculate_rate_limit_delay,
 )
 
 if TYPE_CHECKING:
@@ -234,13 +230,13 @@ def read_cooldowns(
 ) -> dict[str, CooldownRecord]:
     """Read active cooldowns; unavailable state fails open for scheduling."""
     try:
-        return parse_cooldowns(provider.get_variable(COOLDOWN_VARIABLE, use_writer_token=use_writer_token), now=now)
-    except ProviderRateLimitError as exc:
-        if exc.is_rate_limit:
-            raise
-        logger.warning("Could not read provider cooldowns; continuing fail-open: %s", type(exc).__name__)
-        return {}
+        from agentic_devtools.cli.ci.read_token_pool_execution import _read_cooldown_value
+
+        value = _read_cooldown_value(provider, use_writer_token=use_writer_token)
+        return parse_cooldowns(value, now=now)
     except Exception as exc:
+        if isinstance(exc, ProviderRateLimitError) and exc.is_rate_limit:
+            raise
         logger.warning("Could not read provider cooldowns; continuing fail-open: %s", type(exc).__name__)
         return {}
 
@@ -270,68 +266,12 @@ def persist_cooldown(
     *,
     now: float | None = None,
     retries: int = 3,
+    observed_at: float | None = None,
 ) -> tuple[str, CooldownRecord] | None:
-    """Persist a monotonic provider cooldown using bounded read/merge/write attempts.
+    """Persist a provider cooldown, optionally anchoring its expiry to its observation time."""
+    from agentic_devtools.cli.ci.cooldown_persistence import persist_cooldown as persist
 
-    Cross-process safety relies on the read/merge/verify/retry loop: each attempt
-    reads the current variable, merges all known records, writes the merged state,
-    and verifies that no concurrent writer shortened an active cooldown. The
-    in-process ``_WRITE_LOCK`` serializes concurrent callers within the same process.
-    """
-    current = time.time() if now is None else float(now)
-    identity = error.credential_identity or credential_identity_from_environment()
-    key = cooldown_key(identity, provider=error.provider or DEFAULT_PROVIDER)
-    delay: RateLimitDelay = calculate_rate_limit_delay(
-        retry_after_seconds=error.retry_after_seconds,
-        reset_timestamp=error.reset_timestamp,
-        now=current,
-        fallback_delay=DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
-        safety_margin=DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
-        max_delay=DEFAULT_RATE_LIMIT_MAX_DELAY,
-    )
-    record = CooldownRecord(
-        resume_at=delay.resume_at,
-        reason="rate_limit",
-        source=error.source if error.source in _ALLOWED_SOURCE_VALUES else delay.source,
-        updated_at=current,
-    )
-    known_records: dict[str, CooldownRecord] = {}
-    with _WRITE_LOCK:
-        for _ in range(max(1, retries)):
-            try:
-                raw = provider.get_variable(COOLDOWN_VARIABLE, use_writer_token=True)
-                observed_records = parse_cooldowns(raw, now=current)
-                for observed_key, observed_record in observed_records.items():
-                    known_record = known_records.get(observed_key)
-                    if known_record is None or (
-                        observed_record.resume_at > known_record.resume_at
-                        or (
-                            observed_record.resume_at == known_record.resume_at
-                            and observed_record.updated_at > known_record.updated_at
-                        )
-                    ):
-                        known_records[observed_key] = observed_record
-                records = dict(known_records)
-                existing = records.get(key)
-                if existing is None or existing.resume_at < record.resume_at:
-                    records[key] = record
-                merged = serialize_cooldowns(records)
-                provider.set_variable(COOLDOWN_VARIABLE, merged)
-                verified_raw = provider.get_variable(COOLDOWN_VARIABLE, use_writer_token=True)
-                verified_records = parse_cooldowns(verified_raw, now=current)
-                effective = verified_records.get(key)
-                if not _preserves_cooldown_records(records, verified_records):
-                    logger.warning("Provider cooldown write was stale; reconciling records before retrying")
-                    continue
-                if effective is None:  # pragma: no cover - covered by the preservation check
-                    continue
-                return key, effective
-            except Exception as exc:
-                logger.warning("Could not persist provider cooldown; retrying: %s", type(exc).__name__)
-                if _ + 1 < max(1, retries):
-                    time.sleep(1.0)
-    logger.warning("Provider cooldown could not be persisted; keeping rate-limit pause in effect")
-    return None
+    return persist(provider, error, now=now, retries=retries, observed_at=observed_at)
 
 
 def format_resume_at(timestamp: float) -> str:

agentic_devtools/cli/ci/cooldown_persistence.py

@@ -0,0 +1,89 @@
+"""Persistence implementation for durable provider cooldowns."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING
+
+import agentic_devtools.cli.ci.cooldown as cooldown
+from agentic_devtools.cli.shared.retry import (
+    DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
+    DEFAULT_RATE_LIMIT_MAX_DELAY,
+    DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
+    ProviderRateLimitError,
+    RateLimitDelay,
+    calculate_rate_limit_delay,
+)
+
+if TYPE_CHECKING:
+    from agentic_devtools.cli.ci.provider import CIPlatformProvider
+
+logger = logging.getLogger(__name__)
+
+
+def persist_cooldown(
+    provider: CIPlatformProvider,
+    error: ProviderRateLimitError,
+    *,
+    now: float | None = None,
+    retries: int = 3,
+    observed_at: float | None = None,
+) -> tuple[str, cooldown.CooldownRecord] | None:
+    """Persist a cooldown using current time for validation and observation time for its expiry."""
+    current = time.time() if now is None else float(now)
+    event_time = current if observed_at is None else float(observed_at)
+    identity = error.credential_identity or cooldown.credential_identity_from_environment()
+    key = cooldown.cooldown_key(identity, provider=error.provider or cooldown.DEFAULT_PROVIDER)
+    delay: RateLimitDelay = calculate_rate_limit_delay(
+        retry_after_seconds=error.retry_after_seconds,
+        reset_timestamp=error.reset_timestamp,
+        now=event_time,
+        fallback_delay=DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
+        safety_margin=DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
+        max_delay=DEFAULT_RATE_LIMIT_MAX_DELAY,
+    )
+    record = cooldown.CooldownRecord(
+        resume_at=delay.resume_at,
+        reason="rate_limit",
+        source=error.source if error.source in cooldown._ALLOWED_SOURCE_VALUES else delay.source,
+        updated_at=event_time,
+    )
+    known_records: dict[str, cooldown.CooldownRecord] = {}
+    with cooldown._WRITE_LOCK:
+        for attempt in range(max(1, retries)):
+            try:
+                raw = provider.get_variable(cooldown.COOLDOWN_VARIABLE, use_writer_token=True)
+                observed_records = cooldown.parse_cooldowns(raw, now=current)
+                for observed_key, observed_record in observed_records.items():
+                    known_record = known_records.get(observed_key)
+                    if known_record is None or (
+                        observed_record.resume_at > known_record.resume_at
+                        or (
+                            observed_record.resume_at == known_record.resume_at
+                            and observed_record.updated_at > known_record.updated_at
+                        )
+                    ):
+                        known_records[observed_key] = observed_record
+                records = dict(known_records)
+                existing = records.get(key)
+                if existing is None or existing.resume_at < record.resume_at:
+                    records[key] = record
+                merged = cooldown.serialize_cooldowns(records)
+                provider.set_variable(cooldown.COOLDOWN_VARIABLE, merged)
+                verified_raw = provider.get_variable(cooldown.COOLDOWN_VARIABLE, use_writer_token=True)
+                verified_records = cooldown.parse_cooldowns(verified_raw, now=current)
+                effective = verified_records.get(key)
+                expected_records = {item_key: item for item_key, item in records.items() if item.resume_at > current}
+                if not cooldown._preserves_cooldown_records(expected_records, verified_records):
+                    logger.warning("Provider cooldown write was stale; reconciling records before retrying")
+                    continue
+                if effective is None:
+                    return None
+                return key, effective
+            except Exception as exc:
+                logger.warning("Could not persist provider cooldown; retrying: %s", type(exc).__name__)
+                if attempt + 1 < max(1, retries):
+                    time.sleep(1.0)
+    logger.warning("Provider cooldown could not be persisted; keeping rate-limit pause in effect")
+    return None

agentic_devtools/cli/ci/github_provider.py

@@ -93,6 +93,7 @@ from agentic_devtools.cli.ci.provider import (
     RepairDispatchNotAttemptedError,
 )
 from agentic_devtools.cli.ci.read_token_pool import ReadTokenPool
+from agentic_devtools.cli.ci.read_token_pool_execution import ReadTokenPoolOperations
 from agentic_devtools.cli.ci.reconciliation import config
 from agentic_devtools.cli.ci.reconciliation.models import ObservationOutcome
 from agentic_devtools.cli.ci.resolution.engine import TieredResolutionEngine
@@ -2317,6 +2318,9 @@ def _build_repair_comment(
     return _enforce_comment_size_limit(body)
 
 
+_InventoryDeadlineExceeded = ReadTokenPoolOperations.DeadlineExpired
+
+
 def _gh_api(
     endpoint: str,
     *,
@@ -2330,6 +2334,9 @@ def _gh_api(
     response_metadata: dict[str, float | int | None] | None = None,
     read_pool: bool = True,
     timeout_seconds: int = _GH_CLI_TIMEOUT_SECONDS,
+    _deadline: float | None = None,
+    _monotonic: Callable[[], float] | None = None,
+    _pool_managed: bool = False,
 ) -> str:
     """Call the GitHub API via the ``gh`` CLI.
 
@@ -2357,12 +2364,15 @@ def _gh_api(
     """
     if not isinstance(timeout_seconds, int) or isinstance(timeout_seconds, bool) or timeout_seconds <= 0:
         raise ValueError("timeout_seconds must be a positive integer")
+    _deadline, _monotonic = ReadTokenPoolOperations.resolve_request_context(_deadline, _monotonic)
     target_repository = _target_repository_from_gh_arguments(["api", endpoint])
     if method.upper() == "GET" and _should_use_read_token_pool(
         token=token,
         credential_identity=credential_identity,
         read_pool=read_pool,
         target_repository=target_repository,
+        deadline=_deadline,
+        monotonic=_monotonic,
     ):
 
         def pooled_request(selected_token: str | None, identity: str) -> tuple[str, int | None]:
@@ -2379,13 +2389,21 @@ def _gh_api(
                 response_metadata=request_metadata,
                 read_pool=False,
                 timeout_seconds=timeout_seconds,
+                _deadline=_deadline,
+                _monotonic=_monotonic,
+                _pool_managed=True,
             )
             if response_metadata is not None:
                 response_metadata.update(request_metadata)
             remaining_value = request_metadata.get("remaining")
             return response, remaining_value if isinstance(remaining_value, int) else None
 
-        return _call_with_read_token_pool("rest", pooled_request)
+        return _call_with_read_token_pool(
+            "rest",
+            pooled_request,
+            deadline=_deadline,
+            monotonic=_monotonic,
+        )
 
     cmd = ["gh", "api", endpoint, "--method", method]
     if include_headers:
@@ -2407,16 +2425,21 @@ def _gh_api(
     is_agent_tasks = endpoint.partition("?")[0].startswith(AGENT_TASKS_ENDPOINT_TEMPLATE.partition("{owner}")[0])
     diagnostics = AgentTaskDiagnostics(endpoint, env, _sanitize_gh_error, is_agent_tasks=is_agent_tasks)
 
-    result = diagnostics.run(
-        run_safe,
-        cmd,
-        f"gh api {endpoint} timed out after {timeout_seconds}s",
-        capture_output=True,
-        text=True,
-        shell=False,
-        input=json.dumps(body) if body else None,
-        env=env,
-        timeout=timeout_seconds,
+    request_timeout_seconds = ReadTokenPoolOperations.request_timeout(timeout_seconds, _deadline, _monotonic)
+    result = ReadTokenPoolOperations.run_request(
+        lambda: diagnostics.run(
+            run_safe,
+            cmd,
+            f"gh api {endpoint} timed out after {request_timeout_seconds}s",
+            capture_output=True,
+            text=True,
+            shell=False,
+            input=json.dumps(body) if body else None,
+            env=env,
+            timeout=request_timeout_seconds,
+        ),
+        deadline=_deadline,
+        monotonic=_monotonic,
     )
     if include_headers:
         status, response_headers, response_body = _parse_gh_api_output(result.stdout or "")
@@ -2435,6 +2458,12 @@ def _gh_api(
             remaining=remaining,
         )
     if result.returncode != 0:
+        ReadTokenPoolOperations.check_http_error_deadline(
+            _deadline,
+            _monotonic,
+            pool_managed=_pool_managed,
+            is_rate_limit=is_rate_limit,
+        )
         if is_rate_limit:
             raise RetryableError(
                 diagnostics.format_error(f"GitHub API rate limited (HTTP {status or 429})"),
@@ -2499,10 +2528,17 @@ def _extract_existing_pr_url(text: str) -> str:
     return match.group(0) if match else ""
 
 
-def _get_read_token_pool() -> ReadTokenPool | None:
+def _get_read_token_pool(
+    *,
+    deadline: float | None = None,
+    monotonic: Callable[[], float] | None = None,
+) -> ReadTokenPool | None:
     """Create and cache the validated read-token pool for this process and repository."""
     global _READ_TOKEN_POOL, _READ_TOKEN_POOL_REPO
 
+    ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+    if deadline is None:
+        ReadTokenPoolOperations.flush_deferred_rate_limits()
     repo = os.environ.get("GITHUB_REPOSITORY", "").strip()
     secrets_json = os.environ.get("AGDT_GITHUB_SECRETS_JSON")
     if not repo or not secrets_json:
@@ -2522,6 +2558,7 @@ def _get_read_token_pool() -> ReadTokenPool | None:
             credential_identity=identity,
             response_metadata=metadata,
             read_pool=False,
+            _pool_managed=True,
         )
         remaining = metadata.get("remaining")
         return response, remaining if isinstance(remaining, int) else None
@@ -2545,39 +2582,29 @@ def _get_read_token_pool() -> ReadTokenPool | None:
         return {key.partition(":")[2]: record.resume_at for key, record in records.items() if key.startswith("github:")}
 
     def persist_rate_limit(identity: str, error: RetryableError | ProviderRateLimitError) -> float | None:
-        from agentic_devtools.cli.ci.cooldown import persist_cooldown
-
-        retry_after = error.retry_after if isinstance(error, RetryableError) else error.retry_after_seconds
-        bypass = _READ_POOL_BYPASS.set(True)
-        try:
-            persisted = persist_cooldown(
-                provider,
-                ProviderRateLimitError(
-                    retry_after_seconds=retry_after,
-                    reset_timestamp=error.reset_timestamp,
-                    remaining=error.remaining,
-                    provider=error.provider or "github",
-                    credential_identity=identity,
-                    source=error.source,
-                    is_rate_limit=error.is_rate_limit,
-                ),
-            )
-            return persisted[1].resume_at if persisted is not None else None
-        finally:
-            _READ_POOL_BYPASS.reset(bypass)
+        return ReadTokenPoolOperations.persist_rate_limit(
+            provider,
+            identity,
+            error,
+            bypass=_READ_POOL_BYPASS,
+        )
 
-    cooldown_identities = active_cooldown_identities()
-    _READ_TOKEN_POOL = ReadTokenPool(
-        repo=repo,
-        secrets_json=secrets_json,
-        default_token=default_token,
-        default_identity=default_identity,
-        request=request,
-        active_cooldowns=cooldown_identities,
-        on_rate_limit=persist_rate_limit,
-    )
+    with ReadTokenPoolOperations.request_context(deadline, monotonic):
+        cooldown_identities = active_cooldown_identities()
+        ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+        pool = ReadTokenPool(
+            repo=repo,
+            secrets_json=secrets_json,
+            default_token=default_token,
+            default_identity=default_identity,
+            request=request,
+            active_cooldowns=cooldown_identities,
+            on_rate_limit=persist_rate_limit,
+        )
+        ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+    _READ_TOKEN_POOL = pool
     _READ_TOKEN_POOL_REPO = repo
-    return _READ_TOKEN_POOL
+    return pool
 
 
 def _reset_read_token_pool() -> None:
@@ -2593,10 +2620,13 @@ def _should_use_read_token_pool(
     credential_identity: str | None,
     read_pool: bool,
     target_repository: str | None = None,
+    deadline: float | None = None,
+    monotonic: Callable[[], float] | None = None,
 ) -> bool:
     if not read_pool or _READ_POOL_BYPASS.get():
         return False
-    pool = _get_read_token_pool()
+    ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+    pool = _get_read_token_pool() if deadline is None else _get_read_token_pool(deadline=deadline, monotonic=monotonic)
     if pool is None:
         return False
     if target_repository is not None and target_repository.casefold() != pool.repo.casefold():
@@ -2648,64 +2678,23 @@ def _target_repository_from_gh_arguments(arguments: Sequence[str]) -> str | None
 def _call_with_read_token_pool[ReadResult](
     resource: str,
     operation: Callable[[str | None, str], tuple[ReadResult, int | None]],
+    *,
+    deadline: float | None = None,
+    monotonic: Callable[[], float] | None = None,
 ) -> ReadResult:
     """Run one read with ranked pool identities and fail over on rate limits."""
-    pool = _get_read_token_pool()
-    if pool is None:
-        result, _ = operation(None, _credential_identity_for_token(None))
-        return result
-
-    attempted: set[str] = set()
-    last_rate_limit: RetryableError | None = None
-    while (credential := pool.select(resource, excluded=attempted)) is not None:
-        attempted.add(credential.secret_name)
-        try:
-            result, remaining = operation(credential.token, credential.secret_name)
-        except RetryableError as exc:
-            if not exc.is_rate_limit:
-                raise
-            pool.record_remaining(credential.secret_name, resource, exc.remaining)
-            pool.mark_rate_limited(credential.secret_name, exc)
-            last_rate_limit = exc
-            continue
-        pool.record_remaining(credential.secret_name, resource, remaining)
-        return result
-
-    if last_rate_limit is not None and not pool.default_token:
-        raise ProviderRateLimitError(
-            retry_after_seconds=last_rate_limit.retry_after,
-            reset_timestamp=last_rate_limit.reset_timestamp,
-            remaining=last_rate_limit.remaining,
-            provider=last_rate_limit.provider or "github",
-            credential_identity=last_rate_limit.credential_identity,
-            source=last_rate_limit.source,
-            is_rate_limit=True,
+    with ReadTokenPoolOperations.request_context(deadline, monotonic):
+        pool = (
+            _get_read_token_pool() if deadline is None else _get_read_token_pool(deadline=deadline, monotonic=monotonic)
         )
-    if pool.default_is_active:
-        raise ProviderRateLimitError(
-            provider="github",
-            credential_identity=pool.default_identity,
-            source="fallback",
-            is_rate_limit=True,
+        return ReadTokenPoolOperations.run(
+            resource,
+            operation,
+            pool,
+            _credential_identity_for_token,
+            deadline=deadline,
+            monotonic=monotonic,
         )
-    try:
-        result, remaining = operation(pool.default_token or None, pool.default_identity)
-    except RetryableError as exc:
-        if not exc.is_rate_limit:
-            raise
-        pool.record_remaining(pool.default_identity, resource, exc.remaining)
-        pool.mark_rate_limited(pool.default_identity, exc)
-        raise ProviderRateLimitError(
-            retry_after_seconds=exc.retry_after,
-            reset_timestamp=exc.reset_timestamp,
-            remaining=exc.remaining,
-            provider=exc.provider or "github",
-            credential_identity=pool.default_identity,
-            source=exc.source,
-            is_rate_limit=True,
-        ) from exc
-    pool.record_remaining(pool.default_identity, resource, remaining)
-    return result
 
 
 def _run_readonly_gh_command(
@@ -5725,85 +5714,19 @@ class GitHubActionsProvider(GitHubPRFilesMixin, CIPlatformProvider):
                 complete = False
                 reasons.append(f"task-detail:{task_id_value}")
                 detail = task
-            state_value = _task_value(detail, "state", "status")
-            if not isinstance(state_value, str) or not state_value.strip():
-                state_value = _task_value(task, "state", "status")
-            state = state_value if isinstance(state_value, str) else ""
-            created_at = _agent_task_lifecycle.select_valid_timestamp_alias(
-                detail, "created_at", "createdAt", fallback=task
-            )
-            session_records = detail.get("sessions", task.get("sessions"))
-            top_level_session_record = False
-            if not isinstance(session_records, list):
-                if session_records is not None:
-                    complete = False
-                    reasons.append(f"malformed-session:{task_id_value}")
-                top_level_session_record = bool(
-                    _task_value(detail, "session_id", "sessionId")
-                    or _agent_task_lifecycle.has_session_activity_timestamp(detail, fallback=task)
-                )
-                session_records = [detail] if top_level_session_record else []
-            sessions: list[AgentTaskSessionLifecycle] = []
-            for session in session_records:
-                if not isinstance(session, dict):
-                    complete = False
-                    reasons.append(f"malformed-session:{task_id_value}")
-                    continue
-                session_id_value = _task_value(session, "session_id", "sessionId") or (
-                    _task_value(task, "session_id", "sessionId")
-                    if top_level_session_record
-                    else _task_value(session, "id")
-                )
-                if not isinstance(session_id_value, str) or not session_id_value:
-                    complete = False
-                    reasons.append(f"missing-session-id:{task_id_value}")
-                    session_id_value = ""
-                session_state_value = state if top_level_session_record else _task_value(session, "state", "status")
-                started_at, session_created_at, idle_at = _agent_task_lifecycle.session_lifecycle_timestamp_values(
-                    session,
-                    include_created=not top_level_session_record,
-                    fallback=task if top_level_session_record else None,
-                )
-                session_head_sha = _task_value(session, "head_sha", "headSha")
-                session_run_id = _task_value(session, "workflow_run_id", "workflowRunId", "run_id", "runId")
-                session_state = session_state_value if isinstance(session_state_value, str) else ""
-                head_sha = session_head_sha if isinstance(session_head_sha, str) else ""
-                run_id = (
-                    str(session_run_id)
-                    if isinstance(session_run_id, (str, int)) and not isinstance(session_run_id, bool)
-                    else ""
-                )
-                session_values = (session_state, started_at, session_created_at, idle_at, head_sha, run_id)
-                if not session_id_value and not any(session_values):
-                    continue
-                sessions.append(
-                    AgentTaskSessionLifecycle(
-                        session_id=session_id_value,
-                        state=session_state,
-                        started_at=started_at,
-                        idle_at=idle_at,
-                        head_sha=head_sha,
-                        workflow_run_id=run_id,
-                        created_at=session_created_at,
-                    )
-                )
-            task_head_sha = _task_value(detail, "head_sha", "headSha")
-            task_run_id = _task_value(detail, "workflow_run_id", "workflowRunId", "run_id", "runId")
-            normalized.append(
-                AgentTaskLifecycle(
-                    task_id=task_id_value,
-                    repository=repo,
-                    pr_number=task_pr if task_pr is not None else pr_number,
-                    head_branch=self._agent_task_branch(detail) or branch,
-                    state=state,
-                    created_at=created_at,
-                    sessions=tuple(sessions),
-                    head_sha=task_head_sha if isinstance(task_head_sha, str) else "",
-                    workflow_run_id=str(task_run_id)
-                    if isinstance(task_run_id, (str, int)) and not isinstance(task_run_id, bool)
-                    else "",
-                )
+            lifecycle, task_reasons = _agent_task_lifecycle._map_agent_task_lifecycle_detail(
+                task,
+                detail,
+                task_id=task_id_value,
+                repository=repo,
+                pr_number=pr_number,
+                task_pr_number=task_pr,
+                head_branch=self._agent_task_branch(detail) or branch,
             )
+            if task_reasons:
+                complete = False
+                reasons.extend(task_reasons)
+            normalized.append(lifecycle)
         inventory = AgentTaskInventory(tuple(normalized), complete, tuple(dict.fromkeys(reasons)))
         self._agent_task_inventory_cache[key] = inventory
         return inventory

agentic_devtools/cli/ci/read_token_pool.py

@@ -26,6 +26,10 @@ _POOL_SECRET_SUFFIX = "_SWICA_CLASSIC_REPO_WORKFLOW_PAT"
 _HTTP_STATUS_RE = re.compile(r"\bHTTP\s+(\d{3})\b", re.IGNORECASE)
 
 
+class _ReadTokenPoolDeadlineExceeded(RuntimeError):
+    """Private signal that an inventory-scoped request exhausted its deadline."""
+
+
 @dataclass(frozen=True)
 class ReadCredential:
     """A validated read credential identified only by its Actions secret name."""
@@ -321,6 +325,8 @@ class ReadTokenPool:
         expired = {identity for identity, deadline in self._cooldown_deadlines.items() if deadline <= now}
         if not expired:
             return
+        expired_deadlines = {identity: self._cooldown_deadlines[identity] for identity in expired}
+        expired_rate_limited = expired & self._rate_limited
         for identity in expired:
             self._cooldown_deadlines.pop(identity, None)
             self._current_run_cooldowns.pop(identity, None)
@@ -332,10 +338,17 @@ class ReadTokenPool:
         if self.default_identity in expired:
             self._default_login = None
             self._default_login_attempted = False
-            self._load_candidates(self._secret_entries_list)
-            return
-        expired_entries = [(name, token) for name, token in self._secret_entries_list if name in expired]
-        self._load_candidates(expired_entries)
+            expired_entries = self._secret_entries_list
+        else:
+            expired_entries = [(name, token) for name, token in self._secret_entries_list if name in expired]
+        try:
+            self._load_candidates(expired_entries)
+        except _ReadTokenPoolDeadlineExceeded:
+            for identity, deadline in expired_deadlines.items():
+                self._cooldown_deadlines.setdefault(identity, deadline)
+            self._active_cooldowns.update(expired)
+            self._rate_limited.update(expired_rate_limited)
+            raise
 
     def _resolve_login(self, token: str, identity: str) -> str:
         if token in self._logins_by_token:
@@ -362,6 +375,8 @@ class ReadTokenPool:
             self._warn_candidate_failure(identity, stage, error)
 
     def _warn_candidate_failure(self, identity: str, stage: str, error: Exception) -> None:
+        if isinstance(error, _ReadTokenPoolDeadlineExceeded):
+            raise error.with_traceback(error.__traceback__)
         status = self._http_status(str(error))
         if status in {401, 403, 404}:
             logger.warning("Read credential %s failed %s (HTTP %d); excluding it", identity, stage, status)

agentic_devtools/cli/ci/read_token_pool_execution.py

@@ -0,0 +1,299 @@
+"""Deadline-aware execution for pooled GitHub read requests."""
+
+from __future__ import annotations
+
+import time
+from collections import deque
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from math import floor
+from typing import Any
+
+from agentic_devtools.cli.ci.read_token_pool import ReadTokenPool, _ReadTokenPoolDeadlineExceeded
+from agentic_devtools.cli.ci.retry import ProviderRateLimitError, RetryableError
+from agentic_devtools.cli.shared.retry import (
+    DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
+    DEFAULT_RATE_LIMIT_MAX_DELAY,
+    DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
+    calculate_rate_limit_delay,
+)
+
+_REQUEST_CONTEXT: ContextVar[tuple[float | None, Callable[[], float] | None]] = ContextVar(
+    "github_read_pool_request_context",
+    default=(None, None),
+)
+_DEFERRED_RATE_LIMIT_PERSISTENCE: deque[Callable[[], float | None]] = deque()
+
+
+class ReadTokenPoolOperations:
+    """Execute pooled requests while optionally enforcing an inventory deadline."""
+
+    DeadlineExpired = _ReadTokenPoolDeadlineExceeded
+
+    @staticmethod
+    @contextmanager
+    def request_context(deadline: float | None, monotonic: Callable[[], float] | None) -> Iterator[None]:
+        token = _REQUEST_CONTEXT.set((deadline, monotonic))
+        try:
+            yield
+        finally:
+            _REQUEST_CONTEXT.reset(token)
+
+    @staticmethod
+    def current_request_context() -> tuple[float | None, Callable[[], float] | None]:
+        return _REQUEST_CONTEXT.get()
+
+    @staticmethod
+    def resolve_request_context(
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+    ) -> tuple[float | None, Callable[[], float] | None]:
+        request_deadline, request_monotonic = _REQUEST_CONTEXT.get()
+        return (
+            deadline if deadline is not None else request_deadline,
+            monotonic if monotonic is not None else request_monotonic,
+        )
+
+    @staticmethod
+    def persist_rate_limit(
+        provider: Any,
+        identity: str,
+        error: RetryableError | ProviderRateLimitError,
+        *,
+        bypass: ContextVar[bool],
+        observed_at: float | None = None,
+    ) -> float | None:
+        deadline, _ = _REQUEST_CONTEXT.get()
+        if deadline is not None:
+            observed_at = time.time()
+            _DEFERRED_RATE_LIMIT_PERSISTENCE.append(
+                lambda: ReadTokenPoolOperations.persist_rate_limit(
+                    provider,
+                    identity,
+                    error,
+                    bypass=bypass,
+                    observed_at=observed_at,
+                )
+            )
+            retry_after = error.retry_after if isinstance(error, RetryableError) else error.retry_after_seconds
+            return calculate_rate_limit_delay(
+                retry_after_seconds=retry_after,
+                reset_timestamp=error.reset_timestamp,
+                now=observed_at,
+                fallback_delay=DEFAULT_RATE_LIMIT_FALLBACK_DELAY,
+                safety_margin=DEFAULT_RATE_LIMIT_SAFETY_MARGIN,
+                max_delay=DEFAULT_RATE_LIMIT_MAX_DELAY,
+            ).resume_at
+
+        from agentic_devtools.cli.ci.cooldown import persist_cooldown
+
+        retry_after = error.retry_after if isinstance(error, RetryableError) else error.retry_after_seconds
+        token = bypass.set(True)
+        try:
+            persisted = persist_cooldown(
+                provider,
+                ProviderRateLimitError(
+                    retry_after_seconds=retry_after,
+                    reset_timestamp=error.reset_timestamp,
+                    remaining=error.remaining,
+                    provider=error.provider or "github",
+                    credential_identity=identity,
+                    source=error.source,
+                    is_rate_limit=error.is_rate_limit,
+                ),
+                observed_at=observed_at,
+            )
+            return persisted[1].resume_at if persisted is not None else None
+        finally:
+            bypass.reset(token)
+
+    @staticmethod
+    def flush_deferred_rate_limits() -> None:
+        if _REQUEST_CONTEXT.get()[0] is not None:
+            return
+        while True:
+            try:
+                persist = _DEFERRED_RATE_LIMIT_PERSISTENCE.popleft()
+            except IndexError:
+                return
+            try:
+                persist()
+            except Exception:
+                _DEFERRED_RATE_LIMIT_PERSISTENCE.appendleft(persist)
+                raise
+
+    @staticmethod
+    def run_request[Result](
+        request: Callable[[], Result],
+        *,
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+    ) -> Result:
+        try:
+            return request()
+        except RetryableError:
+            if deadline is not None:
+                ReadTokenPoolOperations.request_timeout(1, deadline, monotonic)
+            raise
+
+    @staticmethod
+    def check_http_error_deadline(
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+        *,
+        pool_managed: bool,
+        is_rate_limit: bool,
+    ) -> None:
+        if pool_managed and is_rate_limit:
+            return
+        ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+
+    @staticmethod
+    def _run_without_pool[ReadResult](
+        operation: Callable[[str | None, str], tuple[ReadResult, int | None]],
+        identity_for_token: Callable[[str | None], str],
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+    ) -> ReadResult:
+        try:
+            result, _ = operation(None, identity_for_token(None))
+            return result
+        except RetryableError:
+            ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+            raise
+
+    @staticmethod
+    def remaining_seconds(
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+    ) -> float | None:
+        if deadline is None:
+            return None
+        remaining = deadline - (monotonic or time.monotonic)()
+        if remaining <= 0:
+            raise ReadTokenPoolOperations.DeadlineExpired("GitHub API inventory deadline expired")
+        return remaining
+
+    @staticmethod
+    def request_timeout(
+        timeout_seconds: int,
+        deadline: float | None,
+        monotonic: Callable[[], float] | None,
+    ) -> int:
+        remaining = ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+        if remaining is None:
+            return timeout_seconds
+        timeout = min(timeout_seconds, floor(remaining))
+        if timeout < 1:
+            raise ReadTokenPoolOperations.DeadlineExpired("GitHub API inventory deadline expired")
+        return timeout
+
+    @staticmethod
+    def run[ReadResult](
+        resource: str,
+        operation: Callable[[str | None, str], tuple[ReadResult, int | None]],
+        pool: ReadTokenPool | None,
+        identity_for_token: Callable[[str | None], str],
+        *,
+        deadline: float | None = None,
+        monotonic: Callable[[], float] | None = None,
+    ) -> ReadResult:
+        if pool is None:
+            return ReadTokenPoolOperations._run_without_pool(operation, identity_for_token, deadline, monotonic)
+
+        attempted: set[str] = set()
+        last_rate_limit: RetryableError | None = None
+        while True:
+            ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+            credential = pool.select(resource, excluded=attempted)
+            ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+            if credential is None:
+                break
+            attempted.add(credential.secret_name)
+            try:
+                result, remaining = operation(credential.token, credential.secret_name)
+            except RetryableError as exc:
+                if not exc.is_rate_limit:
+                    ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+                    raise
+                pool.record_remaining(credential.secret_name, resource, exc.remaining)
+                pool.mark_rate_limited(credential.secret_name, exc)
+                ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+                last_rate_limit = exc
+                continue
+            pool.record_remaining(credential.secret_name, resource, remaining)
+            return result
+
+        if last_rate_limit is not None and not pool.default_token:
+            raise ProviderRateLimitError(
+                retry_after_seconds=last_rate_limit.retry_after,
+                reset_timestamp=last_rate_limit.reset_timestamp,
+                remaining=last_rate_limit.remaining,
+                provider=last_rate_limit.provider or "github",
+                credential_identity=last_rate_limit.credential_identity,
+                source=last_rate_limit.source,
+                is_rate_limit=True,
+            )
+        if pool.default_is_active:
+            raise ProviderRateLimitError(
+                provider="github",
+                credential_identity=pool.default_identity,
+                source="fallback",
+                is_rate_limit=True,
+            )
+        ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+        try:
+            result, remaining = operation(pool.default_token or None, pool.default_identity)
+        except RetryableError as exc:
+            if not exc.is_rate_limit:
+                ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+                raise
+            pool.record_remaining(pool.default_identity, resource, exc.remaining)
+            pool.mark_rate_limited(pool.default_identity, exc)
+            ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+            raise ProviderRateLimitError(
+                retry_after_seconds=exc.retry_after,
+                reset_timestamp=exc.reset_timestamp,
+                remaining=exc.remaining,
+                provider=exc.provider or "github",
+                credential_identity=pool.default_identity,
+                source=exc.source,
+                is_rate_limit=True,
+            ) from exc
+        pool.record_remaining(pool.default_identity, resource, remaining)
+        return result
+
+
+def _read_cooldown_value(provider: Any, *, use_writer_token: bool) -> str | None:
+    """Read cooldown data without nested retries when an inventory deadline is active."""
+    deadline, monotonic = _REQUEST_CONTEXT.get()
+    getter = provider.get_variable
+    if deadline is not None:
+        function = getattr(getter, "__func__", getter)
+        original = getattr(function, "__wrapped__", None)
+        if original is not None:
+            getter = original.__get__(provider, type(provider))
+    try:
+        from agentic_devtools.cli.ci.cooldown import COOLDOWN_VARIABLE
+
+        return getter(COOLDOWN_VARIABLE, use_writer_token=use_writer_token)
+    except RetryableError as exc:
+        if deadline is None:
+            raise
+        ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+        if exc.is_rate_limit:
+            raise ProviderRateLimitError(
+                retry_after_seconds=exc.retry_after,
+                reset_timestamp=exc.reset_timestamp,
+                remaining=exc.remaining,
+                provider=exc.provider,
+                credential_identity=exc.credential_identity,
+                source=exc.source,
+                is_rate_limit=True,
+            ) from exc
+        raise
+    except Exception:
+        if deadline is not None:
+            ReadTokenPoolOperations.remaining_seconds(deadline, monotonic)
+        raise

{agentic_devtools-0.2.613.dist-info → agentic_devtools-0.2.615.dist-info}/METADATA

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

{agentic_devtools-0.2.613.dist-info → agentic_devtools-0.2.615.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentic_devtools/__init__.py,sha256=gvLzsZ6L3Abr4sPHr4OJ_rdZDD8cFzXacaV0LGs8dVc,539
-agentic_devtools/_version.py,sha256=YS-Bw9zYTY2rMBsUieoT2_Cvu5Pg9gNaLVIdNU0bAdQ,524
+agentic_devtools/_version.py,sha256=rn1c15V5w4TsR9WAAMV4hET9UCHsIiBfWyOomDAk1UY,524
 agentic_devtools/agdt_gitignore.py,sha256=vVVqTjBZ_ijn6U3Lnh_JGrARLschYVN-fFal9jDk0Ak,2694
 agentic_devtools/background_tasks.py,sha256=sFgmqOnCdCjclABJ8V__yDwBXDyi45b1Z-MVv3G2zB8,17664
 agentic_devtools/config.py,sha256=DEVxTVZhsQbVQwO9qdB_1h19aBpjMzF6xJY_ePYLGLs,15629
@@ -232,14 +232,15 @@ agentic_devtools/cli/ci/ado_provider.py,sha256=6FpNOEF7zeeKdYwIgN56v7F7xpUZUYQLH
 agentic_devtools/cli/ci/agent_assignment.py,sha256=xALWk47PMo2uW44kgMm6K7EXfQN5NCv3zyyzWScIAfE,46026
 agentic_devtools/cli/ci/agent_task_diagnostics.py,sha256=7kVeBKqHn3h4yOXO3sTskOW1NuRj2uMAUYuhIAXRlGE,4306
 agentic_devtools/cli/ci/agent_task_inventory.py,sha256=1JUh6v1Wcgeo7vA49D_IU5LAm1-ohT21iEllV-HYjaY,14006
-agentic_devtools/cli/ci/agent_task_lifecycle.py,sha256=i9ue79HXhpLhckpCLm7p281Dr-imkcUzNHxR3j77WhI,4961
+agentic_devtools/cli/ci/agent_task_lifecycle.py,sha256=aIy_uTtlORd14GJ40CVI_N3TvpBhKvtGqrvyHzwm5_s,10917
 agentic_devtools/cli/ci/approver_preflight.py,sha256=uM_LF0qrf_nMyGJT8CUvdqh0comD_AAsS9Sw_9HqBTA,5865
 agentic_devtools/cli/ci/canonical_dispatch_identity.py,sha256=VmWs3eHBs6HU2IRV_ngMUzk24pZJVE1KBFahtTvGZPA,2799
 agentic_devtools/cli/ci/commands.py,sha256=REVb_t8Ei4F37JmAn57FafIwzBa_u7PNhKkJHvchx5o,27282
 agentic_devtools/cli/ci/comment_format.py,sha256=-jbcUa1AtArU95gnGyhQ1asm704j1zYAf1m1bz7WhS8,1415
 agentic_devtools/cli/ci/conflict_repair_dispatch.py,sha256=nqdRa8DWOPx4DjLVvojUlsG9LmfFiZPtNt9eWxi_NJg,6715
 agentic_devtools/cli/ci/conflict_repair_markers.py,sha256=Bs4WG2aSlSz7MJG0o84fGwn-Zx0uFe67OGVWXZLbpsc,1528
-agentic_devtools/cli/ci/cooldown.py,sha256=iTtMBh6W1xvfdyk4pBN-IHImvMH9IZfvi5iXuZYvw5I,13756
+agentic_devtools/cli/ci/cooldown.py,sha256=yMmqQZB3wegKk8fO3mFw4sAPANKXrNJhHArrLfckB7g,10578
+agentic_devtools/cli/ci/cooldown_persistence.py,sha256=YrJdiGPnAZDYZkcgMG_iV4NsNcnEwBjKs9N0iYppwTE,4129
 agentic_devtools/cli/ci/credential_roles.py,sha256=p057fFf-g7jvaCcnoqWp4MjaPLOp3VcDfxNUaNf92nE,1649
 agentic_devtools/cli/ci/critique_adjudicator.py,sha256=pUe19bKhr8HkwCqAscScXQHm48XLz5qBiyTtEMLARd8,18533
 agentic_devtools/cli/ci/critique_provider.py,sha256=tP_lu4UiwTEn9ti4pHAEiMiWmKCAkByKhAZOIwgYIqs,3551
@@ -253,7 +254,7 @@ agentic_devtools/cli/ci/exceptions.py,sha256=zpKWOgnBbHHQgAQRvdRW4VFnE_qdgqgmo8r
 agentic_devtools/cli/ci/finalization_state.py,sha256=jQm_cH0J09LCZfEUdZK2XQNZFhF7KhyilKcGZ4g8Wzc,8978
 agentic_devtools/cli/ci/github_api_error.py,sha256=SvaOqag7OrnGyFMDjbl3Mr5LkjDM4bix9kXXvL5sHsQ,2382
 agentic_devtools/cli/ci/github_pr_files.py,sha256=7QWw5adLFKMci8AtewkJfLWle3I3irF6pZ4qdhQWGU8,2697
-agentic_devtools/cli/ci/github_provider.py,sha256=Bgbdl9hJvN89LUWyAaJb8LvklqFcQB2eJ_1-wUq0wug,502557
+agentic_devtools/cli/ci/github_provider.py,sha256=k1Ch8gTa6qliMOyTFoBxEv5KoFVuQUizNUQiKW6Yz-E,498035
 agentic_devtools/cli/ci/guards.py,sha256=MQbtBWTpwWgNlWPJ1VJL4oZA8XciKs4J1jsN28BQBfQ,59920
 agentic_devtools/cli/ci/initial_delivery_claims.py,sha256=Aze3eNjk0XrK8FwX87MGt0Mjz9RTDl66xdx45p659ic,9764
 agentic_devtools/cli/ci/job_logs.py,sha256=YUiW487uO0usSwWD-mpWrs6q7IedQuYyhhBJIc0EAfk,12772
@@ -274,7 +275,8 @@ agentic_devtools/cli/ci/provider_repository.py,sha256=0FqIbTExEFN5Xrj7eq9p6OmUke
 agentic_devtools/cli/ci/provider_reviews.py,sha256=z63kEFkBXs8kUJW-OE8tzYtEmUEtRIZPzmvFWh-KQKs,6673
 agentic_devtools/cli/ci/provider_scheduler.py,sha256=SgoQaA2mwF_EmD_OpsJUGkr2-bSkuq34uhIuZ-B_dUM,7086
 agentic_devtools/cli/ci/push_attribution.py,sha256=BcG5p1OAbdE_LrX8w7dKNHsXI2RchP4z5T6ObxOHfRI,4276
-agentic_devtools/cli/ci/read_token_pool.py,sha256=BRxAjEP92Nw-cpq7EJAqyv3r4PXOYCb4gYsNZxIo9KI,17833
+agentic_devtools/cli/ci/read_token_pool.py,sha256=aHhPsAXaCHIThmNuzjX6H0KXYCbPubO7q88smfhXcBM,18574
+agentic_devtools/cli/ci/read_token_pool_execution.py,sha256=i6LP6LLT12V6vOY91js2dFgpnDcR08yhSU4asANjw10,11575
 agentic_devtools/cli/ci/repair_accounting.py,sha256=BHMtgKGVmcziFyxbNAmRCNJzk1MDnBVr9a0Gx7CLAPM,18495
 agentic_devtools/cli/ci/repair_prompt.py,sha256=KnNyDRuTmDyDUP7M47FDPZeREmZMFlri8Yntkb38pEU,3241
 agentic_devtools/cli/ci/retry.py,sha256=aCYvnKEoqfP6lAM3Bh744uARZtl5XI1EuVsJmOBvnEU,8651
@@ -1318,8 +1320,8 @@ agentic_devtools/_bundled_skills/skills/speckit-plan/SKILL.md,sha256=qYLpzgLCIZ6
 agentic_devtools/_bundled_skills/skills/speckit-specify/SKILL.md,sha256=HbHRbdphMqbtNw6fL6NcYCj6sSFmUyk2S4U0bZ9p_l4,13681
 agentic_devtools/_bundled_skills/skills/write-github-commit-message/SKILL.md,sha256=Ep1lR8NDN117Iytj172VZgqazFiLpJ56Z7RXgaTnxR8,2626
 agentic_devtools/_bundled_skills/skills/write-github-commit-message/commit-types.md,sha256=bTy_t68ZD6R87rFIzq9wybTu8Wudoahb7nB9IWC4bFo,1839
-agentic_devtools-0.2.613.dist-info/METADATA,sha256=zwafKMjcPJEwGkHWpNaQGsiiVcirSDStqRaLUp7J9_w,35589
-agentic_devtools-0.2.613.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-agentic_devtools-0.2.613.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
-agentic_devtools-0.2.613.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.613.dist-info/RECORD,,
+agentic_devtools-0.2.615.dist-info/METADATA,sha256=19HQlADjD0-el0pLulpWfRQs0Vk7XODAxOuCo9b_qZg,35589
+agentic_devtools-0.2.615.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+agentic_devtools-0.2.615.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
+agentic_devtools-0.2.615.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.615.dist-info/RECORD,,