alissa-tools-github-devloop 0.8.39__py3-none-any.whl → 0.8.41__py3-none-any.whl

alissa/tools/github/devloop/config.py

@@ -284,6 +284,8 @@ CONFIG_KEYS = (
     "attempt_cap",
     "stale_minutes",
     "max_sessions",
+    "spawn_headroom_threads",
+    "spawn_headroom_memory_pct",
     "reap_grace_minutes",
     "foreign_session_policy",
     "foreign_session_allow_prefixes",
@@ -535,6 +537,19 @@ class Config:
     # listing, so enabling it costs no extra GitHub or CLI calls.
     max_sessions: int = 0
 
+    # Headroom-aware admission (issue #162): a session count does not bound
+    # what the sessions RUN -- an idle claude holds ~16 threads, a test suite
+    # or a Chromium screenshot 100-200+ -- and the container's cgroup v2
+    # `pids.max` counts THREADS. When `pids.max - pids.current` falls under
+    # `spawn_headroom_threads`, or the free share of `memory.max` under
+    # `spawn_headroom_memory_pct`, a pass spawns nothing new: every spawn
+    # (resumes and fix rounds included) defers on the capacity valve and is
+    # re-decided next poll. 0 turns either guard off; an unlimited (`max`) or
+    # unreadable cgroup file turns its guard off too. The 2026-10-13 outage
+    # (a `gh` fork failing EAGAIN at ~1000 threads) set the defaults.
+    spawn_headroom_threads: int = 300
+    spawn_headroom_memory_pct: int = 15
+
     # The reaper's grace: how long a worker session must have been QUIET (no
     # tmux activity) before a terminal anchor licenses killing it. The point
     # is the window right after an anchor goes terminal -- a PR merges while
@@ -1154,6 +1169,25 @@ class Config:
                 f"max_sessions must be >= 0 (0 = unlimited), got {max_sessions}"
             )
 
+        headroom_threads = int(
+            raw.get("spawn_headroom_threads", cls.spawn_headroom_threads)
+        )
+        if headroom_threads < 0:
+            raise ValueError(
+                f"spawn_headroom_threads must be >= 0 (0 = off), got "
+                f"{headroom_threads}"
+            )
+        headroom_memory = int(
+            raw.get("spawn_headroom_memory_pct", cls.spawn_headroom_memory_pct)
+        )
+        # Capped at 90: a reserve of the whole limit would hold every spawn
+        # for ever on any container that has started anything at all.
+        if not 0 <= headroom_memory <= 90:
+            raise ValueError(
+                f"spawn_headroom_memory_pct must be between 0 and 90 (0 = "
+                f"off), got {headroom_memory}"
+            )
+
         # The reaper's grace, validated like the two below it -- same 0
         # sentinel, and a negative value is the only invalid one (it would
         # make every listed session instantly reapable, which is the one
@@ -1340,6 +1374,8 @@ class Config:
             attempt_cap=cap,
             stale_minutes=stale,
             max_sessions=max_sessions,
