agentic-devtools 0.2.595__py3-none-any.whl → 0.2.596__py3-none-any.whl

agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/SKILL.md

@@ -249,7 +249,7 @@ An item is **unresolvable** if:
 - It depends on external behavior that remains unsupported after checking authoritative
   documentation or pinned source for the relevant version and effective project configuration.
   Repository absence alone is not enough to make the behavior unresolvable. Before classifying it,
-  apply the evidence procedure in [Phase 3.3, step 4](#33-feasibility-and-evidence-gate). If the
+  apply the evidence procedure in [Phase 3.3, step 5](#33-feasibility-and-evidence-gate). If the
   evidence establishes the behavior, record its citation and whether it was **source-verified** or
   **exercised** in the clarification log, resolve the ambiguity, and continue. If evidence is
   missing, inaccessible, inapplicable, contradictory, or insufficient to establish effective
@@ -318,28 +318,60 @@ instructions and validators, and authoritative external sources for any claimed
    tests, check the source-to-test folder mapping, directory depth, package markers, and the
    validator itself rather than relying only on a wrapper or confidence label. Record the
    authoritative path rule and evidence for each path.
-4. For every implementation-dependent claim about an external tool, build backend, service, or
+4. Assess physical-line capacity for every prescribed Python source or test file expected to
+   change or be created within the file-length guard's scope: repository-root `*.py` files and
+   files under `agentic_devtools/`, `scripts/`, `tests/`, `.github/`, `.agents/`, and `.agdt/`,
+   excluding guard-ignored runtime paths. Use `agentic_devtools/cli/checks/file_length.py` as the
+   authority for guarded roots, ignored paths, counting semantics, and the 500-line hard ceiling.
+   Record prescribed Python paths outside that scope as `not guarded`. For each existing guarded
+   file, count physical lines on the current default branch with the guard's semantics,
+   `sum(1 for _ in source_file)`; blank lines count, and nonblank-only counts are invalid.
+   Resolve the ceiling from `quality-baseline.json`'s `file_length` map using the repo-relative
+   destination POSIX path, whether or not the file currently exists: a recorded entry is the
+   ceiling, and only a missing entry uses 500 lines. Display an absent proposed file as `new`, but
+   use zero as its current count for projection and headroom calculations; this also applies when
+   recreating a path with a retained baseline entry. For a renamed or moved file, use the
+   destination path and its baseline entry, if any. Record current lines (or `new`), ceiling and
+   source, an evidence-based post-Ruff-format delta range, projected lines, headroom, and the
+   evidence and formatting assumptions/uncertainty supporting the estimate. Cite the default-
+   branch file-count evidence for existing files and the matching destination-path baseline entry,
+   or confirm that no entry exists. Ground the range in the specified behavior and comparable
+   existing code; projected lines are current lines plus the high bound, using zero as current
+   lines for a new file. Headroom is `max(0, ceiling - current lines)`, also using zero for a new
+   file; an existing baseline overrun has zero headroom. Mark the file `PASS` only when the
+   high-bound projection is at or below its ceiling. No fixed safety margin applies. If the range
+   cannot be grounded, mark it `UNVERIFIED`. When a projection exceeds its ceiling or is unverified,
+   correct the boundary toward a cohesive companion source/test module per
+   `docs/file-split-playbook.md` only when issue intent permits, preserving explicit exclusions
+   and public-contract constraints, then repeat this capacity assessment for the corrected paths.
+   Otherwise record `FAIL` or `UNVERIFIED` and use step 7's existing abort path. If no Python file
+   is prescribed, record `None — no Python files prescribed`; the capacity check passes trivially.
+   This is a content-level assessment, not deterministic code enforcement.
+5. For every implementation-dependent claim about an external tool, build backend, service, or
    API, cite authoritative documentation or source pinned to the relevant version/commit and
    effective project configuration. State what the evidence establishes and whether it was
    **source-verified** or **exercised**. A response field's name or type alone does not establish
    semantics not established by its contract. If the relevant version/configuration or behavior is
    not established, mark the claim unverified; a partial trace establishes neither support nor
    impossibility.
-5. Record the gate result using the format below. For each criterion, mark `PASS`, `FAIL`, or
-   `UNVERIFIED` and cite the trace, path authority, or external evidence that supports the result.
+6. Record the gate result using the format below, including the capacity evidence table from the
+   specification template. For each criterion, mark `PASS`, `FAIL`, or `UNVERIFIED` and cite the
+   trace, path authority, capacity evidence, or external evidence that supports the result.
    Record `None` explicitly for empty result categories. Revisit correctable contradictions and
-   rerun the affected checks. A pass requires every criterion and required path/claim to be
-   evidenced, with no failed or unverified item. This is a content-level workflow check, not a
-   deterministic code-level enforcement mechanism.
-6. If multiple independent behaviors remain, use [Abort: Scope Violation](#abort-scope-violation).
+   rerun the affected checks. A capacity failure or unverified estimate prevents a passing result.
+   A pass requires every criterion and required path/claim to be evidenced, with no failed or
+   unverified item. This is a content-level workflow check, not a deterministic code-level
+   enforcement mechanism.
+7. If multiple independent behaviors remain, use [Abort: Scope Violation](#abort-scope-violation).
    For an unresolved product decision, explicit boundary conflict, missing authority, or missing
    external evidence, use [Abort: Needs Human Input](#abort-needs-human-input). Include every
    failed or unverified criterion, its evidence and trace, the conflicting or missing evidence,
    and the decision/evidence needed to proceed. The escalation report is not an implementation-ready
    specification; Phase 4 publication is available only after the gate passes.
-7. After a pass, carry the gate result into the `Feasibility Gate Result` section of the
+8. After a pass, carry the gate result into the `Feasibility Gate Result` section of the
    specification template. Label external evidence as source-verified or exercised. A passing
-   result must state that failed and unverified criteria are `None`.
+   result must state that failed and unverified criteria are `None` and include capacity evidence
+   for every prescribed guarded Python file.
 
 Example gate result:
 
@@ -400,6 +432,38 @@ Evidence:
   leaves the behavior unverified, and takes `Abort: Needs Human Input`; publication remains blocked.
   Actual content walkthrough: the ambiguity is unresolvable, so refinement stops before
   publication, and the Phase 3.3 gate is not bypassed or presumed to pass.
+- **Reject or correct — #4571-style zero headroom and uncertain near-limit estimate.** Input:
+  (a) a hypothetical feasibility snapshot of an existing unbaselined module at 500 lines, as
+  historically evidenced for #4571 at `72c5fa9`, with a same-module-only post-Ruff estimate of
+  +1–3 lines including formatting uncertainty; (b) a near-limit unbaselined module at 495 lines
+  with a post-Ruff estimate of +3–7 lines including uncertainty, where the low-bound projection
+  is 498 but the high-bound projection is 502. Both ceilings are 500, with zero and five lines of
+  initial headroom respectively. Expected: neither case passes its prescribed boundary; correct
+  to a cohesive companion only if intent permits, otherwise fail/escalate through the existing
+  abort path. The historical #4571 evidence does not claim a later unretained implementation.
+- **Reject — synthetic baseline ceiling projection grounded in #4470.** Input: a clearly synthetic
+  pre-dispatch scenario with current lines 606, baseline ceiling 606, and a +22-line estimate
+  (post-Ruff range +22–22, with no additional formatting uncertainty), projecting 628 and zero
+  initial headroom. The #4470 report is evidence of an implementation result at 628 against
+  baseline 606; it does not establish pre-change length. Expected: fail against the recorded
+  606-line ceiling, not the unbaselined 500-line ceiling; correct the boundary if authorized,
+  otherwise use the existing abort path.
+- **Pass — sufficient baseline headroom.** Input: an existing file at 280 lines with a 320-line
+  baseline and an evidenced post-Ruff +20-line estimate (range +20–20, with no additional
+  formatting uncertainty), projecting 300. Initial headroom is 40 lines and remaining headroom is
+  20. Expected: pass this capacity check because the high-bound projection is within the baseline
+  ceiling.
+- **Pass — new Python source and test ceilings.** Input: one proposed new source file with an
+  estimated post-Ruff size of 35–45 lines and one proposed new test file with 25–35 lines; neither
+  path exists in `quality-baseline.json`, and both ranges include formatting uncertainty. Expected:
+  assess both paths, show `new` and the 500-line ceiling for each, show 500 lines of initial
+  headroom, project 45 and 35 lines respectively, and pass their capacity checks. New test files
+  are not omitted.
+- **Fail — recreated source and test paths with retained ceilings.** Input: one absent proposed
+  source path and one absent proposed test path, each still present in `quality-baseline.json` with
+  a 300-line ceiling, and each with an estimated post-Ruff delta of +400 lines. Expected: display
+  each current count as `new`, use zero for the calculation, show 300 lines of initial headroom and
+  a 400-line projection, and fail both capacity checks. Neither path may fall back to 500 or pass.
 
 ---
 

agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/specification-templates.md

@@ -42,6 +42,22 @@ Outcome: PASS — content-level workflow assessment, not deterministic enforceme
 |---|---|---|
 | {AC-1} | PASS | {Producer/behavior → consumer/wiring → observable output; path authority or external source, version/configuration, and source-verified/exercised status as applicable.} |
 
+Capacity evidence:
+
+| Path | Current lines (or new) | Ceiling (destination-path baseline or 500) | Estimated delta range | Projected lines | Headroom (`max(0, ceiling − current)`) | Result |
+|---|---:|---:|---:|---:|---:|---|
+| {repo-relative path} | {count or new} | {destination-path baseline count or 500 if no entry} | {+low–high lines} | {current + high; use 0 as current for new} | {max(0, ceiling − current); use 0 as current for new} | {PASS/FAIL/UNVERIFIED} |
+
+Include every prescribed guarded Python source and test file expected to change or be created.
+Resolve the ceiling by the repo-relative destination path, whether or not the file exists: a
+matching baseline entry is the ceiling, and 500 applies only when no entry exists. Display an
+absent file's current lines as `new`, but use zero as its current count for projection and headroom;
+this includes recreated paths with retained baseline entries. For each existing file, cite its
+default-branch line count. For each path, cite the matching destination-path baseline entry or
+state that no entry exists. For each estimate, cite the behavior and comparable-code evidence, and
+state the Ruff-format assumptions and uncertainty. Record prescribed paths outside the guard scope
+as `not guarded`. If no Python file is prescribed, write `None — no Python files prescribed`.
+
 Passed: {criterion IDs}. Failed: None. Unverified: None.
 
 ## Detailed Requirements
@@ -120,6 +136,21 @@ Outcome: PASS — content-level workflow assessment, not deterministic enforceme
 ||Criterion||Result||Evidence and trace||
 |{AC-1}|PASS|{Producer/behavior → consumer/wiring → observable output; path authority or external source, version/configuration, and source-verified/exercised status as applicable.}|
 
+Capacity evidence:
+
+||Path||Current lines (or new)||Ceiling (destination-path baseline or 500)||Estimated delta range||Projected lines||Headroom (max(0, ceiling − current))||Result||
+|{repo-relative path}|{count or new}|{destination-path baseline count or 500 if no entry}|{+low–high lines}|{current + high; use 0 as current for new}|{max(0, ceiling − current); use 0 as current for new}|{PASS/FAIL/UNVERIFIED}|
+
+Include every prescribed guarded Python source and test file expected to change or be created.
+Resolve the ceiling by the repo-relative destination path, whether or not the file exists: a
+matching baseline entry is the ceiling, and 500 applies only when no entry exists. Display an
+absent file's current lines as `new`, but use zero as its current count for projection and headroom;
+this includes recreated paths with retained baseline entries. For each existing file, cite its
+default-branch line count. For each path, cite the matching destination-path baseline entry or
+state that no entry exists. For each estimate, cite the behavior and comparable-code evidence, and
+state the Ruff-format assumptions and uncertainty. Record prescribed paths outside the guard scope
+as `not guarded`. If no Python file is prescribed, write `None — no Python files prescribed`.
+
 Passed: {criterion IDs}. Failed: None. Unverified: None.
 
 h2. Detailed Requirements

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.595'
-__version_tuple__ = version_tuple = (0, 2, 595)
+__version__ = version = '0.2.596'
+__version_tuple__ = version_tuple = (0, 2, 596)
 
 __commit_id__ = commit_id = None

agentic_devtools/cli/ci/github_provider.py

@@ -410,6 +410,7 @@ _HUNK_HEADER_RE = re.compile(r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \
 
 if TYPE_CHECKING:
     from agentic_devtools.cli.audit.models import ClaimResult, ClosedPRInfo
+    from agentic_devtools.cli.ci.initial_delivery_claims import InitialDeliveryClaims
     from agentic_devtools.cli.ci.reconciliation.models import CloudWriterRunInventory, ObservationOutcome, WorkflowRun
     from agentic_devtools.cli.ci.scheduler import DispatchEvent, EligiblePR
 
@@ -10774,31 +10775,34 @@ query($owner: String!, $repo: String!, $number: Int!) {
             raise RuntimeError(f"Failed to post comment on issue #{issue_number}: response carried no comment ID")
         return comment_id
 
-    @retry_with_backoff(max_retries=0)
+    def _get_initial_delivery_claims(self) -> InitialDeliveryClaims:
+        from agentic_devtools.cli.ci.initial_delivery_claims import InitialDeliveryClaims
+
+        return InitialDeliveryClaims(self._repo)
+
     def dispatch_agent_retry(self, pr_number: int, prompt: str, failure_event_id: str) -> int:
+        return self._dispatch_agent_retry(pr_number, prompt, failure_event_id)
+
+    @retry_with_backoff(max_retries=0)
+    def _dispatch_agent_retry(self, pr_number: int, prompt: str, key: str, *, initial_delivery: bool = False) -> int:
         """Post one @copilot-first retry comment with its marker using the workflow token."""
-        from agentic_devtools.cli.ci.guards import (
-            _AGENT_RETRY_IDENTITY_MARKER_RE,
-            _agent_retry_comment_header,
-        )
+        from agentic_devtools.cli.ci.guards import _AGENT_RETRY_IDENTITY_MARKER_RE, _agent_retry_comment_header
 
-        marker_pattern = re.compile(rf"<!-- agdt:agent-retry:{re.escape(failure_event_id)}:(\d+) -->")
+        namespace = "initial-delivery-retry" if initial_delivery else "agent-retry"
+        marker_pattern = re.compile(rf"<!-- agdt:{namespace}:{re.escape(key)}:(\d+) -->")
         metadata, _, context = prompt.partition("\n\n")
         marker_match = marker_pattern.search(metadata)
         if marker_match is None:
             raise ValueError("agent retry prompt is missing its failure marker")
         marker = marker_match.group(0)
         alias_pattern = re.compile(r"<!-- agdt:agent-retry-alias:([^:\s>]+) -->")
-        alias_markers = [
-            f"<!-- agdt:agent-retry-alias:{alias} -->" for alias in dict.fromkeys(alias_pattern.findall(metadata))
-        ]
+        alias_markers = [f"<!-- agdt:agent-retry-alias:{a} -->" for a in dict.fromkeys(alias_pattern.findall(metadata))]
         identity_markers = [
             f"<!-- agdt:agent-retry-identity:{source}:{identity} -->"
             for source, identity in dict.fromkeys(_AGENT_RETRY_IDENTITY_MARKER_RE.findall(metadata))
         ]
-        content = re.sub(r"<!-- agdt:agent-retry:[^:\s>]+:\d+ -->", "", metadata)
-        content = alias_pattern.sub("", content)
-        content = _AGENT_RETRY_IDENTITY_MARKER_RE.sub("", content)
+        content = re.sub(rf"<!-- agdt:{namespace}:[^:\s>]+:\d+ -->", "", metadata)
+        content = _AGENT_RETRY_IDENTITY_MARKER_RE.sub("", alias_pattern.sub("", content))
         content = "\n\n".join(part.strip() for part in (content, context) if part.strip())
         content = re.sub(r"@copilot", "", content, flags=re.IGNORECASE).strip()
         retry_header = "\n".join([marker, *alias_markers, *identity_markers])
@@ -10808,8 +10812,7 @@ query($owner: String!, $repo: String!, $number: Int!) {
             body = _enforce_comment_size_limit(body)
         if len(body) > _MAX_COMMENT_BODY_CHARS:
             suffix = "\n\n[Retry context truncated to fit GitHub's comment limit.]"
-            reserved = len(prefix) + len(suffix)
-            body = f"{prefix}{content[: max(0, _MAX_COMMENT_BODY_CHARS - reserved)]}{suffix}"
+            body = f"{prefix}{content[: max(0, _MAX_COMMENT_BODY_CHARS - len(prefix) - len(suffix))]}{suffix}"
         try:
             return self._post_comment_as_pr_token_once(pr_number, body)
         except RetryableError as exc:
@@ -10831,7 +10834,12 @@ query($owner: String!, $repo: String!, $number: Int!) {
                 comment
                 for comment in comments
                 if comment.author.casefold() == dispatch_login.casefold()
-                and marker in _agent_retry_comment_header(comment.body)
+                and marker
+                in (
+                    comment.body.split("\n\n", 2)[1].splitlines()
+                    if initial_delivery and comment.body.startswith("@copilot\n\n")
+                    else _agent_retry_comment_header(comment.body)
+                )
             ]
             if matching_comments:
                 return max(matching_comments, key=lambda comment: comment.id).id

agentic_devtools/cli/ci/initial_delivery_claims.py

@@ -0,0 +1,227 @@
+"""Repository-backed initial-delivery claims and staged escalation reservations."""
+
+from __future__ import annotations
+
+import base64
+import json
+import re
+from datetime import UTC, datetime, timedelta
+from typing import Any, cast
+
+from agentic_devtools.cli.ci.reconciliation.queue_store import (
+    GitHubVariableBackingStore,
+    _is_conflict_error,
+    _is_not_found_error,
+)
+from agentic_devtools.cli.ci.retry import retry_with_backoff
+from agentic_devtools.cli.shared.retry import RetryableError
+
+_ESCALATION_RESERVATION_TTL = timedelta(minutes=15)
+
+
+class InitialDeliveryClaims:
+    """One shared claim per original delivery and purpose.
+
+    Recovery and delivery claims are immutable. Escalation reservations use the
+    GitHub contents blob SHA for owner-checked compare-and-swap stage changes.
+    Never delete claims or retry an ambiguous create. The existing
+    ``ai-pr-loop-state`` branch must already be initialized.
+    """
+
+    def __init__(self, repo: str) -> None:
+        if (
+            not isinstance(repo, str)
+            or re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]*/[A-Za-z0-9][A-Za-z0-9_.-]*", repo) is None
+        ):
+            raise ValueError("repo must be a canonical owner/name")
+        self._repo = repo
+
+    @staticmethod
+    @retry_with_backoff(max_retries=0)
+    def _api(endpoint: str, *, method: str = "GET", body: dict[str, Any] | None = None) -> str:
+        """Use the existing repository-state credential boundary without retries."""
+        return GitHubVariableBackingStore._api(endpoint, method=method, body=body)
+
+    def _endpoint(self, pr: int, key: str, purpose: str) -> str:
+        if (
+            isinstance(pr, bool)
+            or not isinstance(pr, int)
+            or pr <= 0
+            or not isinstance(key, str)
+            or re.fullmatch(r"[0-9a-f]{64}", key) is None
+            or purpose not in {"recovery", "escalation", "delivered"}
+        ):
+            raise ValueError("invalid initial-delivery claim identity")
+        return f"/repos/{self._repo}/contents/.agdt/initial-delivery/{pr}/{key}/{purpose}.json"
+
+    def _read_versioned(self, pr: int, key: str, purpose: str) -> tuple[dict[str, Any], str] | None:
+        """Read a claim and its blob SHA for narrowly scoped compare-and-swap updates."""
+        try:
+            raw = self._api(f"{self._endpoint(pr, key, purpose)}?ref=ai-pr-loop-state")
+        except RuntimeError as exc:
+            if _is_not_found_error(exc):
+                return None
+            raise
+        metadata = json.loads(raw)
+        content = base64.b64decode(metadata["content"].replace("\n", ""), validate=True)
+        if len(content) > 16_000:
+            raise ValueError("initial-delivery claim exceeds bounded size")
+        record = json.loads(content)
+        if not isinstance(record, dict) or not isinstance(record.get("created_at"), str):
+            raise ValueError("malformed initial-delivery claim")
+        now = datetime.now(UTC)
+        created = datetime.fromisoformat(record["created_at"])
+        if created.tzinfo is None or created > now:
+            raise ValueError("invalid initial-delivery claim timestamp")
+        if "updated_at" in record:
+            updated_at = record["updated_at"]
+            if not isinstance(updated_at, str):
+                raise ValueError("invalid initial-delivery claim timestamp")
+            updated = datetime.fromisoformat(updated_at)
+            if updated.tzinfo is None or updated < created or updated > now:
+                raise ValueError("invalid initial-delivery claim timestamp")
+        sha = metadata.get("sha")
+        if not isinstance(sha, str) or not sha:
+            raise ValueError("malformed initial-delivery claim")
+        return record, sha
+
+    def read(self, pr: int, key: str, purpose: str) -> dict[str, Any] | None:
+        """Read a claim; malformed/unavailable data is never treated as absence."""
+        versioned = self._read_versioned(pr, key, purpose)
+        return versioned[0] if versioned is not None else None
+
+    def claim(self, pr: int, key: str, purpose: str, evidence: dict[str, Any]) -> bool:
+        """Create once before mutation; only a confirmed create authorizes work."""
+        endpoint = self._endpoint(pr, key, purpose)
+        record = {**evidence, "created_at": datetime.now(UTC).isoformat()}
+        content = json.dumps(record).encode()
+        if len(content) > 16_000:
+            raise ValueError("initial-delivery claim exceeds bounded size")
+        try:
+            self._api(
+                endpoint,
+                method="PUT",
+                body={
+                    "branch": "ai-pr-loop-state",
+                    "message": f"chore(#{pr}): claim initial-delivery {purpose}\n\n#{pr}",
+                    "content": base64.b64encode(content).decode("ascii"),
+                },
+            )
+        except RuntimeError, RetryableError:
+            if self.read(pr, key, purpose) is not None:
+                return False
+            raise
+        return True
+
+    def _reserve_escalation(self, pr: int, key: str, evidence: dict[str, Any], owner_token: str) -> bool:
+        """Create or CAS-acquire one owner's escalation reservation."""
+        if not isinstance(owner_token, str) or re.fullmatch(r"[0-9a-f]{32}", owner_token) is None:
+            raise ValueError("invalid escalation reservation owner")
+        reservation = {**evidence, "stage": "reserved", "owner_token": owner_token}
+        if self.claim(pr, key, "escalation", reservation):
+            return True
+        existing = self._read_versioned(pr, key, "escalation")
+        if existing is None:
+            return False
+        record, _sha = existing
+        if record.get("stage") == "reserved" and record.get("owner_token") == owner_token:
+            return True
+        if record.get("stage") == "reserved":
+            acquired = datetime.fromisoformat(record.get("updated_at", record["created_at"]))
+            if datetime.now(UTC) - acquired < _ESCALATION_RESERVATION_TTL:
+                return False
+            current_owner = record.get("owner_token")
+            if not isinstance(current_owner, str) or re.fullmatch(r"[0-9a-f]{32}", current_owner) is None:
+                return False
+            return self._transition_escalation(
+                pr,
+                key,
+                current_owner,
+                "reserved",
+                "reserved",
+                next_owner_token=owner_token,
+            )
+        if record.get("stage") != "retryable":
+            return False
+        current_owner = record.get("owner_token")
+        if not isinstance(current_owner, str) or re.fullmatch(r"[0-9a-f]{32}", current_owner) is None:
+            return False
+        return self._transition_escalation(
+            pr,
+            key,
+            current_owner,
+            "retryable",
+            "reserved",
+            next_owner_token=owner_token,
+        )
+
+    def _transition_escalation(
+        self,
+        pr: int,
+        key: str,
+        owner_token: str,
+        expected_stage: str,
+        next_stage: str,
+        *,
+        next_owner_token: str | None = None,
+    ) -> bool:
+        """CAS an escalation stage; ambiguous writes require exact read-back verification."""
+        allowed = {
+            ("reserved", "retryable"),
+            ("reserved", "reserved"),
+            ("retryable", "reserved"),
+            ("reserved", "attempted"),
+        }
+        if (
+            (expected_stage, next_stage) not in allowed
+            or not isinstance(owner_token, str)
+            or re.fullmatch(r"[0-9a-f]{32}", owner_token) is None
+            or (
+                next_owner_token is not None
+                and (not isinstance(next_owner_token, str) or re.fullmatch(r"[0-9a-f]{32}", next_owner_token) is None)
+            )
+            or (
+                (expected_stage, next_stage) in {("retryable", "reserved"), ("reserved", "reserved")}
+                and next_owner_token is None
+            )
+            or (
+                (expected_stage, next_stage) not in {("retryable", "reserved"), ("reserved", "reserved")}
+                and next_owner_token is not None
+            )
+        ):
+            raise ValueError("invalid escalation reservation transition")
+        versioned = self._read_versioned(pr, key, "escalation")
+        if versioned is None:
+            return False
+        record, sha = versioned
+        if record.get("stage") != expected_stage or record.get("owner_token") != owner_token:
+            return False
+        updated = dict(record)
+        updated["stage"] = next_stage
+        if next_owner_token is not None:
+            updated["owner_token"] = next_owner_token
+        updated["updated_at"] = datetime.now(UTC).isoformat()
+        content = json.dumps(updated).encode()
+        if len(content) > 16_000:
+            raise ValueError("initial-delivery claim exceeds bounded size")
+        try:
+            self._api(
+                self._endpoint(pr, key, "escalation"),
+                method="PUT",
+                body={
+                    "branch": "ai-pr-loop-state",
+                    "message": f"chore(#{pr}): advance initial-delivery escalation\n\n#{pr}",
+                    "content": base64.b64encode(content).decode("ascii"),
+                    "sha": sha,
+                },
+            )
+        except (RuntimeError, RetryableError) as exc:
+            if _is_conflict_error(cast(RuntimeError, exc)):
+                return False
+            observed = self._read_versioned(pr, key, "escalation")
+            if observed is not None and observed[0] == updated:
+                return True
+            if observed is not None and observed[0] == record:
+                return False
+            raise
+        return True

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

@@ -0,0 +1,500 @@
+"""Bounded recovery consumer for independently admitted initial-delivery evidence."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+from agentic_devtools.cli.ci.guards import AGENT_RETRY_CONFIRMATION_WINDOW
+from agentic_devtools.cli.ci.initial_delivery_claims import InitialDeliveryClaims
+from agentic_devtools.cli.ci.models import AgentTaskInventoryAvailability
+from agentic_devtools.cli.ci.pipeline.delivery import (
+    InitialDeliveryEvidence,
+    InitialDeliveryOutcome,
+    classify_initial_delivery_with_head,
+)
+from agentic_devtools.cli.ci.pipeline.models import ActionDecision, ActionResult
+from agentic_devtools.cli.ci.pipeline.session_detector import (
+    SessionOutcome,
+    SessionState,
+    get_latest_session_state,
+    is_copilot_session_active_via_agent_task,
+)
+from agentic_devtools.cli.ci.pipeline.snapshot_models import DerivedState, PRStateSnapshot
+from agentic_devtools.cli.ci.pipeline.snapshot_utils import _raise_if_rate_limit
+from agentic_devtools.cli.ci.provider import CIPlatformProvider
+from agentic_devtools.cli.shared.retry import ProviderRateLimitError
+
+if TYPE_CHECKING:
+    from agentic_devtools.cli.ci.pipeline.actions.retry_failed_session import RetryFailedSessionAction
+
+
+class InitialDeliveryRecovery:
+    """Consume one original-delivery claim, never a terminal-event or per-SHA cap."""
+
+    def __init__(self, action: RetryFailedSessionAction) -> None:
+        self._action = action
+        self._provider = action._provider
+
+    def _result(self, decision: ActionDecision, details: str) -> ActionResult:
+        return ActionResult(name=self._action.name, decision=decision, details=details)
+
+    def evaluate_session(
+        self, snapshot: PRStateSnapshot, derived: DerivedState, state: SessionState
+    ) -> ActionResult | None:
+        """Route terminal admission without changing the existing session guards."""
+        if state.outcome is SessionOutcome.UNKNOWN:
+            return ActionResult(
+                name=self._action.name,
+                decision=ActionDecision.BLOCKED,
+                preconditions={"session_outcome_known": False},
+                details="Latest Copilot session outcome is unknown",
+            )
+        if state.outcome is SessionOutcome.ACTIVE:
+            return ActionResult(
+                name=self._action.name,
+                decision=ActionDecision.BLOCKED,
+                preconditions={"session_active": True},
+                details="Active Copilot session blocks retry and subsequent pipeline actions",
+            )
+        if snapshot.initial_delivery is not None:
+            result = self.evaluate(snapshot, derived, state)
+            if result is not None:
+                return result
+        if state.outcome is not SessionOutcome.FAILED:
+            return ActionResult(
+                name=self._action.name,
+                decision=ActionDecision.SKIP,
+                preconditions={"session_failed": False},
+                details=f"Latest Copilot session outcome is {state.outcome.value}",
+            )
+        return None
+
+    @staticmethod
+    def _identity(evidence: object) -> str:
+        if (
+            not isinstance(evidence, InitialDeliveryEvidence)
+            or not isinstance(evidence.outcome, InitialDeliveryOutcome)
+            or not isinstance(evidence.initial_task_id, str)
+            or re.fullmatch(r"[A-Za-z0-9_-]{1,200}", evidence.initial_task_id) is None
+            or not isinstance(evidence.initial_plan_sha, str)
+            or re.fullmatch(r"[0-9a-f]{40}", evidence.initial_plan_sha) is None
+            or not isinstance(evidence.head_sha, str)
+            or re.fullmatch(r"[0-9a-f]{40}", evidence.head_sha) is None
+        ):
+            return ""
+        return hashlib.sha256(f"{evidence.initial_task_id}\n{evidence.initial_plan_sha}".encode()).hexdigest()
+
+    def _observe(self, snapshot: PRStateSnapshot, state: SessionState) -> InitialDeliveryOutcome | None:
+        evidence = snapshot.initial_delivery
+        if (
+            not self._identity(evidence)
+            or evidence is None
+            or evidence.head_sha != snapshot.head_sha
+            or state.inventory_availability is not AgentTaskInventoryAvailability.COMPLETE
+            or state.outcome not in {SessionOutcome.FINISHED, SessionOutcome.FAILED}
+            or not isinstance(state.task_id, str)
+            or not state.task_id
+        ):
+            return None
+        live = self._provider.get_pr_metadata(snapshot.pr_number)
+        if (
+            live.head_sha != snapshot.head_sha
+            or live.head_branch != snapshot.head_branch
+            or live.head_repo_full_name != snapshot.head_repo_full_name
+            or live.base_repo_full_name != snapshot.base_repo_full_name
+            or live.labels != snapshot.labels
+            or self._has_active_session(snapshot)
+        ):
+            return None
+        observed_head, outcome = classify_initial_delivery_with_head(
+            self._provider,
+            snapshot.pr_number,
+            completion_confirmed=state.outcome is SessionOutcome.FINISHED,
+            initial_plan_sha=evidence.initial_plan_sha,
+        )
+        if observed_head and observed_head != snapshot.head_sha:
+            return None
+        if self._provider.get_pr_metadata(snapshot.pr_number) != live:
+            return None
+        return outcome
+
+    def _has_active_session(self, snapshot: PRStateSnapshot) -> bool:
+        """Invalidate cached lifecycle and writer inventories before every safety check."""
+        self._provider.invalidate_agent_task_inventory(snapshot.pr_number)
+        return (
+            is_copilot_session_active_via_agent_task(
+                snapshot.base_repo_full_name,
+                snapshot.pr_number,
+                provider=self._provider,
+                head_branch=snapshot.head_branch,
+                pr_id=snapshot.pr_id,
+                head_sha=snapshot.head_sha,
+            )
+            is not False
+        )
+
+    @staticmethod
+    def _matches_delivered_handoff(
+        claim: object,
+        evidence: InitialDeliveryEvidence,
+    ) -> bool:
+        """Match a persisted completed recovery to its exact source, task and head."""
+        return (
+            isinstance(claim, dict)
+            and claim.get("initial_task_id") == evidence.initial_task_id
+            and claim.get("initial_plan_sha") == evidence.initial_plan_sha
+            and claim.get("head") == evidence.head_sha
+            and isinstance(claim.get("task_id"), str)
+            and re.fullmatch(r"[A-Za-z0-9_-]{1,200}", claim["task_id"]) is not None
+        )
+
+    @staticmethod
+    def _delivered_receipt_key(key: str, evidence: InitialDeliveryEvidence, task_id: str | None = None) -> str:
+        """Index immutable delivery receipts by admission, head, and optional task."""
+        return hashlib.sha256("\n".join(filter(None, (key, evidence.head_sha, task_id))).encode()).hexdigest()
+
+    def _record_delivered_handoff(
+        self,
+        store: InitialDeliveryClaims,
+        snapshot: PRStateSnapshot,
+        key: str,
+        evidence: InitialDeliveryEvidence,
+        task_id: str,
+    ) -> bool:
+        """Persist the exact verified task/head that completed initial-delivery recovery."""
+        record = {
+            "head": evidence.head_sha,
+            "initial_task_id": evidence.initial_task_id,
+            "initial_plan_sha": evidence.initial_plan_sha,
+            "task_id": task_id,
+        }
+        receipt_key = self._delivered_receipt_key(key, evidence)
+        if store.claim(snapshot.pr_number, receipt_key, "delivered", record):
+            return True
+        existing = store.read(snapshot.pr_number, receipt_key, "delivered")
+        if (
+            existing is None
+            or not self._matches_delivered_handoff(existing, evidence)
+            or existing.get("head") != snapshot.head_sha
+        ):
+            return False
+        if existing.get("task_id") == task_id:
+            return True
+        task_receipt_key = self._delivered_receipt_key(key, evidence, task_id)
+        if store.claim(snapshot.pr_number, task_receipt_key, "delivered", record):
+            return True
+        task_receipt = store.read(snapshot.pr_number, task_receipt_key, "delivered")
+        return (
+            task_receipt is not None
+            and self._matches_delivered_handoff(task_receipt, evidence)
+            and task_receipt.get("head") == snapshot.head_sha
+            and task_receipt.get("task_id") == task_id
+        )
+
+    def _should_defer_failed_task(
+        self,
+        store: InitialDeliveryClaims,
+        claim: dict | None,
+        snapshot: PRStateSnapshot,
+        key: str,
+        state: SessionState,
+    ) -> bool | None:
+        """Route unrelated failures normally and fence tasks already recorded delivered."""
+        if state.outcome is not SessionOutcome.FAILED:
+            return False
+        if claim is None:
+            return True
+        evidence = snapshot.initial_delivery
+        if (
+            not isinstance(state.task_id, str)
+            or re.fullmatch(r"[A-Za-z0-9_-]{1,200}", state.task_id) is None
+            or evidence is None
+        ):
+            return None
+        receipt_key = self._delivered_receipt_key(key, evidence)
+        delivered = store.read(snapshot.pr_number, receipt_key, "delivered")
+        if (
+            delivered is None
+            or not self._matches_delivered_handoff(delivered, evidence)
+            or delivered.get("head") != snapshot.head_sha
+        ):
+            return False
+        if state.task_id == delivered.get("task_id"):
+            return None
+        task_receipt_key = self._delivered_receipt_key(key, evidence, state.task_id)
+        task_receipt = store.read(snapshot.pr_number, task_receipt_key, "delivered")
+        if (
+            task_receipt is not None
+            and self._matches_delivered_handoff(task_receipt, evidence)
+            and task_receipt.get("head") == snapshot.head_sha
+            and task_receipt.get("task_id") == state.task_id
+        ):
+            return None
+        return True
+
+    def _handle_unknown_failed_task(
+        self,
+        store: InitialDeliveryClaims,
+        claim: dict | None,
+        snapshot: PRStateSnapshot,
+        key: str,
+        state: SessionState,
+        outcome: InitialDeliveryOutcome | None,
+    ) -> tuple[bool, ActionResult | None]:
+        defer = (
+            self._should_defer_failed_task(store, claim, snapshot, key, state)
+            if outcome is InitialDeliveryOutcome.UNKNOWN
+            else False
+        )
+        return defer is not False, self._result(
+            ActionDecision.BLOCKED, "A previously delivered task cannot re-enter recovery"
+        ) if defer is None else None
+
+    def _delivered_result(
+        self,
+        store: InitialDeliveryClaims,
+        claim: dict | None,
+        snapshot: PRStateSnapshot,
+        key: str,
+        evidence: InitialDeliveryEvidence | None,
+        state: SessionState,
+    ) -> ActionResult:
+        """Persist claimed recovery completion before returning to normal pipeline gates."""
+        if state.outcome is not SessionOutcome.FINISHED:
+            return self._result(ActionDecision.BLOCKED, "Delivery requires a completed task")
+        if claim is not None and (
+            evidence is None
+            or not isinstance(state.task_id, str)
+            or re.fullmatch(r"[A-Za-z0-9_-]{1,200}", state.task_id) is None
+            or not self._record_delivered_handoff(store, snapshot, key, evidence, state.task_id)
+        ):
+            return self._result(ActionDecision.BLOCKED, "Verified recovery handoff could not be persisted")
+        return self._result(ActionDecision.SKIP, "Fresh complete non-empty delivery returns to normal PR gates")
+
+    @staticmethod
+    def _mode(claim: dict | None, state: SessionState, evidence: InitialDeliveryEvidence) -> str:
+        if claim is None:
+            return (
+                "retry"
+                if state.outcome is SessionOutcome.FINISHED and state.task_id == evidence.initial_task_id
+                else "invalid"
+            )
+        if (
+            state.task_id == evidence.initial_task_id
+            and datetime.now(UTC) - datetime.fromisoformat(claim["created_at"]) < AGENT_RETRY_CONFIRMATION_WINDOW
+        ):
+            return "wait"
+        return "escalate"
+
+    def evaluate(self, snapshot: PRStateSnapshot, derived: DerivedState, state: SessionState) -> ActionResult | None:
+        """Fail closed without admission; preserve ordinary true-FAILED handling."""
+        try:
+            key = self._identity(snapshot.initial_delivery)
+            if not key:
+                return self._result(ActionDecision.BLOCKED, "Initial-delivery admission is malformed")
+            store = self._provider._get_initial_delivery_claims()
+            claim = store.read(snapshot.pr_number, key, "recovery")
+            evidence = snapshot.initial_delivery
+            if claim is None and state.outcome is SessionOutcome.FAILED:
+                return None
+            outcome = self._observe(snapshot, state)
+            if outcome is None or (outcome is InitialDeliveryOutcome.UNKNOWN and claim is None):
+                return self._result(ActionDecision.BLOCKED, "Initial-delivery evidence is unknown, active or stale")
+            handled, failed_task_result = self._handle_unknown_failed_task(store, claim, snapshot, key, state, outcome)
+            if handled:
+                return failed_task_result
+            if outcome is InitialDeliveryOutcome.DELIVERED:
+                return self._delivered_result(store, claim, snapshot, key, evidence, state)
+            evidence = snapshot.initial_delivery
+            assert evidence is not None
+            if claim is None and evidence.outcome is not InitialDeliveryOutcome.NO_DELIVERY:
+                return self._result(ActionDecision.BLOCKED, "Recovery requires typed NO_DELIVERY admission")
+            mode = self._mode(claim, state, evidence)
+            if mode in {"wait", "invalid"}:
+                return self._result(
+                    ActionDecision.BLOCKED, "Recovery claimed or original task identity changed; waiting"
+                )
+            derived.set("initial_delivery_mode", mode)
+            derived.set("initial_delivery_key", key)
+            derived.set("initial_delivery_session", state)
+            return self._result(ActionDecision.EXECUTE, f"Initial-delivery recovery: {mode}")
+        except Exception as exc:
+            if isinstance(exc, ProviderRateLimitError) and exc.is_rate_limit:
+                raise
+            return self._result(ActionDecision.BLOCKED, "Initial-delivery evidence or durable claims unavailable")
+
+    def execute(self, provider: CIPlatformProvider, snapshot: PRStateSnapshot, derived: DerivedState) -> ActionResult:
+        """Revalidate before each mutation; a lost response never releases a claim."""
+        try:
+            state = get_latest_session_state(
+                provider,
+                snapshot.pr_number,
+                repo=snapshot.base_repo_full_name,
+                head_branch=snapshot.head_branch,
+                pr_id=snapshot.pr_id,
+                head_sha=snapshot.head_sha,
+            )
+            outcome = self._observe(snapshot, state)
+            if (
+                state != derived.get("initial_delivery_session")
+                or outcome is None
+                or outcome is InitialDeliveryOutcome.DELIVERED
+            ):
+                return self._result(ActionDecision.BLOCKED, "Initial-delivery head, diff or lifecycle changed")
+            if derived.get("initial_delivery_mode") == "escalate":
+                return self._escalate(provider, snapshot, derived, "One-attempt recovery budget exhausted")
+            if outcome is not InitialDeliveryOutcome.NO_DELIVERY:
+                return self._result(ActionDecision.BLOCKED, "Initial-delivery classification became unknown")
+            key = derived.get("initial_delivery_key")
+            evidence = snapshot.initial_delivery
+            assert evidence is not None
+            # Build context before claiming so failures here cannot consume a dispatch.
+            derived.set("agent_retry_task_id", evidence.initial_task_id)
+            prompt = self._action._build_retry_prompt(snapshot, derived, key, 1, 1)
+            prompt = prompt.replace("agdt:agent-retry:", "agdt:initial-delivery-retry:")
+            prompt = prompt.replace(
+                f"Copilot session {key} failed.",
+                "The initial implementation completed with verified NO_DELIVERY.",
+            )
+            store = provider._get_initial_delivery_claims()
+            if not store.claim(
+                snapshot.pr_number,
+                key,
+                "recovery",
+                {
+                    "head": snapshot.head_sha,
+                    "initial_task_id": evidence.initial_task_id,
+                    "diff": "ZERO_DIFF",
+                },
+            ):
+                return self._result(ActionDecision.BLOCKED, "Another worker already consumed the recovery claim")
+            # Check again after the durable write, immediately before the non-idempotent call.
+            latest = get_latest_session_state(
+                provider,
+                snapshot.pr_number,
+                repo=snapshot.base_repo_full_name,
+                head_branch=snapshot.head_branch,
+                pr_id=snapshot.pr_id,
+                head_sha=snapshot.head_sha,
+            )
+            if latest != state or self._observe(snapshot, latest) is not InitialDeliveryOutcome.NO_DELIVERY:
+                return self._result(ActionDecision.BLOCKED, "Recovery claim retained; evidence changed before dispatch")
+            try:
+                receipt = provider._dispatch_agent_retry(snapshot.pr_number, prompt, key, initial_delivery=True)
+            except Exception as exc:
+                _raise_if_rate_limit(exc)
+                return self._escalate(
+                    provider, snapshot, derived, "Recovery dispatch failed or acceptance is uncertain"
+                )
+            if not isinstance(receipt, int) or isinstance(receipt, bool) or receipt <= 0:
+                return self._escalate(provider, snapshot, derived, "Recovery dispatch acceptance is uncertain")
+            return ActionResult(
+                name=self._action.name,
+                decision=ActionDecision.EXECUTE,
+                preconditions={"retry_dispatched": True},
+                details="Dispatched the single initial-delivery recovery",
+            )
+        except Exception as exc:
+            if isinstance(exc, ProviderRateLimitError) and exc.is_rate_limit:
+                raise
+            return self._result(
+                ActionDecision.FAILED, "Recovery stopped; durable claim/evidence unavailable, no resend"
+            )
+
+    def validate_escalation(self, snapshot: PRStateSnapshot, derived: DerivedState) -> None:
+        """Refuse initial-delivery notifications or exclusion after a lifecycle change."""
+        if not self._escalation_is_safe(snapshot, derived):
+            raise RuntimeError("Recovery lifecycle or delivery changed; escalation stopped without exclusion")
+
+    def _escalation_is_safe(self, snapshot: PRStateSnapshot, derived: DerivedState) -> bool:
+        """Return whether the current delivery and task lifecycle still allow escalation."""
+        if not derived.get("initial_delivery_mode"):
+            return True
+        state = get_latest_session_state(
+            self._provider,
+            snapshot.pr_number,
+            repo=snapshot.base_repo_full_name,
+            head_branch=snapshot.head_branch,
+            pr_id=snapshot.pr_id,
+            head_sha=snapshot.head_sha,
+        )
+        outcome = self._observe(snapshot, state)
+        return outcome is not None and outcome is not InitialDeliveryOutcome.DELIVERED
+
+    def _escalate(
+        self, provider: CIPlatformProvider, snapshot: PRStateSnapshot, derived: DerivedState, reason: str
+    ) -> ActionResult:
+        """Serialize notification attempts too; retain ambiguous notices for manual inspection."""
+        evidence = snapshot.initial_delivery
+        assert evidence is not None
+        state = get_latest_session_state(
+            provider,
+            snapshot.pr_number,
+            repo=snapshot.base_repo_full_name,
+            head_branch=snapshot.head_branch,
+            pr_id=snapshot.pr_id,
+            head_sha=snapshot.head_sha,
+        )
+        outcome = self._observe(snapshot, state)
+        if outcome is None or outcome is InitialDeliveryOutcome.DELIVERED:
+            return self._result(ActionDecision.BLOCKED, "Recovery may be active; retain claim without escalation")
+        key = derived.get("initial_delivery_key")
+        comments = provider.list_issue_comments(snapshot.pr_number)
+        login = provider.get_dispatch_login()
+        if not isinstance(login, str) or not login:
+            return self._result(ActionDecision.FAILED, "Escalation identity unavailable; recovery claim retained")
+        diagnostics = evidence.push_diagnostics[:2000] if isinstance(evidence.push_diagnostics, str) else ""
+        diagnostics = re.sub(r"@copilot", "Copilot", diagnostics, flags=re.IGNORECASE)
+        diff = "ZERO_DIFF" if outcome is InitialDeliveryOutcome.NO_DELIVERY else "UNKNOWN"
+        body = (
+            f"{reason}. Original task: `{evidence.initial_task_id}`. "
+            f"Observed head: `{snapshot.head_sha}`; diff: `{diff}`; "
+            "initial-delivery recovery budget: one (consumed). "
+            f"Push cause: {'available evidence below' if diagnostics else 'unknown'}.\n\n"
+            f"{diagnostics}\n\n"
+            "Inspect the original task and any local unpushed work, then recover manually. "
+            "Removing `ai-pr-loop:agent-failed` does not reset this durable recovery budget."
+        )
+        # A prior generic failure notice does not contain this delivery's head/diff evidence.
+        comments = [comment for comment in comments if key in self._action._escalation_identities([comment], login)]
+        derived.set("agent_retry_comments", comments)
+        derived.set("agent_retry_dispatch_login", login)
+        derived.set(
+            "initial_delivery_escalation_body",
+            f"<!-- agdt:agent-retry-escalation:{key} -->\n\n{body}",
+        )
+        if not comments:
+            if not self._escalation_is_safe(snapshot, derived):
+                return self._result(ActionDecision.BLOCKED, "Recovery may be active; do not reserve escalation")
+            claims = provider._get_initial_delivery_claims()
+            owner_token = uuid4().hex
+            if not claims._reserve_escalation(
+                snapshot.pr_number,
+                key,
+                {"head": snapshot.head_sha, "diff": diff, "notice": body},
+                owner_token,
+            ):
+                return self._result(
+                    ActionDecision.FAILED,
+                    "Escalation already attempted; inspect durable escalation evidence, no resend",
+                )
+            if not self._escalation_is_safe(snapshot, derived):
+                if claims._transition_escalation(snapshot.pr_number, key, owner_token, "reserved", "retryable"):
+                    return self._result(
+                        ActionDecision.BLOCKED,
+                        "Recovery became active before notice send; reservation released for safe retry",
+                    )
+                return self._result(
+                    ActionDecision.FAILED,
+                    "Pre-send abort could not verify escalation reservation ownership; no notice sent",
+                )
+            if not claims._transition_escalation(snapshot.pr_number, key, owner_token, "reserved", "attempted"):
+                return self._result(
+                    ActionDecision.FAILED,
+                    "Escalation send attempt could not be durably fenced; no notice sent",
+                )
+        return self._action._escalate(provider, snapshot, derived, key)

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

@@ -21,6 +21,7 @@ from agentic_devtools.cli.ci.guards import (
     is_agent_retry_confirmation_expired,
 )
 from agentic_devtools.cli.ci.models import IssueCommentInfo
+from agentic_devtools.cli.ci.pipeline.actions.initial_delivery_recovery import InitialDeliveryRecovery
 from agentic_devtools.cli.ci.pipeline.models import ActionDecision, ActionResult
 from agentic_devtools.cli.ci.pipeline.session_detector import (
     SessionOutcome,
@@ -95,27 +96,9 @@ class RetryFailedSessionAction:
                     ),
                 )
         derived.set("latest_session_state", state)
-        if state.outcome is SessionOutcome.UNKNOWN:
-            return ActionResult(
-                name=self.name,
-                decision=ActionDecision.BLOCKED,
-                preconditions={"session_outcome_known": False},
-                details="Latest Copilot session outcome is unknown",
-            )
-        if state.outcome is SessionOutcome.ACTIVE:
-            return ActionResult(
-                name=self.name,
-                decision=ActionDecision.BLOCKED,
-                preconditions={"session_active": True},
-                details="Active Copilot session blocks retry and subsequent pipeline actions",
-            )
-        if state.outcome is not SessionOutcome.FAILED:
-            return ActionResult(
-                name=self.name,
-                decision=ActionDecision.SKIP,
-                preconditions={"session_failed": False},
-                details=f"Latest Copilot session outcome is {state.outcome.value}",
-            )
+        result = InitialDeliveryRecovery(self).evaluate_session(snapshot, derived, state)
+        if result is not None:
+            return result
 
         failure_id = self._failure_identity(state)
         if not failure_id:
@@ -317,6 +300,8 @@ class RetryFailedSessionAction:
         derived: DerivedState,
     ) -> ActionResult:
         """Dispatch one retry or publish an idempotent escalation notice."""
+        if derived.get("initial_delivery_mode"):
+            return InitialDeliveryRecovery(self).execute(provider, snapshot, derived)
         mode = derived.get("agent_retry_mode", "")
         failure_id = derived.get("agent_retry_failure_id", "")
         if mode not in {"retry", "escalate"} or not isinstance(failure_id, str) or not failure_id:
@@ -458,13 +443,8 @@ class RetryFailedSessionAction:
     ) -> ActionResult:
         """Post one human-readable escalation comment, then add the failure label.
 
-        The comment is posted before the label so a partial failure never
-        leaves the PR excluded (label present) without the human-readable
-        explanation that justifies the exclusion. If ``add_label`` fails after
-        the comment succeeds, the PR stays schedulable and the next run only
-        needs to retry the (idempotent) label write; the inverse ordering
-        would instead let the scheduler drop the PR before the comment ever
-        exists (see ``scheduler.py``'s ``AGENT_FAILED_LABEL`` exclusion).
+        Comment-first ordering prevents scheduler exclusion without an explanation.
+        A failed label write leaves the PR schedulable for an idempotent label retry.
         """
         comments = derived.get("agent_retry_comments", [])
         dispatch_login = derived.get("agent_retry_dispatch_login", "")
@@ -513,6 +493,7 @@ class RetryFailedSessionAction:
                     f"This PR is excluded from the AI PR Loop. To resume, remove the `{AGENT_FAILED_LABEL}` label "
                     "and retry the task manually."
                 )
+            body = derived.get("initial_delivery_escalation_body", body)
             try:
                 provider.post_comment_as_pr_token(snapshot.pr_number, body)
             except Exception as exc:
@@ -522,6 +503,7 @@ class RetryFailedSessionAction:
                 failures.append(f"failed to post escalation: {exc}")
         if not failures:
             try:
+                InitialDeliveryRecovery(self).validate_escalation(snapshot, derived)
                 provider.add_label(snapshot.pr_number, AGENT_FAILED_LABEL)
             except Exception as exc:
                 if isinstance(exc, ProviderRateLimitError) and exc.is_rate_limit:

agentic_devtools/cli/ci/pipeline/delivery.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from dataclasses import dataclass
 from enum import StrEnum
 
 from agentic_devtools.cli.ci.provider import CIPlatformProvider
@@ -27,6 +28,23 @@ class InitialDeliveryOutcome(StrEnum):
     UNKNOWN = "UNKNOWN"
 
 
+@dataclass(frozen=True)
+class InitialDeliveryEvidence:
+    """Admission handoff from the initial-delivery observer, not from PR prose.
+
+    The caller retains the original task and authoritative plan SHA across recovery
+    runs, and supplies the classifier's typed outcome for the observed head.
+    Missing admission remains ``None``; this contract does not normalize terminal
+    signals or discover an initial-plan identity.
+    """
+
+    outcome: InitialDeliveryOutcome
+    initial_task_id: str
+    initial_plan_sha: str
+    head_sha: str
+    push_diagnostics: str = ""
+
+
 def _read_pr_identity(provider: CIPlatformProvider, pr_number: int) -> tuple[str, str, str, int] | None:
     """Read PR base/head identity and the API-reported changed-file count."""
     metadata = provider.get_pr_metadata(pr_number)

agentic_devtools/cli/ci/pipeline/snapshot_models.py

@@ -8,6 +8,7 @@ from typing import Any
 from agentic_devtools.cli.ci.approver_preflight import ApproverPreflightResult
 from agentic_devtools.cli.ci.models import CheckRunStatus, ReviewInfo
 from agentic_devtools.cli.ci.pipeline.critique_snapshot import CritiqueSnapshotFields
+from agentic_devtools.cli.ci.pipeline.delivery import InitialDeliveryEvidence
 from agentic_devtools.cli.ci.pipeline.gate_verdict import CopilotGateVerdict
 
 
@@ -18,6 +19,7 @@ class PRStateSnapshot(CritiqueSnapshotFields):
     Attributes:
         pr_number: The pull request number.
         pr_id: The pull request database ID when the provider exposes one.
+        initial_delivery: Optional typed admission retaining the original task/plan identity.
         head_sha: Current HEAD commit SHA.
         base_branch: Target branch name.
         base_sha: Target branch commit SHA captured with the snapshot.
@@ -133,6 +135,7 @@ class PRStateSnapshot(CritiqueSnapshotFields):
     pr_number: int = 0
     approver_preflight: ApproverPreflightResult | None = field(default=None, kw_only=True)
     pr_id: int | None = field(default=None, kw_only=True)
+    initial_delivery: InitialDeliveryEvidence | None = field(default=None, kw_only=True)
     head_sha: str = ""
     base_branch: str = ""
     base_sha: str = ""

agentic_devtools/cli/ci/provider_events.py

@@ -122,3 +122,7 @@ class _ProviderEventsMixin(ABC):
     def dispatch_agent_retry(self, pr_number: int, prompt: str, failure_event_id: str) -> int:
         """Dispatch one failed-session retry through a provider-specific mechanism."""
         raise NotImplementedError(f"{type(self).__name__} does not implement dispatch_agent_retry")
+
+    def _dispatch_agent_retry(self, pr_number: int, prompt: str, key: str, *, initial_delivery: bool = False) -> int:
+        """Internal retry-comment route for separately fenced initial delivery."""
+        raise NotImplementedError(f"{type(self).__name__} does not implement initial-delivery dispatch")

agentic_devtools/cli/ci/provider_pr_lifecycle.py

@@ -3,13 +3,21 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
 from agentic_devtools.cli.ci.models import ClosingIssue
 
+if TYPE_CHECKING:
+    from agentic_devtools.cli.ci.initial_delivery_claims import InitialDeliveryClaims
+
 
 class _ProviderPrLifecycleMixin(ABC):
     """Pull-request lifecycle and file/check capabilities."""
 
+    def _get_initial_delivery_claims(self) -> InitialDeliveryClaims:
+        """Return durable, cross-worker claims when supported; never a local lock."""
+        raise NotImplementedError("Provider does not support durable initial-delivery claims")
+
     @abstractmethod
     def approve_pr(self, pr_number: int, head_sha: str, body: str) -> bool:
         """Approve a pull request.

{agentic_devtools-0.2.595.dist-info → agentic_devtools-0.2.596.dist-info}/METADATA

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

{agentic_devtools-0.2.595.dist-info → agentic_devtools-0.2.596.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentic_devtools/__init__.py,sha256=gvLzsZ6L3Abr4sPHr4OJ_rdZDD8cFzXacaV0LGs8dVc,539
-agentic_devtools/_version.py,sha256=yu1a204qVZRleC_5c0LoHgt2mwgkkFjwyJGisw2mRkk,524
+agentic_devtools/_version.py,sha256=AvrHmM1z84QxURku5GjpXs4ePlchTMmZCz-bqWtaQkM,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
@@ -250,8 +250,9 @@ 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=xRnK2apdAt09qfdPTLguDGSJ1l8OVlxh-SPegpSGTFo,502091
+agentic_devtools/cli/ci/github_provider.py,sha256=S64RFoqRdWejDzGPC5BouCUiP43fR3UnnM2_VIl9yZo,502743
 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
 agentic_devtools/cli/ci/logging_config.py,sha256=1Ak6hPfqa6BhxhQ96FmpoqqeYk-aJLEdz0ekpb_gEdU,2328
 agentic_devtools/cli/ci/models.py,sha256=H5crqYDQyuH1uou7Jjoshzf-PAd4rBOWeivTwhPt10I,21823
@@ -261,10 +262,10 @@ agentic_devtools/cli/ci/provider_audit_dispatch.py,sha256=rGc1aIvAdNSaHzLcBYgmZ_
 agentic_devtools/cli/ci/provider_comments.py,sha256=f9y14qF-ePV1x-vqOgV9vskscdBSbaYDOYp1QRttfXA,4503
 agentic_devtools/cli/ci/provider_deferrals.py,sha256=kuujg2XjIlh66HVjn53j6H4HEJ7zElkppAizJivSCGA,4101
 agentic_devtools/cli/ci/provider_diff.py,sha256=2_Rx-A2k5rN8gRAE2wI67AtUq2Q4tTXVrA0BYmBKJDM,4208
-agentic_devtools/cli/ci/provider_events.py,sha256=-iIE8imxDU-WcyrfosV2_SKP747pOA19nzBzE0n9VLA,4010
+agentic_devtools/cli/ci/provider_events.py,sha256=ZkeVawg_od36NwOlVyFeW_HmOsA4tVhNEzhT1hE-PJk,4317
 agentic_devtools/cli/ci/provider_issue_inventory.py,sha256=-1Zjaf0c58DdQ9QlivJXc2-b1b4xJ5qW06UpanY1Mhc,6021
 agentic_devtools/cli/ci/provider_issue_mutations.py,sha256=_pAM0Ld7sqGNK3OhwKk-xkNqi_OUPUodWRatty5QZQo,2111
-agentic_devtools/cli/ci/provider_pr_lifecycle.py,sha256=rdO2y-OnaBTLMLBIIqbOSmrfxkGsJvLRfOk42TYGra0,3340
+agentic_devtools/cli/ci/provider_pr_lifecycle.py,sha256=kWPEtyfcZ9UT7xCvfUmMzSSA4uUvmAq6juGsYVLgV4s,3729
 agentic_devtools/cli/ci/provider_repair_dispatch.py,sha256=fPg2dUN97K1UKqs4Qo2uA8owC19C0IxmHNuKYi7KVDw,3746
 agentic_devtools/cli/ci/provider_repository.py,sha256=0FqIbTExEFN5Xrj7eq9p6OmUke2xD9MhrjqRVXFBqhE,3094
 agentic_devtools/cli/ci/provider_reviews.py,sha256=z63kEFkBXs8kUJW-OE8tzYtEmUEtRIZPzmvFWh-KQKs,6673
@@ -312,7 +313,7 @@ agentic_devtools/cli/ci/pipeline/conflict_reconciliation.py,sha256=H_O67JPHeqByO
 agentic_devtools/cli/ci/pipeline/critique_gate.py,sha256=OGaaTy_21pbPBvJSNyjTXvxWTAWYLbCSmrKARc4JYaw,3763
 agentic_devtools/cli/ci/pipeline/critique_snapshot.py,sha256=_lJyfCLqeEw9WDMV7qQsYZljgfdDhalhoGtG9Lw0Hvo,9203
 agentic_devtools/cli/ci/pipeline/deferral.py,sha256=M0WSLAJol9xLe1RuWNKiuRAw3EqU8VULDJqUSwM0HCw,19426
-agentic_devtools/cli/ci/pipeline/delivery.py,sha256=zUg3AlVd8KmKgdWHYi4_e1oKbstmVTBRdQpRHBJDaws,6388
+agentic_devtools/cli/ci/pipeline/delivery.py,sha256=2CRoAQtnNJuI6T8B9pxK3CENM222LF9UbYUbfTJIsn8,6998
 agentic_devtools/cli/ci/pipeline/delivery_bridge.py,sha256=p_cO6s9lvS60iua1dO-3ttpU6D_DNbYvyelVxW2VnlQ,2694
 agentic_devtools/cli/ci/pipeline/diff_validation.py,sha256=LRf-FB2sIap6kLCcqZIw3LFXhRFgRqYIaHtCY7hPtwQ,2678
 agentic_devtools/cli/ci/pipeline/exceptions.py,sha256=4UXy2weeQZex_lp4sILNxlYfGjetxbR-tjms2ReT4iw,451
@@ -326,7 +327,7 @@ agentic_devtools/cli/ci/pipeline/runner_diff_parser.py,sha256=T3ofZoUxKGZaGSyx5d
 agentic_devtools/cli/ci/pipeline/session_detector.py,sha256=FdwjFZG0LZ7TDmcO9Fwjr9xPbcDqnAxKho7SCSTDo50,66251
 agentic_devtools/cli/ci/pipeline/snapshot_builder.py,sha256=WxMSAsfK1h1StwkWAOVHgaorvBpKyjeCAcD1ekGHt8g,20116
 agentic_devtools/cli/ci/pipeline/snapshot_ci.py,sha256=nvtqRVSEnjWUSCXLEUVa9-JBmMXV08cOLEczogorNTc,4531
-agentic_devtools/cli/ci/pipeline/snapshot_models.py,sha256=NP02aqTG8L1N3v0Wa8DSeaiYGcNHwXaJQBqpwnxCY7E,12349
+agentic_devtools/cli/ci/pipeline/snapshot_models.py,sha256=htimdF2kUdcnNzIlhbZ_6bT-dzo72bVeMqgxnr0dX0c,12610
 agentic_devtools/cli/ci/pipeline/snapshot_review_comments.py,sha256=GuPKNBJ1g8-nrEcL7QRbMx-lUKwqrBfJlzb2q0z5UeA,7172
 agentic_devtools/cli/ci/pipeline/snapshot_reviews.py,sha256=wQtzxgw3-0s4m_5flqYYXTu45jLhTRaCkmdclSlPu-c,2837
 agentic_devtools/cli/ci/pipeline/snapshot_thread_count.py,sha256=QpNI383E3wJyb3jBOkcgvhpxY7cgn9yjyi1DZTlAZBA,7633
@@ -346,12 +347,13 @@ agentic_devtools/cli/ci/pipeline/actions/defer_suppressed.py,sha256=98ixxe4ml2pC
 agentic_devtools/cli/ci/pipeline/actions/dispatch_conflict_resolution.py,sha256=gPnQpukH1_oLYIybLnmeEaZofHLdsugDF9VBk6yAJKU,14731
 agentic_devtools/cli/ci/pipeline/actions/dispatch_repair.py,sha256=g-xkmCh6rUCPdUuUAjb7MISTCc0dgJUB3M-7N6fdo_w,39760
 agentic_devtools/cli/ci/pipeline/actions/guards.py,sha256=922i276VJhRU3sZpq9tYqRAjLr7sXVIPRkD17l0jfNg,5842
+agentic_devtools/cli/ci/pipeline/actions/initial_delivery_recovery.py,sha256=7KRTobupqdfXYPDzXiLRgbTKzu1K8XO09vjeu7yoCMA,24138
 agentic_devtools/cli/ci/pipeline/actions/merge.py,sha256=mWbmDxZmlrq8wAQl_oMR70LsdFUc5vU8rt_ZQ-QEXmk,20936
 agentic_devtools/cli/ci/pipeline/actions/publish.py,sha256=w3rqB1OXGR_SeeRqWUGNCaxZb4-oljptMgzw374KEz4,10806
 agentic_devtools/cli/ci/pipeline/actions/rebase.py,sha256=CwNk6tZlkaTG6-jm1lRPGsyLyo3sdjwQZy6kMjIc55k,5883
 agentic_devtools/cli/ci/pipeline/actions/request_review.py,sha256=uvlr4Vm9KRWIKGHtBF9i9gPsDAZLskn3bLiXuxxdlmI,11759
 agentic_devtools/cli/ci/pipeline/actions/resolve_threads.py,sha256=SvlAFVF5kL6unYPvxYhvF_zas85LBysOWgGR52kFCdE,12719
-agentic_devtools/cli/ci/pipeline/actions/retry_failed_session.py,sha256=BBEMmOwHeteUabAN6WfDCdHRE9N4xlXkiVsWbgm6fHA,25615
+agentic_devtools/cli/ci/pipeline/actions/retry_failed_session.py,sha256=vAiLRKt_PtqgUE5u1AP-3U-siARrIdWHbjh3YAtV3-I,24836
 agentic_devtools/cli/ci/pipeline/actions/squash.py,sha256=efdxkjwvJFvmYu9w1M0lnMEGiokSpUD4CQnCaDj0dKs,11643
 agentic_devtools/cli/ci/pipeline/actions/takeover.py,sha256=-QMvoJTvGsu2DDQFUkVUwZcbK34A7HIvgh0hdFrnFr4,8030
 agentic_devtools/cli/ci/pipeline/discovery/__init__.py,sha256=QNdOYvl_wK6qcWOvNJR-wm8EtWD_DPn4barKF5RSmfU,752
@@ -1243,10 +1245,10 @@ agentic_devtools/_bundled_skills/skills/agdt-analyze-workflow/SKILL.md,sha256=JV
 agentic_devtools/_bundled_skills/skills/agdt-analyze-workflow/lifecycle.md,sha256=DmYCXNaf8W0hq5dgKyowvdZ5brkTofDVTgXmLBnbYCw,12416
 agentic_devtools/_bundled_skills/skills/agdt-analyze-workflow/workflow-analysis.md,sha256=ZssIwWCMsmgHYRFNv_NG088YovFvXcms1RUktaSGyaI,21997
 agentic_devtools/_bundled_skills/skills/agdt-apply-pr-suggestions-initiate/SKILL.md,sha256=sMIEi3Pjse5hDpk5O2D8bXKqjuWNw7L28XlNhFaToSA,797
-agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/SKILL.md,sha256=KA4gaBg3XQa3tL8koSa3v-65M7m4WpbG713ioqMB3q4,29297
+agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/SKILL.md,sha256=0JqrZAzZ-3Rf_FO-GDGIBUg1mg0qr5UwkURhxU9jcbU,35149
 agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/command-reference.md,sha256=TOIWIRyaldLNyyPipEN8pkH4wNHGYnw4ay3m9MAf1_8,4186
 agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/execution-procedures.md,sha256=1GmQpgsdwDI0vf6-sNXyLgZVV5W1u_fkf44ZX9XLu4I,8394
-agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/specification-templates.md,sha256=FORZ1fCmseI5SOrYf57T11yBZBroO5KAw77oTxYicxw,4499
+agentic_devtools/_bundled_skills/skills/agdt-autonomous-issue-refinement/specification-templates.md,sha256=gvHy2JHmd_2tDTQfcIh2mqc4OIymRjltilW0MiupkAo,7130
 agentic_devtools/_bundled_skills/skills/agdt-break-down-issue-into-subtasks-initiate/SKILL.md,sha256=i68KWw4c6wLrGzSFsbc1ynR4yvx9g46z5qsqsgwXLlk,2073
 agentic_devtools/_bundled_skills/skills/agdt-create-issues-from-analysis/SKILL.md,sha256=S_838usj0oWllUhoL5sKMmU8IcQc1HKsoNX4dhr0mac,11937
 agentic_devtools/_bundled_skills/skills/agdt-create-issues-from-analysis/analysis-output-contract.md,sha256=bX2UmlQohmgyrLqQ7IFTmTEobaHJ-pWzvwqIROYYvRA,821
@@ -1303,8 +1305,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.595.dist-info/METADATA,sha256=wc355Gd-s_CeC7R7O0PmHZ4_-5sYEmFEW282w1RBPwY,35589
-agentic_devtools-0.2.595.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-agentic_devtools-0.2.595.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
-agentic_devtools-0.2.595.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
-agentic_devtools-0.2.595.dist-info/RECORD,,
+agentic_devtools-0.2.596.dist-info/METADATA,sha256=LpdqiT1tbaT8eB4vtvWOdBDdCX5ZY7TdRs7odTvahHs,35589
+agentic_devtools-0.2.596.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+agentic_devtools-0.2.596.dist-info/entry_points.txt,sha256=kL35_Y5OHI6XpPneeBTcX82ORjjfx2VIK6XfmKHgNm4,13630
+agentic_devtools-0.2.596.dist-info/licenses/LICENSE,sha256=yBEDdICksxhBYLWoERKp9MTqwGnUF6Ryj9BTLwXTc6k,1082
+agentic_devtools-0.2.596.dist-info/RECORD,,