alissa-tools-github-devloop 0.8.18__tar.gz → 0.8.19__tar.gz

{alissa_tools_github_devloop-0.8.18/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.18
+Version: 0.8.19
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_devloop-0.8.18 → alissa_tools_github_devloop-0.8.19}/src/main/alissa/tools/github/devloop/loop.py

@@ -27,11 +27,15 @@ and the merge, a finished session's PR sits open for the whole review loop.
 DEAD alone would therefore fire on the modal happy path. So the resume takes
 a FOURTH signal from the PR the session left behind: the handoff publishes
 itself (`gh pr ready` flips the draft off, then the re-request puts a
-reviewer on it), which makes a PR that is STILL A DRAFT with NO reviewer
-requested the one state that says "this session never handed off". That test
-also keeps the edges disjoint -- the moment a PR leaves draft it belongs to
-the review lifecycle and the fix edge owns it exclusively, so no `develop-*`
-resume can land on a branch a `fix-*` session is already working.
+reviewer on it), which makes a PR that is STILL A DRAFT the one state that
+says "this session never handed off" -- whatever reviewer is on it, because
+a review request on a draft publishes nothing (the reviewer daemon only
+reviews non-draft PRs and the fix edge refuses drafts, so nothing downstream
+can ever move a draft; studio.alissa.app#1204 sat 80 minutes behind exactly
+that shape). That test also keeps the edges disjoint -- the moment a PR
+leaves draft it belongs to the review lifecycle and the fix edge owns it
+exclusively, so no `develop-*` resume can land on a branch a `fix-*` session
+is already working.
 
 The signals so far all describe the PR's STATE, and a sibling task's young
 draft satisfies every one of them; a cross-reference is raised by ANY mention
@@ -91,8 +95,8 @@ above takes over as attempt k+1, counting toward attempt_cap like any
 resume. Nothing about the kill is new machinery on the resume side: it
 manufactures the one signal the matrix already acts on. The invariants are
 the matrix's own -- never on INDETERMINATE (absence of evidence keeps the
-defer), never on a PR that left draft or has a reviewer engaged (the wedge
-sits strictly behind `_resumable_pr`), never with `resume_enabled` false (a
+defer), never on a PR that left draft (the wedge sits strictly behind
+`_resumable_pr`), never with `resume_enabled` false (a
 kill whose resume cannot fire would only orphan the lane), and never a
 roster sweep.
 
@@ -173,7 +177,9 @@ self-heal needs an unanswered review, and the issue-edge resume keys off an
 OPEN labeled issue, which a draft replayed after its issue merged does not
 have (fahera-mx/studio.alissa.app#279, 2026-07-28: an operator found it by
 accident). So the PR search is widened to drafts and every draft is asked the
