alissa-tools-github-devloop 0.8.44__py3-none-any.whl → 0.8.46__py3-none-any.whl

alissa/tools/github/devloop/loop.py

@@ -1964,6 +1964,16 @@ def write_discovery_marker(session: str, plans_repo: str, number: int, discovery
 # `escalation.first-run-dialog`, anchored on the issue.
 ESCALATION_FIRST_RUN_DIALOG = "first-run-dialog"
 
+# The claude-exited wedge (issue #169): a session the roster lists ALIVE
+# whose pane is back at its login shell -- `claude` exited, the tmux session
+# stayed. WEDGE_CLAUDE_EXITED is the classification the loop logs and puts
+# on the activity line; ESCALATION_CLAUDE_EXITED is its once-per-episode
+# marker (see claude_exited_kind), an ACT like ESCALATION_FIRST_RUN_DIALOG:
+# it dedupes the WARNING and the activity line, and the loop-events emitter
+# turns it into `escalation.claude_exited`, anchored on the issue.
+WEDGE_CLAUDE_EXITED = "wedged:claude-exited"
+ESCALATION_CLAUDE_EXITED = "claude-exited"
+
 # The maintenance edge's cap-out kind prefix. The `maintain-` prefix keeps
 # rows from ever colliding with the issue edge's `cap` when an issue and a
 # PR share a number; the epoch suffix is maintain_cap_kind's job below.
@@ -2353,6 +2363,15 @@ def first_run_dialog_kind(attempt: int) -> str:
     return f"{ESCALATION_FIRST_RUN_DIALOG}:a{attempt}"
 
 
+def claude_exited_kind(attempt: int) -> str:
+    """The ledger kind for ONE claude-exited wedge episode (issue #169).
+
+    first_run_dialog_kind's episode reasoning: every attempt's claude can
+    exit, and attempt k's row must not silence attempt k+1's WARNING.
+    """
+    return f"{ESCALATION_CLAUDE_EXITED}:a{attempt}"
+
+
 def deferral_activity_kind(session: str) -> str:
     """The activity-log kind that dedupes ONE capacity-deferral episode's line.
 
@@ -4016,7 +4035,10 @@ class DevWatcher:
         # terminal one.
         resume_pr: "PullRequest | None" = None
         dead_session: "str | None" = None
-        wedged_dialog = False
+        # A wedge kill that clears the lane THIS pass (the first-run dialog,
+        # a claude that exited) logged its own WARNING: the re-enqueue's
+        # "absent from the tmux listing" line below would misstate it.
+        wedge_killed = False
         if age is not None:
             # `exhaustive` only when a resume could actually fire: the probe's
             # default early break answers the boolean the deferral needs, but
@@ -4043,7 +4065,25 @@ class DevWatcher:
                     issue.full_name, number
                 )
                 liveness = self.session_liveness(row_session, roster)
-                if self.config.resume_enabled and liveness is Liveness.DEAD:
+                if liveness is Liveness.ALIVE and row_session:
+                    killed, exited_resume = self._claude_exited(
+                        issue, attempts, row_session, linked
+                    )
+                    if killed:
+                        # Issue #169: listed, but its claude is gone -- the
+                        # kill landed, so the lane is DEAD from here on, and
+                        # the `_resumable_pr` answer the kill's outcome line
+                        # was written from is the one this pass acts on: a
+                        # still-draft PR is resumed below, anything else
+                        # keeps the (now dead) defer.
+                        wedge_killed = True
+                        liveness = Liveness.DEAD
+                        resume_pr = exited_resume
+                if (
+                    self.config.resume_enabled
+                    and liveness is Liveness.DEAD
+                    and not wedge_killed
+                ):
                     resume_pr = self._resumable_pr(issue, linked)
                 elif (
                     self.config.resume_enabled
@@ -4165,7 +4205,19 @@ class DevWatcher:
                 # successful listing without this name) -- so the retry below
                 # can name the session it proved gone instead of presuming.
                 dead_session = live_session
-                if liveness is Liveness.ALIVE:
+                if (
+                    liveness is Liveness.ALIVE
+                    and self._claude_exited(
+                        issue, attempts, live_session, None
+                    )[0]
+                ):
+                    # Issue #169: ALIVE is a tmux session, not a claude. The
+                    # pane is back at its login shell, the kill landed: fall
+                    # through to the cap check and the re-enqueue below as
+                    # the CONFIRMED-dead path would.
+                    wedge_killed = True
+                    liveness = Liveness.DEAD
+                elif liveness is Liveness.ALIVE:
                     # Issue #123: ALIVE is a process, not a worker. A session
                     # sitting on Claude Code's first-run "trust this folder?"
                     # (or bypass-permissions) gate is listed, idle, and will
@@ -4177,7 +4229,7 @@ class DevWatcher:
                     if self._wedged_on_first_run_dialog(
                         issue, attempts, live_session
                     ):
-                        wedged_dialog = True
+                        wedge_killed = True
                         # The kill landed and the hub is seeded: fall through
                         # to the cap check and the re-enqueue below as the
                         # CONFIRMED-dead path would -- one WARNING for the
@@ -4270,7 +4322,7 @@ class DevWatcher:
                 attempts,
             )
 
-        if age is not None and resume_pr is not None:
+        if age is not None and resume_pr is not None and not wedge_killed:
             log.warning(
                 "%s attempt %d has been in flight %.0f min behind its still-"
                 "draft open PR %s and its session %s is absent from the tmux "
@@ -4283,7 +4335,7 @@ class DevWatcher:
                 dead_session,
                 attempts + 1,
             )
-        elif age is not None and not wedged_dialog:
+        elif age is not None and not wedge_killed:
             log.warning(
                 "%s attempt %d has been in flight %.0f min with no completion "
                 "and no linked open PR, and its session %s is absent from the "
@@ -5083,6 +5135,157 @@ class DevWatcher:
             return None
         return min(youngest, max(0.0, now - committed))
 
+    def _claude_exited(
+        self,
+        issue: Issue,
+        attempts: int,
+        session: str,
+        linked: "list[str] | None",
+    ) -> "tuple[bool, PullRequest | None]":
+        """Issue #169: is this stale, ALIVE session's `claude` gone -- and
+        if so, clear the lane.
+
+        ALIVE means the roster LISTS the session; it says nothing about the
+        process the session was spawned for. A claude that exits (a crash,
+        a `/exit`, a kill from inside) leaves the tmux session open with its
+        pane back at the login shell, and the session read alive for as long
+        as anyone cared to look -- 2026-10-13, four worker sessions for
+        1.5-2 h, behind the "work may be alive" and "may still be running"
+        defers, until an operator killed them by hand. The probe is the one
+        `display-message` `_first_turn_death` already uses: a pane whose
+        `#{pane_current_command}` is one of `SHELL_COMMANDS` has no claude
+        (nor the `alissa code` wrapper) in the foreground. A pane that
+        reads anything else -- `node`, the wrapper -- is a live worker and
+        keeps every defer exactly as before; "" (tmux could not answer) is
+        absence of evidence, never a dead claude, and keeps them too. A
+        usage-limited session is never killed (issue #144).
+
+        A match is `wedged:claude-exited`: ONE WARNING per episode (keyed
+        claude_exited_kind(attempts); a failed kill retried next poll logs
+        at INFO), then the row's own session is killed (`alissa tmux kill
+        <name>`, the path every wedge kill takes, never a sweep), one
+        activity-comment line records the act, and a True first element
+        tells the caller to treat the session as CONFIRMED dead NOW. The
+        pre-PR branch (`linked` None) re-enqueues attempt k+1. The linked-PR
+        branch passes its open PRs, and `_resumable_pr` is asked HERE,
+        before a word is logged, because only its answer says what the lane
+        does next: a still-draft PR is resumed as attempt k+1 (the PR is the
+        second element, which the caller acts on rather than asking again),
+        while a handed-off PR, several candidates or `resume_enabled: false`
+        leave the lane deferring, now read dead -- and the WARNING and the
+        activity line say THAT, never a resume the lane will not get. A
+        re-enqueue or a resume counts toward attempt_cap, and on the
+        terminal attempt the caller's cap check pages the operator instead,
+        which the lines say rather than promising a retry (a deferring lane
+        never reaches that check, so it is never told it caps out).
+        Dry-run classifies and logs but kills nothing and answers False
+        (the defer holds); so does a kill that fails, retried next poll.
+
+        Not done here: the process groups the session's claude started
+        that outlived it (a test run re-parented to init). Nothing on the
+        daemon's side ties such a group to a session once its parent is
+        gone, so they are left to the operator (see the README)."""
+        command = self.alissa.pane_command(session)
+        if command not in SHELL_COMMANDS:
+            return False, None
+        if self.state.session_limited(session):
+            return False, None
+        kind = claude_exited_kind(attempts)
+        resume_pr = (
+            self._resumable_pr(issue, linked)
+            if linked is not None and self.config.resume_enabled
+            else None
+        )
+        deferring = linked is not None and resume_pr is None
+        capping = not deferring and attempts >= self.config.attempt_cap
+        if deferring:
+            outcome = (
+                "leaving the lane to the review lifecycle: no linked PR is "
+                "resumable (a handed-off PR is not resumed), so it keeps its "
+                "defer, now reading dead"
+            )
+            activity_outcome = (
+                "no linked PR is resumable, so the lane waits on the review "
+                "lifecycle"
+            )
+        elif capping:
+            outcome = (
+                f"NOT re-enqueuing: attempt {attempts} was the last "
+                f"(attempt_cap {self.config.attempt_cap}), so the lane caps "
+                f"out and pages the operator"
+            )
+            activity_outcome = (
+                f"attempt_cap {self.config.attempt_cap} reached — the lane "
+                f"caps out and pages the operator instead of re-enqueuing"
+            )
+        elif resume_pr is not None:
+            outcome = (
+                f"resuming its still-draft PR {resume_pr.url} as attempt "
+                f"{attempts + 1} (counting toward attempt_cap "
+                f"{self.config.attempt_cap})"
+            )
+            activity_outcome = (
+                f"its still-draft PR is resumed as attempt {attempts + 1}"
+            )
+        else:
+            outcome = (
+                f"re-enqueuing as attempt {attempts + 1} (counting toward "
+                f"attempt_cap {self.config.attempt_cap})"
+            )
+            activity_outcome = f"re-enqueued as attempt {attempts + 1}"
+        if self.state.escalated(issue.full_name, issue.number, kind):
+            log.info(
+                "%s: session %s (%s attempt %d) still has no claude in its "
+                "pane — retrying the kill",
+                WEDGE_CLAUDE_EXITED, session, issue.issue_slug, attempts,
+            )
+        else:
+            log.warning(
+                "%s: session %s (%s attempt %d) reads alive but its pane is "
+                "back at the shell (%s) — its claude exited and nothing will "
+                "ever be published. Killing it and %s",
+                WEDGE_CLAUDE_EXITED, session, issue.issue_slug, attempts,
+                command, outcome,
+            )
+            self.state.record_escalation(issue.full_name, issue.number, kind)
+        if self.config.dry_run:
+            log.info(
+                "[dry-run] would kill %s (claude exited) and %s",
+                session,
+                "keep the defer" if deferring
+                else f"cap out (attempt_cap {self.config.attempt_cap})"
+                if capping
+                else f"resume attempt {attempts + 1}" if resume_pr is not None
+                else f"re-enqueue attempt {attempts + 1}",
+            )
+            return False, None
+        try:
+            self.alissa.kill_session(session)
+        except CommandError as exc:
+            log.warning(
+                "%s: could not kill %s (%s) — kills are best-effort; the lane "
+                "keeps its defer and the kill is retried next poll",
+                WEDGE_CLAUDE_EXITED, session, exc,
+            )
+            return False, None
+        if not self.state.activity_logged(issue.full_name, issue.number, kind):
+            landed = self._append_activity(
+                issue.owner,
+                issue.repo,
+                issue.number,
+                self._activity_line(
+                    session,
+                    "issue edge",
+                    f"{ACTIVITY_WEDGE_KILLED} — {WEDGE_CLAUDE_EXITED}: the "
+                    f"session read alive but its pane was back at the shell "
+                    f"(claude exited); killed, {activity_outcome}",
+                ),
+                issue.issue_slug,
+            )
+            if landed:
+                self.state.record_activity(issue.full_name, issue.number, kind)
+        return True, resume_pr
+
     def _wedged_on_first_run_dialog(
         self, issue: Issue, attempts: int, session: str
     ) -> bool:

alissa/tools/github/devloop/loop_events.py

@@ -187,6 +187,7 @@ _LIMIT_LIFTED_RE = re.compile(r"^usage-limit-lifted:(?P<session>[^@]+)@(?P<since
 # points the operator at an unrelated PR or at nothing.
 _ISSUE_ANCHORED = (
     "cap", "assignment", "stalled", "live-stalled", "wedged", "first-run-dialog",
+    "claude-exited",
 )
 
 

alissa/tools/github/devloop/parking.py

@@ -25,7 +25,7 @@ serves it on ``GET /api/state`` and runs the drain handshake):
   null as a refusal.
 * **The drain.** A flag with a TTL in `state.db` (`State.set_drain`), cleared
   when the daemon boots. While it holds, every spawn path stands down before
-  its first side effect (`DevWatcher._drain_gate`).
+  its first side effect (`DevWatcher._drain_gated`).
 """
 
 from __future__ import annotations

alissa/tools/github/devloop/version

@@ -1 +1 @@
-0.8.44
+0.8.46

alissa/tools/github/devloop/webui/server.py

@@ -234,7 +234,16 @@ class App:
         down and the answer is `drained: false` with the reasons. When the
         drain holds, a vitals snapshot carrying `idle.drainedAt` is pushed
         BEFORE the answer, because that snapshot is what Studio re-checks
-        before it removes anything; the answer says how the push went."""
+        before it removes anything; the answer says how the push went.
+
+        A refused drain lowers the flag, not just its own raise: the clear is
+        unscoped (`State.clear_drain`). A refused RE-drain therefore also
+        lowers an earlier drain that held and had answered `drained: true`,
+        and so does a second, overlapping `/action/drain` that is refused.
+        That is intended (seat-parking §2.4: when the block breaks D2 "the
+        seat clears the flag itself and answers `drained: false`"): a seat
+        that is no longer idle must not stay drained, whoever raised the
+        flag."""
         if ttl_s is None:
             ttl = parking.DRAIN_TTL_DEFAULT
         elif (
@@ -265,7 +274,7 @@ class App:
         except sqlite3.Error as exc:
             self._audit("drain", {"ok": False, "error": str(exc)})
             return 503, {"drained": False, "error": "state_unavailable"}
-        listing = self.sources._safe_json(["alissa", "tmux", "ls", "--json"])
+        listing = self.sources.listing()
         idle = self.sources.idle(listing=listing)
         refusals = parking.idle_refusals(
             idle, poll_interval=self.sources.config.poll_interval, now=now,
@@ -305,13 +314,18 @@ class App:
     def undrain(self) -> "tuple[int, dict]":
         """`POST /action/undrain`: lower the drain flag -- orcloop's step 4
         on any failure of a park. Idempotent: undraining a seat that is not
-        drained answers `cleared: false`. (status, payload), audited."""
+        drained answers `cleared: false`. (status, payload), audited.
+
+        A ledger that cannot be written answers 503 with `drained: null`:
+        nobody knows then whether the flag is up (there may be no drain at
+        all), and unknown is never a value (design D2). The 503 already says
+        the undrain did not land; the TTL still bounds any flag left up."""
         try:
             with State(self.sources.config.state_db) as st:
                 cleared = st.clear_drain()
         except sqlite3.Error as exc:
             self._audit("undrain", {"ok": False, "error": str(exc)})
-            return 503, {"drained": True, "error": "state_unavailable"}
+            return 503, {"drained": None, "error": "state_unavailable"}
         self._audit("undrain", {"ok": True, "cleared": cleared})
         return 200, {"drained": False, "cleared": cleared}
 

alissa/tools/github/devloop/webui/sources.py

@@ -384,6 +384,15 @@ class Sources:
         except ValueError:
             return None
 
+    def listing(self) -> "object":
+        """The parsed ``alissa tmux ls --json`` listing, or None when it could
+        not be read (the command failed, printed nothing, or printed something
+        that is not JSON). The console's one reader of the tmux roster: the
+        sessions panel, the idle block, the dashboard and the drain handshake
+        all read it here. The value is whatever the CLI printed -- callers
+        check it is a list before trusting its shape."""
+        return self._safe_json(["alissa", "tmux", "ls", "--json"])
+
     def sessions(self, listing: "list[dict] | None" = None) -> "list[dict]":
         """The managed sessions with their edge, age and `/proc` footprint.
 
@@ -393,9 +402,7 @@ class Sources:
         console (no listing) lists for itself. Either way the rows go
         through the same shaping, so the two never disagree about what a
         session record looks like."""
-        raw = listing if listing is not None else (
-            self._safe_json(["alissa", "tmux", "ls", "--json"]) or []
-        )
+        raw = listing if listing is not None else (self.listing() or [])
         if not isinstance(raw, list):
             return []
         now = int(self._wall())
@@ -463,7 +470,7 @@ class Sources:
             snaps = self.snapshots(1)
             latest = snaps[0] if snaps else None
         if listing is _UNREAD:
-            listing = self._safe_json(["alissa", "tmux", "ls", "--json"])
+            listing = self.listing()
         roster = listing if isinstance(listing, list) else None
         snapshot = latest if isinstance(latest, dict) else None
         queues = self._safe_json(["alissa", "tmux", "queue", "ls", "--json"])
@@ -678,7 +685,7 @@ class Sources:
         latest = snaps[0] if snaps else None
         ledgers = self.ledgers()
         # One listing feeds both the sessions panel and the idle block.
-        listing = self._safe_json(["alissa", "tmux", "ls", "--json"])
+        listing = self.listing()
         sessions = self.sessions(
             listing=listing if isinstance(listing, list) else []
         )

{alissa_tools_github_devloop-0.8.44.dist-info → alissa_tools_github_devloop-0.8.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.44
+Version: 0.8.46
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera
@@ -220,6 +220,32 @@ kills or reaps one. The fleet-vitals push applies the same rule to
 `sessions.managed` and `idle.managed` (Studio's park guard reads both) and
 leaves `gone` out, since Studio's idle schema is strict.
 
+## Wedges: alive is not working
+
+A stale issue-edge session the tmux roster lists ALIVE is not trusted on
+that alone. The daemon kills the row's own session (`alissa tmux kill
+<name>`, never a sweep) and moves the lane on when the session is wedged:
+
+- **`wedged:claude-exited`** (issue #169) — the pane's
+  `#{pane_current_command}` is a login shell (`alissa.SHELL_COMMANDS`): the
+  `claude` the session was spawned for exited and the tmux session stayed.
+  Checked on both stale branches (with and without a linked open PR), no
+  `wedge_minutes` needed; the session reads DEAD in the same pass, so the
+  pre-PR lane re-enqueues attempt k+1 and a draft-PR lane resumes its PR as
+  attempt k+1, counting toward `attempt_cap`. Ledger kind
+  `claude-exited:a<k>`.
+- **`wedged:first-run-dialog`** (issue #123) — the pane sits on Claude
+  Code's trust / bypass-permissions gate: killed, hub pre-trusted,
+  re-enqueued in the same pass.
+- **footprint wedges** (issues #110, #127; opt-in `wedge_minutes`) — no
+  activity footprint inside the window: killed, and the next pass resumes
+  or retries.
+
+A pane tmux cannot read keeps the defer, a usage-limited session is never
+killed (issue #144), and dry-run only logs. The root README's *Claude
+exited, the session stayed* section has the details. Processes a dead claude started that
+outlived it (re-parented to init) are not reaped — a known follow-up.
+
 ## License
 
 Licensed under the

{alissa_tools_github_devloop-0.8.44.dist-info → alissa_tools_github_devloop-0.8.46.dist-info}/RECORD

@@ -8,25 +8,25 @@ alissa/tools/github/devloop/fleet_vitals.py,sha256=5mWnRkJh8u9soSplud3UMxkelT6Eq
 alissa/tools/github/devloop/ghclient.py,sha256=tYUHwmoy9CBBt-jSOz9nuAl8lpMvm1LH4A-wHx25bss,71842
 alissa/tools/github/devloop/hubs.py,sha256=yjnsnSHLG7GNNP8X2hILeAMV6P5n4JGc_IaAxpSP_YQ,18974
 alissa/tools/github/devloop/janitor.py,sha256=R8REoHBeY2cfW7fYJVhKr-F5z9Mjlc-vmv-z4KtvBZc,27360
-alissa/tools/github/devloop/loop.py,sha256=uMfuomSdIPC8KkWUGF0OrW3RR9OSC1txKVnXGZ1SeIc,613973
-alissa/tools/github/devloop/loop_events.py,sha256=tmso0OALqY2yAPW2Fo6ae0sYetQIdIeIYooJ2Sc2cc4,37921
-alissa/tools/github/devloop/parking.py,sha256=vEf-qprN14-I4vu4M53tIFaA3827FiHLpKetBAgN4LQ,12409
+alissa/tools/github/devloop/loop.py,sha256=I5rZy082JqplmFm1t2XgYkstc7IdkJJdX-FXAfwqcKk,624114
+alissa/tools/github/devloop/loop_events.py,sha256=pKtBl1HK8gYPB2gKiI29xUkx-JuW2A48KwRlbdcf_lo,37942
+alissa/tools/github/devloop/parking.py,sha256=7h3Gg2XQ0eqlvn0M6K6NeEg9xbqnlUPrZNs9gRofzxc,12410
 alissa/tools/github/devloop/proc.py,sha256=nzfsxJSHFWRQcrXmfv588KazFysv8dVQrhMPH1q5eRk,3134
 alissa/tools/github/devloop/prompts.py,sha256=VzN6ec5eF2wwg7QSCRg52WLcxo-tGbGRgQbc4HSahUc,55169
 alissa/tools/github/devloop/state.py,sha256=uVwhbkogUTjWXXFq-COKzUeYrpuGbHzi05CjfEzAtPA,88668
-alissa/tools/github/devloop/version,sha256=va232A0BU1OdMrEBtZ5PyqpxusfsBdgt4whBySGjLHY,7
+alissa/tools/github/devloop/version,sha256=YpzpT7756Lld10FKXeESQnDWJA9HvJScK9ngOSfSk8s,7
 alissa/tools/github/devloop/version.py,sha256=znuuOaitXGrBpbskNy78_rlVpFdtmKmk_3k1ACxZrl0,1418
 alissa/tools/github/devloop/webui/__init__.py,sha256=vdXYoyGYzD7BrJ5lV6XdH8Bpw_pej8-RK0hjfxop7-8,1513
 alissa/tools/github/devloop/webui/__main__.py,sha256=wORyW5AkgsniK0TZcrOrvm_P7Q4Mr-fH-4S6qj9XcgA,6137
 alissa/tools/github/devloop/webui/auth.py,sha256=g9YEDao9nKt-cBEENp7vFqwJ-T8olN6uLiCzVIN8yhA,7890
 alissa/tools/github/devloop/webui/page.py,sha256=4OD3e01ByvVM4Wo04AZyFuyOYTFEMT2lagktZAvyCKk,30862
-alissa/tools/github/devloop/webui/server.py,sha256=YuUmcng5qdWqSurcuyxH3FKKkBBfrpDtvtZLidJOGiU,26226
-alissa/tools/github/devloop/webui/sources.py,sha256=JJXJEkLKh2qRbpTaIyQwCTu90DuKq_Z3nz6DwLhzlr4,38900
+alissa/tools/github/devloop/webui/server.py,sha256=3aGYGesjUSrPrgcpfy-oYDefBNKnAj3lGfRzwsRkv_I,27031
+alissa/tools/github/devloop/webui/sources.py,sha256=Uw_2B5QGSmW6f66WfVbQb6yLLYmSv6uuF7HNJ5OSr_I,39314
 alissa/tools/github/devloop/webui/sysinfo.py,sha256=ptlogH9alFv0vZ-pQfyUaA3w-K7LQS3tQHGv0d8Tdlk,9649
-alissa_tools_github_devloop-0.8.44.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-alissa_tools_github_devloop-0.8.44.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
-alissa_tools_github_devloop-0.8.44.dist-info/METADATA,sha256=s-GkeBOMMoSQatUPgO0Hg_HgIyoe5TlcNi-8D-NwSYQ,12222
-alissa_tools_github_devloop-0.8.44.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-alissa_tools_github_devloop-0.8.44.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
-alissa_tools_github_devloop-0.8.44.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
-alissa_tools_github_devloop-0.8.44.dist-info/RECORD,,
+alissa_tools_github_devloop-0.8.46.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+alissa_tools_github_devloop-0.8.46.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
+alissa_tools_github_devloop-0.8.46.dist-info/METADATA,sha256=0V0tseoJcEXAfIvuBYJmDowXYvWG0FaMgnUNbASbxVE,13628
+alissa_tools_github_devloop-0.8.46.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+alissa_tools_github_devloop-0.8.46.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
+alissa_tools_github_devloop-0.8.46.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
+alissa_tools_github_devloop-0.8.46.dist-info/RECORD,,