+            spawn_headroom_threads=headroom_threads,
+            spawn_headroom_memory_pct=headroom_memory,
             reap_grace_minutes=reap_grace,
             foreign_session_policy=foreign_policy,
             foreign_session_allow_prefixes=normalize_session_prefixes(

alissa/tools/github/devloop/loop.py

@@ -464,6 +464,7 @@ from . import janitor
 from . import fleet_vitals as fleet_vitals_mod
 from . import loop_events as loop_events_mod
 from . import parking as parking_mod
+from . import proc as proc_mod
 from . import prompts as prompts_mod
 from .alissa import MANAGED_PREFIX, SHELL_COMMANDS, Alissa
 from .alissa_client import AlissaClient
@@ -2689,6 +2690,112 @@ class DiskReport:
     offenders: "tuple[tuple[str, int], ...]" = ()
 
 
+# The container's cgroup v2 mount (issue #162). A module global, read at each
+# call, so a test can point every watcher at a fake cgroup directory.
+CGROUP_ROOT = Path("/sys/fs/cgroup")
+
+
+def _cgroup_value(path: Path) -> "int | str | None":
+    """One cgroup v2 counter file: its integer, the string "max" (no limit),
+    or None when it is absent, unreadable, or malformed."""
+    try:
+        raw = path.read_text().split()[0]
+    except (OSError, ValueError, IndexError):
+        return None
+    if raw == "max":
+        return "max"
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+def _cgroup_stat(path: Path, field: str) -> int:
+    """One `key value` line of a cgroup `memory.stat`; 0 when unreadable --
+    it only ever ADDS headroom (reclaimable page cache), so a missing stat
+    reads the conservative way."""
+    try:
+        for line in path.read_text().splitlines():
+            key, _, value = line.partition(" ")
+            if key == field:
+                return int(value.strip())
+    except (OSError, ValueError):
+        return 0
+    return 0
+
+
+@dataclass(frozen=True)
+class Headroom:
+    """One pass's cgroup headroom reading (issue #162).
+
+    `low` names every guard whose reserve is breached, in the poll-summary
+    wording (`threads 812/1000, reserve 300`), and is empty when the pass may
+    spawn. `unreadable` names every ENABLED guard whose files could not be
+    read: that guard is off this pass (failing open, like the max_sessions
+    budget on a listing failure -- a missing file must not freeze spawning)
+    and the watcher warns about it once."""
+
+    low: "tuple[str, ...]" = ()
+    unreadable: "tuple[str, ...]" = ()
+
+    @property
+    def reason(self) -> "str | None":
+        """`headroom (threads 812/1000, reserve 300)`, or None when no
+        reserve is breached."""
+        if not self.low:
+            return None
+        return f"headroom ({'; '.join(self.low)})"
+
+
+def read_headroom(
+    threads_reserve: int,
+    memory_pct: int,
+    cgroup_root: "Path | None" = None,
+) -> Headroom:
+    """Read cgroup v2 `pids.current`/`pids.max` and `memory.current`/
+    `memory.max` and judge them against the two reserves. A reserve of 0 is
+    that guard off (its files are not even read); a `max` limit is unlimited,
+    so that guard is off too. `pids.max` counts THREADS, not processes --
+    which is why a session count alone never bounded it. Free memory is the
+    limit minus what is charged, with the inactive page cache the kernel
+    would drop under pressure (`memory.stat inactive_file`) counted as free:
+    a container that just walked a few big checkouts is not out of memory."""
+    root = CGROUP_ROOT if cgroup_root is None else cgroup_root
+    low: "list[str]" = []
+    unreadable: "list[str]" = []
+    if threads_reserve > 0:
+        current = _cgroup_value(root / "pids.current")
+        limit = _cgroup_value(root / "pids.max")
+        if not isinstance(current, int) or limit is None:
+            unreadable.append("threads")
+        elif isinstance(limit, int) and limit - current < threads_reserve:
+            low.append(f"threads {current}/{limit}, reserve {threads_reserve}")
+    if memory_pct > 0:
+        current = _cgroup_value(root / "memory.current")
+        limit = _cgroup_value(root / "memory.max")
+        if not isinstance(current, int) or limit is None:
+            unreadable.append("memory")
+        elif isinstance(limit, int) and limit > 0:
+            charged = max(0, current - _cgroup_stat(root / "memory.stat", "inactive_file"))
+            free = max(0, limit - charged)
+            if free * 100 < memory_pct * limit:
+                low.append(
+                    f"memory {free * 100 // limit}% free of "
+                    f"{limit / (1 << 30):.1f} GiB, reserve {memory_pct}%"
+                )
+    return Headroom(low=tuple(low), unreadable=tuple(unreadable))
+
+
+def cgroup_threads(cgroup_root: "Path | None" = None) -> "str | None":
+    """`pids 998/1000` for a log line, or None when unreadable."""
+    root = CGROUP_ROOT if cgroup_root is None else cgroup_root
+    current = _cgroup_value(root / "pids.current")
+    limit = _cgroup_value(root / "pids.max")
+    if not isinstance(current, int) or limit is None:
+        return None
+    return f"pids {current}/{limit}"
+
+
 class SessionBudget:
     """The per-pass concurrency budget behind `max_sessions`.
 
@@ -2727,10 +2834,18 @@ class SessionBudget:
         hold: "str | None" = None,
         probe: bool = False,
         limited: int = 0,
+        headroom: "str | None" = None,
     ):
         self.limit = limit
         self.active = active
         self.reserved = 0
+        # The cgroup headroom guard (issue #162): while the container's
+        # thread or memory reserve is breached, every reserve() is refused --
+        # resumes, fix rounds and the usage-limit probe included, since each
+        # is a new session with the same footprint. It defers on the
+        # capacity valve (claims nothing, re-decided next poll); `headroom`
+        # is the reason, `headroom (threads 812/1000, reserve 300)`.
+        self.headroom = headroom
         # The prompt responder's spawn hold (issue #127): while an account-
         # level notice (an expired login, a hit limit, no credits) is on a
         # worker's screen, NEW sessions would only burn attempts against a
@@ -2763,7 +2878,10 @@ class SessionBudget:
     def reserve(self) -> bool:
         """Claim one slot if the cap allows. Unlimited always grants -- unless
         the responder's hold stands, which refuses every spawn but the one
-        probe a usage-limit hold admits (issue #144)."""
+        probe a usage-limit hold admits (issue #144). A breached cgroup
+        headroom reserve refuses everything, the probe too (issue #162)."""
+        if self.headroom:
+            return False
         if self.hold:
             if not self.probe or self._probe_taken:
                 return False
@@ -2797,13 +2915,20 @@ class SessionBudget:
     def defer_token(self) -> "str | None":
         """The loop-events defer token a DEFERRED decision off this budget
         carries: the hold's own token while it stands, else None (the
-        emitter reads None as the capacity valve)."""
+        emitter reads None as the capacity valve). A headroom deferral is
+        the capacity valve too (issue #162), even under a hold: the guard
+        refused it first."""
+        if self.headroom:
+            return None
         return loop_events_mod.DEFER_PROMPT_HOLD if self.hold else None
 
     def deferral(self) -> str:
         """The DEFERRED decision's reason -- `at capacity k/k`, the operator's
         signal that the cap (not per-item state) is what held the spawn --
-        or the responder's hold, which names the notice standing in the way."""
+        or the responder's hold, which names the notice standing in the way,
+        or the cgroup headroom reserve the container is under (issue #162)."""
+        if self.headroom:
+            return f"{self.headroom}; retrying next poll"
         if self.hold:
             return f"spawns held by the prompt responder — {self.hold}"
         return f"at capacity {self.used}/{self.limit}; retrying next poll"
@@ -3408,6 +3533,10 @@ class DevWatcher:
         # The reaper's warn-once latch for a CLI without `tmux kill` (kills
         # are best-effort; the condition is per-process, not per-session).
         self._kill_warned = False
+        # The headroom guard's warn-once latch (issue #162): the guards whose
+        # cgroup files could not be read. Per-process like the one above --
+        # an unreadable cgroup does not become readable between polls.
+        self._headroom_warned: "set[str]" = set()
         # The BOW-derived allowlist (`repos_source: "bows"`), or None in
         # static mode -- in which nothing below this line ever runs and the
         # allowlist is `config.repos`, unchanged.
@@ -10234,8 +10363,14 @@ class DevWatcher:
         roster fails CLOSED in the same breath -- an unlisted roster answers
         INDETERMINATE, so a hiccup can never manufacture a resume.
         `max_sessions=0` also yields an unlimited budget -- the default, so
-        nothing changes until an operator opts in."""
+        nothing changes until an operator opts in.
+
+        The cgroup headroom guard (issue #162) is read here too, from files
+        rather than the listing, so it stands through a listing failure: a
+        container out of threads is exactly the one whose `tmux ls` fork
+        fails, and failing the budget open THEN would spawn into the wall."""
         limit = self.config.max_sessions or None
+        headroom = self._read_headroom()
         try:
             sessions = self.alissa.list_sessions()
         except CommandError as exc:
@@ -10250,7 +10385,7 @@ class DevWatcher:
             limit_hold, _probe = self._limit_gate(None)
             return (
                 Sweep(reaped=0, names=set(), hold=limit_hold),
-                SessionBudget(None, 0, hold=limit_hold),
+                SessionBudget(None, 0, hold=limit_hold, headroom=headroom),
                 SessionLiveness(None),
             )
         sweep = self._reap_sessions(sessions)
@@ -10295,10 +10430,60 @@ class DevWatcher:
         )
         return (
             sweep,
-            SessionBudget(limit, active, hold=sweep.hold, probe=probe, limited=limited),
+            SessionBudget(
+                limit, active, hold=sweep.hold, probe=probe, limited=limited,
+                headroom=headroom,
+            ),
             SessionLiveness(sessions, gone),
         )
 
+    def _read_headroom(self) -> "str | None":
+        """The pass's headroom deferral reason, or None when the pass may
+        spawn (issue #162). Logs the breach at WARNING (the operator's signal
+        that the container, not the session cap, is what holds the fleet),
+        and an unreadable guard ONCE per process -- that guard is off."""
+        reading = read_headroom(
+            self.config.spawn_headroom_threads,
+            self.config.spawn_headroom_memory_pct,
+        )
+        for guard in reading.unreadable:
+            if guard in self._headroom_warned:
+                continue
+            self._headroom_warned.add(guard)
+            log.warning(
+                "headroom: the cgroup v2 %s files under %s cannot be read — "
+                "the %s headroom guard is OFF (spawns are not held on it)",
+                guard, CGROUP_ROOT,
+                "spawn_headroom_threads" if guard == "threads"
+                else "spawn_headroom_memory_pct",
+            )
+        if reading.reason:
+            log.warning(
+                "%s: HOLDING new worker spawns this pass (resumes and fix "
+                "rounds included); live sessions keep running and the next "
+                "poll re-reads the cgroup", reading.reason,
+            )
+        return reading.reason
+
+    def _warn_start_failures(self) -> None:
+        """ONE warning per poll for every command that could not even start
+        (issue #162): the fork or exec failed -- EAGAIN at the cgroup's
+        pids.max on 2026-10-13 -- and `proc.run` raised it as the
+        CommandError its caller already handles. Names the errno(s) and the
+        thread budget when the cgroup reads."""
+        failures = proc_mod.take_start_failures()
+        if not failures:
+            return
+        names = ", ".join(sorted(Counter(failures)))
+        threads = cgroup_threads()
+        log.warning(
+            "%d command(s) could not start this poll (%s)%s — the container "
+            "is likely at its process/thread or memory limit; the poll's "
+            "failure paths handled each one",
+            len(failures), names,
+            f"; cgroup {threads}" if threads else "",
+        )
+
     def _check_session_cap(self, active: int, sweep: Sweep) -> None:
         """Page-worthy log when the machine is STILL over `max_sessions` after
         the sweep.
@@ -11259,7 +11444,7 @@ class DevWatcher:
             "poll summary: %d candidate(s) — %d spawned, %d in-flight, "
             "%d skipped, %d escalated, %d capped, %d deferred; "
             "%d worker session(s) reaped, %d foreign; %d parked on a prompt, "
-            "%d answered%s; vitals: %s",
+            "%d answered%s%s; vitals: %s",
             len(results),
             counts[Action.SPAWNED],
             counts[Action.IN_FLIGHT],
@@ -11272,6 +11457,7 @@ class DevWatcher:
             len(sweep.waiting),
             sweep.answered,
             " (spawns HELD)" if sweep.hold else "",
+            f"; deferred: {budget.headroom}" if budget.headroom else "",
             vitals,
         )
         return results
@@ -11280,21 +11466,19 @@ class DevWatcher:
         """The pass's fleet-vitals push (issue #116): one console snapshot
         to Studio, built from the pass's own roster and the ledgers the pass
         just wrote. Returns the outcome token the summary quotes --
-        `skipped` when the feature is off or under dry_run (the push writes
-        to an external service, and a dry pass takes no side effects: it
-        logs what it would have sent instead), else the pusher's `pushed` /
-        `failed`. Runs AFTER the loop-events push and never raises."""
+        `skipped` when the feature is off, else the pusher's `pushed` /
+        `failed`. Runs AFTER the loop-events push and never raises.
+
+        dry_run still pushes (issue: managed fleet first heartbeat). Vitals
+        are the seat's liveness report to Studio, not an action on any
+        repository: the managed provisioner deploys devloop dry for the
+        smoke's first phase and waits for its first heartbeat, which a dry
+        pass that sent nothing could never give. revloop already pushes its
+        vitals under dry_run; this makes the seats agree."""
         if self.fleet_vitals is None:
             return fleet_vitals_mod.SKIPPED
         if self.config.dry_run:
-            log.info(
-                "[dry-run] would push fleet vitals (seat %s, %s roster "
-                "session(s) → POST %s%s)",
-                fleet_vitals_mod.SEAT,
-                len(roster.entries) if roster.entries is not None else "unlisted",
-                self.config.alissa_endpoint, fleet_vitals_mod.ENDPOINT_PATH,
-            )
-            return fleet_vitals_mod.SKIPPED
+            log.debug("[dry-run] pushing fleet vitals anyway: liveness is not a side effect on a repository")
         return self.fleet_vitals.push_pass(roster.entries)
 
     def _vitals_config(self) -> dict:
@@ -11703,6 +11887,11 @@ class DevWatcher:
                         "not a GitHub or auth failure; retrying in %ds",
                         exc, backoff,
                     )
+                finally:
+                    # After whichever branch ran, before the sleep: a fork
+                    # failure is usually caught deep in the pass, so a
+                    # "successful" poll is where it most often surfaces.
+                    self._warn_start_failures()
                 time.sleep(backoff)
             except KeyboardInterrupt:
                 log.info("stopping")

alissa/tools/github/devloop/proc.py

@@ -3,6 +3,7 @@ their own auth handling; we never touch tokens ourselves."""
 
 from __future__ import annotations
 
+import errno
 import json
 import logging
 import os
@@ -20,6 +21,29 @@ class CommandError(RuntimeError):
         super().__init__(f"{argv[0]} exited {returncode}: {stderr.strip()[:400]}")
 
 
+# The errno names of every command that could not even START (fork/exec
+# failed) since the last take_start_failures(). Issue #162: at the container's
+# cgroup pids.max a fork raises BlockingIOError (EAGAIN), which run() now
+# turns into a CommandError so each caller's existing failure path handles it;
+# the daemon loop drains this list once per poll to log ONE warning naming
+# the errno and the thread budget, instead of one per failed command.
+_start_failures: "list[str]" = []
+
+
+def _errno_name(exc: OSError) -> str:
+    if exc.errno is None:
+        return type(exc).__name__
+    return errno.errorcode.get(exc.errno, str(exc.errno))
+
+
+def take_start_failures() -> "list[str]":
+    """The errno names of the commands that failed to start since the last
+    call, oldest first; clears the list."""
+    taken = list(_start_failures)
+    _start_failures.clear()
+    return taken
+
+
 def run(
     argv: Sequence[str],
     *,
@@ -39,6 +63,17 @@ def run(
         )
     except subprocess.TimeoutExpired as exc:
         raise CommandError(argv, -1, f"timed out after {timeout}s") from exc
+    except OSError as exc:
+        # The command never ran: the fork or the exec failed (EAGAIN at the
+        # cgroup's pids.max, ENOMEM, a missing binary). Raised as the
+        # CommandError every caller already handles -- the 2026-10-13 outage
+        # was a BlockingIOError escaping run_forever, which only catches
+        # CommandError, and taking the whole daemon down with it.
+        name = _errno_name(exc)
+        _start_failures.append(name)
+        raise CommandError(
+            argv, -1, f"could not start {argv[0]}: {name}: {exc.strerror or exc}"
+        ) from exc
 
     if check and proc.returncode != 0:
         raise CommandError(argv, proc.returncode, proc.stderr)

alissa/tools/github/devloop/version

@@ -1 +1 @@
-0.8.39
+0.8.41

{alissa_tools_github_devloop-0.8.39.dist-info → alissa_tools_github_devloop-0.8.41.dist-info}/METADATA

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

{alissa_tools_github_devloop-0.8.39.dist-info → alissa_tools_github_devloop-0.8.41.dist-info}/RECORD

@@ -3,18 +3,18 @@ alissa/tools/github/devloop/__main__.py,sha256=5p_SjwpOvdyTA8pPr54gS-RP99itkydVc
 alissa/tools/github/devloop/alissa.py,sha256=TJU4eSZc2MvP35HewCwBKvhPAel32vKjtt3ApSPDLrM,18064
 alissa/tools/github/devloop/alissa_client.py,sha256=wmpXYWf9ThcLeYnz6gGeDz7gj5BpYjduuVASMc-QOOY,14873
 alissa/tools/github/devloop/bows.py,sha256=pzDNMRk_S78FX7vMNYMlXHxW6VPHPo1Xd2EzFMgVCUM,17325
-alissa/tools/github/devloop/config.py,sha256=VKeyTsXfoRSDltuU1h9UqjrHGE6YvgCQDvimDt3BH58,73330
+alissa/tools/github/devloop/config.py,sha256=j6W0Wrz7smFdFdSs3g5S6xadcxfFS5YEhQDL64yAuJk,75109
 alissa/tools/github/devloop/fleet_vitals.py,sha256=Hl2xshweh7A9R0N7fyYRg2WzHN4aNefVlt0TiXCv8zk,24979
 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=Md5uX1Euo1T1SZ8x8um-TfirPjeTQsbb8ndQJ36nREs,590672
+alissa/tools/github/devloop/loop.py,sha256=BFU9XgBTColvKwgiczxhWPgACn1LGiszV1HDxTIqaqM,599231
 alissa/tools/github/devloop/loop_events.py,sha256=tmso0OALqY2yAPW2Fo6ae0sYetQIdIeIYooJ2Sc2cc4,37921
 alissa/tools/github/devloop/parking.py,sha256=2Sys1bh_hG8qbq7cO9RxW1F1kAu3dCWHnvwg_iAFVvY,7987
-alissa/tools/github/devloop/proc.py,sha256=_dDr3g76WEf2DRyLUz1Dzl4KvLVptJant_UZOrRixNk,1649
+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=G7Ocfbe12QLl5nILgm4wm9MiFgTZ-m2G2Eqgqg_CJWc,7
+alissa/tools/github/devloop/version,sha256=QOcLK9uM_DEwqdJtbll5EUYMrrUbOLIguSS-pnllhCs,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
@@ -23,10 +23,10 @@ alissa/tools/github/devloop/webui/page.py,sha256=4OD3e01ByvVM4Wo04AZyFuyOYTFEMT2
 alissa/tools/github/devloop/webui/server.py,sha256=YuUmcng5qdWqSurcuyxH3FKKkBBfrpDtvtZLidJOGiU,26226
 alissa/tools/github/devloop/webui/sources.py,sha256=Ud8357-Ag4qC39V3mlepqnArui9p1fTJ058bAdN29Jc,36730
 alissa/tools/github/devloop/webui/sysinfo.py,sha256=ptlogH9alFv0vZ-pQfyUaA3w-K7LQS3tQHGv0d8Tdlk,9649
-alissa_tools_github_devloop-0.8.39.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-alissa_tools_github_devloop-0.8.39.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
-alissa_tools_github_devloop-0.8.39.dist-info/METADATA,sha256=2AAwmlUxY0R_doi3rOjmqej-3vvHiea0iRF7qoWktiU,8093
-alissa_tools_github_devloop-0.8.39.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-alissa_tools_github_devloop-0.8.39.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
-alissa_tools_github_devloop-0.8.39.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
-alissa_tools_github_devloop-0.8.39.dist-info/RECORD,,
+alissa_tools_github_devloop-0.8.41.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+alissa_tools_github_devloop-0.8.41.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
+alissa_tools_github_devloop-0.8.41.dist-info/METADATA,sha256=Ngui7ERzDLYBQHzZ1Q6mdtFV1mnek3FUeFnwqk5YhG8,8093
+alissa_tools_github_devloop-0.8.41.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+alissa_tools_github_devloop-0.8.41.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
+alissa_tools_github_devloop-0.8.41.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
+alissa_tools_github_devloop-0.8.41.dist-info/RECORD,,