-handoff question instead of being skipped: self-authored, no reviewer on it,
+handoff question instead of being skipped: self-authored (a reviewer already
+requested on it is NOT a reason to skip -- a request on a draft arms nothing,
+so the sweep readies it and requests only the reviewers still missing),
 a daemon-shaped head ref naming an implementation task (a `TASK-<n>-<DESC>`
 branch or a task ref in the body -- the provenance test, `closes_issue`'s
 role here), no live worker session for the PR (the SAME liveness rule --
@@ -741,8 +747,9 @@ RESUME_DIRECTIVE = (
     "previous developer session on GitHub issue {issue_url} died AFTER "
     "opening its pull request but BEFORE handing it off for review — the "
     "daemon confirmed its session `{dead_session}` is gone from the machine, "
-    "and its DRAFT pull request {pr_url} is still open with no reviewer on "
-    "it. This is attempt {attempt} of {cap}, and your job is to FINISH THAT "
+    "and its DRAFT pull request {pr_url} is still open (a reviewer may "
+    "already be requested on it — that is not a handoff; the ready flip is). "
+    "This is attempt {attempt} of {cap}, and your job is to FINISH THAT "
     "PULL REQUEST, not to start the work over. "
     "{task_instruction} "
     "FIRST hydrate the context you did not live through: read the issue (its "
@@ -2629,11 +2636,16 @@ class DevWatcher:
         # the session behind the open PR is not running -- but NOT that it was
         # abandoned, because a healthy handoff ends in `alissa tmux kill`. So
         # DEAD only opens the question, and `_resumable_pr` answers it: a
-        # still-draft, no-reviewer PR that CLOSES this issue is one of this
+        # still-draft PR that CLOSES this issue (a reviewer on the draft
+        # changes nothing -- a draft is never handed off) is one of this
         # issue's own sessions that was never handed off, and it
         # is the one case the deferral was always wrong about -- resumed as
         # attempt k+1 with RESUME_DIRECTIVE instead of parking the lane behind
-        # an operator ping. Everything else -- ALIVE, INDETERMINATE, and DEAD
+        # an operator ping. (When the orphan sweep is on it runs EARLIER in
+        # the same pass and readies such a draft mechanically, so the fetch
+        # here sees a non-draft PR and defers -- the sweep's handoff wins
+        # over a resume without any coordination between the edges.)
+        # Everything else -- ALIVE, INDETERMINATE, and DEAD
         # behind a PR already in the review lifecycle -- keeps the floored
         # defer: past STALLED_DEFER_MULTIPLE stale windows it posts a
         # "stalled" operator comment (this deferral sits above the cap check,
@@ -2708,9 +2720,9 @@ class DevWatcher:
                     # an operator reading the log must not have to guess.
                     why = (
                         "no linked PR is resumable (a handed-off PR — out of "
-                        "draft, or with a reviewer engaged — belongs to the "
-                        "review lifecycle, not to a resume; and a PR that "
-                        "only MENTIONS this issue is another task's work)"
+                        "draft — belongs to the review lifecycle, not to a "
+                        "resume; a PR that only MENTIONS this issue is "
+                        "another task's work)"
                         if liveness is Liveness.DEAD
                         and self.config.resume_enabled
                         else "work may be alive (the review loop can outlast "
@@ -3080,12 +3092,23 @@ class DevWatcher:
 
         What separates the two is the PR the session left behind, because the
         handoff PUBLISHES itself: `gh pr ready` flips the draft off, then the
-        re-request puts a reviewer on it. So a PR that is STILL A DRAFT with
-        NO reviewer requested is one its session never handed off -- the only
-        state a resume is owed. (A session that died in the narrow window
-        between the ready flip and the re-request reads handed-off and keeps
-        the legacy floored defer: conservative on purpose, since that is also
-        exactly what a live review loop looks like from here.)
+        re-request puts a reviewer on it. So a PR that is STILL A DRAFT is one
+        its session never handed off -- the only state a resume is owed --
+        and a reviewer requested on that draft does not change the reading: a
+        request on a draft arms nothing (the reviewer daemon reviews only
+        non-draft PRs, the fix edge refuses drafts), so no automation
+        downstream can ever move it. The two half-states a session can die in
+        are therefore read differently: (a) READY + NO reviewer -- the ready
+        flip landed, the request did not -- reads handed-off here and keeps
+        the legacy floored defer, conservative on purpose since that is also
+        exactly what a live review loop looks like from this edge; where this
+        daemon's own sweep made that flip, the `orphan-ready@<head>` row lets
+        the PR edge's `_finish_orphan_handoff` complete it. (b) DRAFT +
+        reviewer -- the request landed, the flip did not (studio#1204: 80
+        minutes behind a draft with `alissa-app` on it) -- is resumable when
+        the session is DEAD, exactly like a review-less draft, and deferred
+        while ALIVE; with the orphan sweep on, that sweep readies it earlier
+        in the same pass, so the resume yields to the mechanical handoff.
 
         That same test settles the cross-edge race: the moment a PR leaves
         draft it belongs to the review lifecycle, and the fix edge -- which
@@ -3162,16 +3185,24 @@ class DevWatcher:
             # still a PR whose base can strand it, and the guard's own author
             # test is what keeps it off PRs that are not ours.
             self._check_stacked_base(pr)
-            if not pr.draft or pr.requested_reviewers:
+            if not pr.draft:
                 log.info(
-                    "%s: %s has been handed off (draft=%s, reviewers=%s) — "
-                    "not a resume candidate; the review lifecycle owns it",
+                    "%s: %s has been handed off (out of draft, reviewers=%s) "
+                    "— not a resume candidate; the review lifecycle owns it",
                     issue.issue_slug,
                     url,
-                    pr.draft,
                     ", ".join(pr.requested_reviewers) or "none",
                 )
                 continue
+            if pr.requested_reviewers:
+                log.info(
+                    "%s: %s is still a DRAFT with %s requested — a review "
+                    "request on a draft is not a handoff (the ready flip is), "
+                    "so this PR is a resume candidate",
+                    issue.issue_slug,
+                    url,
+                    ", ".join(pr.requested_reviewers),
+                )
             if pr.author != self.github.login:
                 log.warning(
                     "%s: %s is authored by %r, not the developer identity — "
@@ -3258,12 +3289,13 @@ class DevWatcher:
 
         Two gates, in order. First `_resumable_pr`, verbatim -- the wedge
         path inherits every admission test the resume has (still a draft,
-        no reviewer, self-authored, daemon-shaped head, a body that CLOSES
-        this issue, exactly one candidate), because the kill it licenses is
+        self-authored, daemon-shaped head, a body that CLOSES this issue,
+        exactly one candidate; a reviewer requested on the draft is not a
+        handoff and does not exclude it), because the kill it licenses is
         only safe where the resume that follows it is: a PR that has left
-        draft or has a reviewer engaged belongs to the review lifecycle,
-        and a live review loop behind an ALIVE session is the healthy shape
-        this daemon was built around. Then the footprint (`_footprint_age`):
+        draft belongs to the review lifecycle, and a live review loop behind
+        an ALIVE session is the healthy shape this daemon was built around.
+        Then the footprint (`_footprint_age`):
         None means unreadable, and unreadable keeps the defer -- the same
         fail-safe every other presumed-dead decision here makes.
 
@@ -4459,17 +4491,18 @@ class DevWatcher:
                 f"identity — not this daemon's to hand off",
             )
 
-        # A draft already carrying a review request is not unhanded-off: a
-        # session (or a human) put a reviewer on it deliberately and simply has
-        # not flipped it ready. Nothing here is owed, and readying it would
-        # take that decision away from whoever made it.
-        if pr.requested_reviewers:
-            return Decision(
-                Action.SKIPPED,
-                f"draft already carries a review request "
-                f"({', '.join(pr.requested_reviewers)}) — its handoff is "
-                f"someone's deliberate work in progress, not an orphan",
-            )
+        # A draft already carrying a review request is NOT excluded (issue
+        # #113). The sweep used to read a reviewer on a draft as someone's
+        # deliberate work in progress, but a request on a draft arms nothing
+        # -- the reviewer daemon reviews only non-draft PRs and the fix edge
+        # refuses drafts -- and the issue edge read the same shape as "handed
+        # off", so a session that died between its `--add-reviewer` and its
+        # `gh pr ready` (studio.alissa.app#1204: 80 minutes of silence after
+        # a 10-hour attempt) left a draft NO edge would ever move. The
+        # liveness gate below is what protects a deliberately-parked draft:
+        # a live session behind it is never swept, and for a DEAD one the
+        # sweep does the FIRST half only -- the ready flip -- and requests
+        # just the configured reviewers that are not already on the PR.
 
         # head_ref reaches nothing but log lines here (the sweep spawns no
         # session, so it never becomes a worktree path or a shell token), but
@@ -4804,36 +4837,64 @@ class DevWatcher:
           not retried on this head (escalate-don't-retry, `_escalate_rejection`
           verbatim).
 
+        A draft that ALREADY carries a review request (issue #113) takes the
+        same walk minus the request: the session died between its
+        `--add-reviewer` and its `gh pr ready`, so the flip is the only act
+        still owed. `request_reviews` is skipped entirely when every
+        configured reviewer is already on the PR -- re-requesting an
+        already-requested reviewer is a no-op on GitHub, but it must not be
+        recorded as a fresh request -- and requests only the missing ones
+        otherwise. Both ledger rows still land, so the once-per-(PR, head)
+        guarantee and `_owes_orphan_handoff` keep holding on this shape.
+
         The activity line comes LAST and stays best-effort: it is telemetry
         about acts that have already happened, and it is written as a NON-SPAWN
         context because no session exists for it to claim a lane on behalf of.
         """
-        reviewers = self.config.reviewers
-        log.warning(
-            "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, no "
-            "reviewer is requested, and no worker session for this PR is "
-            "listed — the session that opened it died before handing it off; "
-            "marking it ready and requesting %s mechanically (once per "
-            "PR/head)",
-            pr.pr_slug,
-            task_ref,
-            pr.head_sha[:8],
-            waited / 60,
-            ", ".join(reviewers),
-        )
+        already, missing = self._orphan_reviewers_split(pr)
+        if already:
+            log.warning(
+                "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, %s "
+                "already requested on it, and no worker session for this PR "
+                "is listed — the session that opened it died after its "
+                "review request but before flipping it ready (a request on a "
+                "draft arms nothing); marking it ready mechanically%s (once "
+                "per PR/head)",
+                pr.pr_slug,
+                task_ref,
+                pr.head_sha[:8],
+                waited / 60,
+                ", ".join(already),
+                f" and requesting {', '.join(missing)}" if missing else "",
+            )
+        else:
+            log.warning(
+                "ORPHAN DRAFT %s (%s): head %s has been public %.0f min, no "
+                "reviewer is requested, and no worker session for this PR is "
+                "listed — the session that opened it died before handing it "
+                "off; marking it ready and requesting %s mechanically (once "
+                "per PR/head)",
+                pr.pr_slug,
+                task_ref,
+                pr.head_sha[:8],
+                waited / 60,
+                ", ".join(missing),
+            )
 
         if self.config.dry_run:
+            request = (
+                f"request {', '.join(missing)}"
+                if missing
+                else f"request nobody ({', '.join(already)} already requested)"
+            )
             log.info(
-                "[dry-run] would mark %s ready and request review from %s",
-                pr.pr_slug,
-                ", ".join(reviewers),
+                "[dry-run] would mark %s ready and %s", pr.pr_slug, request
             )
             return Decision(
                 Action.IN_FLIGHT,
                 f"[dry-run] would mechanically hand off draft head "
                 f"{pr.head_sha[:8]} (public {int(waited / 60)} min, its "
-                f"session gone): mark ready + request "
-                f"{', '.join(reviewers)}",
+                f"session gone): mark ready + {request}",
                 task_ref=task_ref,
             )
 
@@ -4863,6 +4924,28 @@ class DevWatcher:
 
         return self._request_orphan_reviewers(pr, task_ref, waited)
 
+    def _orphan_reviewers_split(
+        self, pr: PullRequest
+    ) -> "tuple[tuple[str, ...], tuple[str, ...]]":
+        """The configured reviewers, split by what the PR already carries:
+        (already requested, still missing), each in config order.
+
+        Casefolded like `_reviewer_reviews`: the configured set is
+        operator-typed and GitHub logins are case-insensitive, so `Alissa-App`
+        in the config and `alissa-app` on the PR are one reviewer, not a
+        missing one. Stated once because the sweep and the completion path
+        both need exactly this answer -- the request must never name a
+        reviewer who is already on the PR (a no-op on GitHub that would still
+        be recorded, and logged, as a fresh request)."""
+        on_pr = {r.casefold() for r in pr.requested_reviewers}
+        already = tuple(
+            r for r in self.config.reviewers if r.casefold() in on_pr
+        )
+        missing = tuple(
+            r for r in self.config.reviewers if r.casefold() not in on_pr
+        )
+        return already, missing
+
     def _owes_orphan_handoff(self, pr: PullRequest) -> bool:
         """Did THIS daemon ready this exact head and still owe it a reviewer?
 
@@ -4904,6 +4987,14 @@ class DevWatcher:
         entitled to finish its own handoff). Not re-run is the grace window --
         it was satisfied when the flip fired, and the head has not moved since
         (a moved head would be a different key with no ready row at all).
+
+        Reached only for a PR with NO pending request (evaluate_pr's own
+        guard sits above this). So a draft that already carried a reviewer
+        can never arrive here: it left draft carrying that reviewer, and the
+        pending-request guard reads it as in review. That is why
+        `_request_orphan_reviewers` never leaves that shape half-recorded --
+        a failed request for the MISSING reviewers there is given up on and
+        the handoff completed on the spot (round-1 review fix, PR #114).
         """
         if not self._owes_orphan_handoff(pr) or not self.config.reviewers:
             return None
@@ -4952,43 +5043,73 @@ class DevWatcher:
         this is the completion path (where that number is a poll or more old
         and would be reported as fact).
 
-        Failure handling mirrors `_rerequest_review`'s exactly: a
-        ReviewRequestRejected is permanent and operator-fixable (escalate,
-        don't retry, and never record the DONE marker); a CommandError is
-        transient (record nothing, retry next poll). The READY row stays in
-        both cases -- the flip really did happen, and re-flipping an
-        already-ready PR is not what the retry needs to do."""
-        reviewers = self.config.reviewers
-        try:
-            landed = self.github.request_reviews(
-                pr.owner, pr.repo, pr.number, reviewers
-            )
-        except ReviewRequestRejected as exc:
-            return self._escalate_orphan_rejected(pr, task_ref, exc)
-        except CommandError as exc:
-            log.error(
-                "could not request review from %s on %s: %s — NOT recording "
-                "the handoff; the sweep retries next poll",
-                ", ".join(reviewers),
-                pr.pr_slug,
-                exc,
-            )
-            return Decision(
-                Action.SKIPPED,
-                f"the PR was marked ready but the review request did not land "
-                f"({exc}) — transient; not recorded, retrying next poll",
-                task_ref=task_ref,
-            )
+        Only the configured reviewers NOT already on the PR are requested
+        (`_orphan_reviewers_split`, issue #113). When every one of them is
+        already requested -- the draft the session put a reviewer on before
+        dying, or a completion-path PR someone requested by hand between
+        polls -- no call is made at all: the DONE marker lands, the activity
+        line says who was already there, and the reviewer daemon already sees
+        the PR.
+
+        Failure handling on the review-less shape mirrors
+        `_rerequest_review`'s exactly: a ReviewRequestRejected is permanent
+        and operator-fixable (escalate, don't retry, and never record the
+        DONE marker); a CommandError is transient (record nothing, retry next
+        poll). The READY row stays in both cases -- the flip really did
+        happen, and re-flipping an already-ready PR is not what the retry
+        needs to do.
+
+        On the PARTIAL shape -- some configured reviewers already on the PR,
+        the call carrying only the missing rest -- neither doctrine applies
+        (round-1 review fix, PR #114). `request_reviews` raises only when
+        nothing in THAT call landed, which here does not mean nobody is on
+        the PR: the flip landed and `already` is requested, so the PR is in
+        review and the reviewer daemon sees it. The refusal page would be
+        false ("never marked ready or sent to a reviewer"), and a retry is
+        structurally impossible: next poll the pending-request guard in
+        evaluate_pr reads the PR as in review before `_finish_orphan_handoff`
+        is reached, so a ready row left down would stick on that head
+        forever. So a failed request for the missing subset, permanent or
+        transient, is logged as given up on -- naming who IS on the PR --
+        and the handoff is completed: DONE row, activity line."""
+        already, missing = self._orphan_reviewers_split(pr)
+        landed: tuple[str, ...] = ()
+        if missing:
+            try:
+                landed = self.github.request_reviews(
+                    pr.owner, pr.repo, pr.number, missing
+                )
+            except ReviewRequestRejected as exc:
+                if not already:
+                    return self._escalate_orphan_rejected(pr, task_ref, exc)
+                self._log_orphan_reviewers_given_up(pr, missing, already, exc)
+            except CommandError as exc:
+                if not already:
+                    log.error(
+                        "could not request review from %s on %s: %s — NOT "
+                        "recording the handoff; the sweep retries next poll",
+                        ", ".join(missing),
+                        pr.pr_slug,
+                        exc,
+                    )
+                    return Decision(
+                        Action.SKIPPED,
+                        f"the PR was marked ready but the review request "
+                        f"did not land ({exc}) — transient; not recorded, "
+                        f"retrying next poll",
+                        task_ref=task_ref,
+                    )
+                self._log_orphan_reviewers_given_up(pr, missing, already, exc)
 
-        dropped = tuple(r for r in reviewers if r not in landed)
-        if dropped:
-            log.warning(
-                "%s: GitHub silently dropped reviewer(s) %s from the "
-                "mechanical handoff; %s landed, so the PR IS in review",
-                pr.pr_slug,
-                ", ".join(dropped),
-                ", ".join(landed),
-            )
+            dropped = tuple(r for r in missing if r not in landed)
+            if dropped and landed:
+                log.warning(
+                    "%s: GitHub silently dropped reviewer(s) %s from the "
+                    "mechanical handoff; %s landed, so the PR IS in review",
+                    pr.pr_slug,
+                    ", ".join(dropped),
+                    ", ".join(landed + already),
+                )
 
         self.state.record_escalation(
             pr.full_name, pr.number, orphan_kind(pr.head_sha)
@@ -4998,6 +5119,23 @@ class DevWatcher:
             if waited is not None
             else ""
         )
+        if landed and already:
+            acted = (
+                f"marked ready and requested review from {', '.join(landed)} "
+                f"({', '.join(already)} already requested)"
+            )
+            died = "before handing it off"
+        elif landed:
+            acted = f"marked ready and requested review from {', '.join(landed)}"
+            died = "before handing it off"
+        else:
+            noun = "reviewer" if len(already) == 1 else "reviewers"
+            verb = "was" if len(already) == 1 else "were"
+            acted = (
+                f"marked ready ({noun} {', '.join(already)} {verb} already "
+                f"requested)"
+            )
+            died = "before flipping it"
         self._append_activity(
             pr.owner,
             pr.repo,
@@ -5005,22 +5143,51 @@ class DevWatcher:
             self._activity_line(
                 orphan_activity_lane(pr),
                 "orphan sweep",
-                f"{ACTIVITY_HANDED_OFF} — marked ready and requested review "
-                f"from {', '.join(landed)}; the session that opened this draft "
-                f"died before handing it off{age}, so the daemon completed its "
-                f"protocol (no session spawned, once per PR/head)",
+                f"{ACTIVITY_HANDED_OFF} — {acted}; the session that opened "
+                f"this draft died {died}, so the daemon completed its "
+                f"protocol{age} (no session spawned, once per PR/head)",
             ),
             pr.pr_slug,
         )
 
+        if landed:
+            requested = f"and review requested from {', '.join(landed)}"
+        else:
+            requested = (
+                f"(review already requested from {', '.join(already)}, no "
+                f"new request made)"
+            )
         return Decision(
             Action.IN_FLIGHT,
-            f"orphaned draft handed off — marked ready and review requested "
-            f"from {', '.join(landed)} for head {pr.head_sha[:8]}; the ball is "
-            f"in the reviewer's court",
+            f"orphaned draft handed off — marked ready {requested} for head "
+            f"{pr.head_sha[:8]}; the ball is in the reviewer's court",
             task_ref=task_ref,
         )
 
+    @staticmethod
+    def _log_orphan_reviewers_given_up(
+        pr: PullRequest,
+        missing: "tuple[str, ...]",
+        already: "tuple[str, ...]",
+        exc: Exception,
+    ) -> None:
+        """The partial shape's one failure path (see
+        `_request_orphan_reviewers`): the request for the configured
+        reviewers NOT yet on the PR failed, `already` IS on it, and no retry
+        can ever reach this PR again -- so the missing reviewers are given up
+        on, out loud, and the handoff completes with who is there."""
+        log.warning(
+            "%s: could not request review from %s on the mechanical handoff "
+            "(%s) — giving up on them: %s already requested and the PR is out "
+            "of draft, so it IS in review; the daemon will not retry (the "
+            "pending request reads as in review from here on), request them "
+            "by hand if wanted",
+            pr.pr_slug,
+            ", ".join(missing),
+            exc,
+            ", ".join(already),
+        )
+
     def _escalate_orphan_rejected(
         self, pr: PullRequest, task_ref: "str | None", exc: Exception
     ) -> Decision:

alissa_tools_github_devloop-0.8.19/src/main/alissa/tools/github/devloop/version

@@ -0,0 +1 @@
+0.8.19

{alissa_tools_github_devloop-0.8.18 → alissa_tools_github_devloop-0.8.19/src/main/alissa_tools_github_devloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.18
+Version: 0.8.19
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_devloop-0.8.18/src/main/alissa/tools/github/devloop/version

@@ -1 +0,0 @@
-0.8.18