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

alissa/tools/github/devloop/fleet_vitals.py

@@ -257,7 +257,8 @@ def build_snapshot(
     `queued` (the undispatched alissa queue items, None when unread) and
     `drain` (the holding drain row, or None) feed the `idle` block, whose
     owed / timers come from the latest poll snapshot and whose live /
-    managed come from `roster` -- the same reading as `sessions`.
+    managed come from `roster` -- the same reading as `sessions`, with a dead
+    row backing no held lane left out of `managed` (issue #166).
 
     `config` is the seat's `config_block`, or None to leave the key out
     (the console's push, which has no derived answer to give)."""
@@ -275,13 +276,20 @@ def build_snapshot(
             if session and session not in repo_by_session:
                 repo_by_session[str(session)] = str(row["repo_slug"])
 
+    # A dead row counts as managed only while it backs a lane the seat still
+    # holds (issue #166): Studio's park guard reads `sessions.managed` as well
+    # as the idle block's, so both follow the console's rule.
+    roster_live, roster_managed, _gone = parking.roster_counts(
+        roster, parking.lane_sessions(latest, ledgers=ledgers),
+    )
+
     sessions_block: "dict | None" = None
     session_list: "list[dict] | None" = None
     if roster is not None:
         records = sources.sessions(listing=[dict(r) for r in roster])
         sessions_block = {
             "live": sum(1 for r in records if r.get("live")),
-            "managed": len(records),
+            "managed": roster_managed,
         }
         session_list = [
             _session_row(r, repo_by_session=repo_by_session, parse_session=parse)
@@ -307,11 +315,13 @@ def build_snapshot(
             + int(latest.get("revert_candidates") or 0)
         )
 
-    roster_live, roster_managed = parking.roster_counts(roster)
     idle = parking.idle_block(
         latest, live=roster_live, managed=roster_managed, queued=queued,
         drain=drain, now=now_ts,
     )
+    # `gone` is the console's observation; Studio's idle schema is strict and
+    # does not carry it.
+    idle.pop("gone", None)
 
     drift = sources.drift()
     snapshot = {

alissa/tools/github/devloop/parking.py

@@ -8,8 +8,8 @@ the devloop half of that contract, shared by the daemon (which computes the
 verdict per pass and pushes it with the fleet vitals) and the console (which
 serves it on ``GET /api/state`` and runs the drain handshake):
 
-* **The idle block.** ``{asOf, passAt, owed, live, managed, queued, timers,
-  drainedAt}``. `owed` counts the candidates whose LAST evaluation was an
+* **The idle block.** ``{asOf, passAt, owed, live, managed, queued, gone,
+  timers, drainedAt}``. `owed` counts the candidates whose LAST evaluation was an
   action or a timer the seat owns (a spawn, a fresh spawn row in its stale
   window, an owed respawn, a deferral, a pending stall ping, a grace the seat
   is waiting out, an evaluation that failed); a candidate the seat has
@@ -17,7 +17,9 @@ serves it on ``GET /api/state`` and runs the drain handshake):
   owed. Each pass records the verdict per candidate on its poll snapshot's
   stage (`owed`, `timer`), so the block is read back from the snapshot and
   costs no GitHub call. `live` / `managed` / `queued` are read from tmux and
-  the alissa queue by whoever builds the block.
+  the alissa queue by whoever builds the block. `managed` is the live rows
+  plus the dead rows whose session backs a lane the seat still holds; a dead
+  row backing nothing is reported under `gone` instead (`roster_counts`).
 * **Unknown is never idle.** No snapshot yet → `owed` is null; a listing that
   failed → `live` / `managed` / `queued` are null. `idle_refusals` reads every
   null as a refusal.
@@ -29,7 +31,7 @@ serves it on ``GET /api/state`` and runs the drain handshake):
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import Iterable, Mapping, Sequence
+from typing import Collection, Iterable, Mapping, Sequence
 
 # The timer kinds of the design's idle block (§2.1). devloop owns the first
 # three; the last two are revloop's and are listed so the union is stated once.
@@ -111,19 +113,107 @@ def queued_items(queues: "object") -> "int | None":
     return count
 
 
+# The tmux prefix `alissa tmux` puts on a managed session's real name
+# (`alissa.MANAGED_PREFIX`, restated so this module imports nothing of the
+# daemon's). A listing row carries both spellings (`name` bare, `session`
+# prefixed), a snapshot stage the bare one, a queue the prefixed one.
+MANAGED_PREFIX = "ali-"
+
+# The spawn ledgers (`Sources.ledgers` keys) with the snapshot edge each one
+# feeds, the column holding its issue / PR number, and the slug separator the
+# poll snapshot uses for it (`owner/repo#7`, `owner/repo#pr16`).
+LEDGER_LANES = (
+    ("spawns", "issue", "issue", "#"),
+    ("fix_spawns", "fix", "number", "#pr"),
+    ("maintain_spawns", "maintain", "number", "#pr"),
+    ("revert_spawns", "revert", "number", "#pr"),
+)
+
+# A stage holding one of these actions has a worker in flight on it whatever
+# its owed verdict says: its session is never an orphan.
+IN_FLIGHT_ACTIONS = frozenset({"spawned", "in-flight"})
+
+
+def bare_session(name: "object") -> str:
+    """A session name without its `ali-` tmux prefix ("" for a non-name)."""
+    text = str(name or "")
+    return text[len(MANAGED_PREFIX):] if text.startswith(MANAGED_PREFIX) else text
+
+
+def lane_sessions(
+    snapshot: "Mapping | None",
+    *,
+    ledgers: "Mapping | None" = None,
+    queues: "object" = None,
+) -> "frozenset[str] | None":
+    """The bare names of the sessions that back a lane the seat still holds
+    (issue #166): the session a stage that is owed or in flight names; every
+    session the spawn ledgers record on such a stage's lane (an earlier
+    attempt the lane may still resume); and every session the alissa queue
+    holds an undispatched item for. None before the first pass -- with no
+    snapshot nothing can be called an orphan, so every row stays managed."""
+    if snapshot is None:
+        return None
+    names: "set[str]" = set()
+    held: "set[tuple[str, str]]" = set()
+    for stage in snapshot.get("stages") or ():
+        if not isinstance(stage, Mapping):
+            continue
+        if not (stage_owed(stage) or stage.get("stage") in IN_FLIGHT_ACTIONS):
+            continue
+        held.add((str(stage.get("edge") or ""), str(stage.get("slug") or "")))
+        if stage.get("session"):
+            names.add(bare_session(stage["session"]))
+    for table, edge, column, sep in LEDGER_LANES:
+        for row in (ledgers or {}).get(table) or ():
+            lane = (edge, f"{row.get('repo_slug')}{sep}{row.get(column)}")
+            if lane in held and row.get("session"):
+                names.add(bare_session(row["session"]))
+    if isinstance(queues, list):
+        for queue in queues:
+            if not isinstance(queue, Mapping):
+                continue
+            if any(
+                isinstance(item, Mapping) and not item.get("lastDispatchedAt")
+                for item in queue.get("items") or ()
+            ):
+                names.add(bare_session(queue.get("session")))
+    names.discard("")
+    return frozenset(names)
+
+
 def roster_counts(
     roster: "Sequence[Mapping] | None",
-) -> "tuple[int | None, int | None]":
-    """`(live, managed)` from an ``alissa tmux ls --json`` listing, the
-    fleet-vitals `sessions` rule: a row is live unless it says otherwise.
-    `(None, None)` when the listing failed."""
+    lanes: "Collection[str] | None" = None,
+) -> "tuple[int | None, int | None, list[str] | None]":
+    """`(live, managed, gone)` from an ``alissa tmux ls --json`` listing.
+
+    A row is live unless it says otherwise (the fleet-vitals `sessions`
+    rule: its `live` flag, else `status != "gone"`). A row is MANAGED when it
+    is live or when its session backs a lane the seat still holds -- `lanes`,
+    the bare names `lane_sessions` returns. A dead row matching no lane is an
+    orphan: it is not managed, and its name is reported in `gone` instead
+    (issue #166 -- one such row kept orcloop's `managed == 0` from ever
+    holding). `lanes=None` (no completed pass to read lanes from) keeps every
+    row managed: unknown is never idle. `(None, None, None)` when the listing
+    failed."""
     if roster is None:
-        return None, None
-    rows = [r for r in roster if isinstance(r, Mapping)]
-    live = sum(
-        1 for r in rows if bool(r.get("live", r.get("status") != "gone"))
-    )
-    return live, len(rows)
+        return None, None, None
+    live = managed = 0
+    gone: "list[str]" = []
+    for row in roster:
+        if not isinstance(row, Mapping):
+            continue
+        if bool(row.get("live", row.get("status") != "gone")):
+            live += 1
+            managed += 1
+            continue
+        name = bare_session(row.get("name") or row.get("session"))
+        if lanes is None or name in lanes or bare_session(row.get("session")) in lanes:
+            managed += 1
+        else:
+            gone.append(name)
+    return live, managed, sorted(gone)
 
 
 def idle_block(
@@ -134,10 +224,13 @@ def idle_block(
     queued: "int | None",
     drain: "Mapping | None",
     now: "float | int",
+    gone: "Sequence[str] | None" = None,
 ) -> dict:
     """The seat's idle block from its latest poll snapshot (None before the
     first pass) and the caller's live readings. `drain` is the holding drain
-    row (`State.drain`) or None."""
+    row (`State.drain`) or None. `gone` is `roster_counts`' orphaned rows,
+    reported as `{count, sessions}` (null when the listing was not read) --
+    an observation for the operator, never a refusal."""
     stages: "Iterable[Mapping]" = (snapshot or {}).get("stages") or ()
     owed: "int | None" = None
     timers: "list[dict]" = []
@@ -157,6 +250,10 @@ def idle_block(
         "live": live,
         "managed": managed,
         "queued": queued,
+        "gone": (
+            {"count": len(gone), "sessions": list(gone)}
+            if gone is not None else None
+        ),
         "timers": timers,
         "drainedAt": iso(drain.get("drained_at")) if drain else None,
     }

alissa/tools/github/devloop/version

@@ -1 +1 @@
-0.8.42
+0.8.44

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

@@ -31,6 +31,7 @@ logic lives here -- the console only moves a clock the daemon already reads.
 from __future__ import annotations
 
 import json
+import re
 import sqlite3
 import time
 import urllib.error
@@ -111,8 +112,20 @@ VERSION_CACHE_TTL = 600.0
 # non-terminal task corpus 1,440x/day.
 TASKS_CACHE_TTL = 300.0
 # The flag that narrows `alissa task list` to the calling actor's own rows
-# instead of the sponsor's corpus. Newer CLIs only -- see `_supports_self_scope`.
+# instead of the sponsor's corpus. Newer CLIs only -- see `_task_list_flags`.
 TASKS_SELF_FLAG = "--self"
+# The pane shows live work only, so the read asks for exactly those statuses
+# rather than every non-terminal row: the pending_validation backlog alone was
+# ~2,600 rows (~3.5 MB) per refresh on prod (issue #168).
+TASKS_STATUS_FLAG = "--status"
+TASKS_LIVE_STATUSES = ("draft", "committed", "in_progress", "blocked")
+# A row cap, a small multiple of what the pane displays, for a CLI that offers
+# one. Kept within the 1..100 the CLI's paged listings accept.
+TASKS_LIMIT_FLAG = "--limit"
+TASKS_LIMIT_FACTOR = 4
+TASKS_LIMIT_MAX = 100
+# The pane's displayed row count (`worker_tasks`' default limit).
+TASKS_DISPLAYED = 25
 # PyPI JSON endpoint for the running-vs-latest drift chip.
 PYPI_URL = "https://pypi.org/pypi/alissa-tools-github-devloop/json"
 # How many minutes past the stale window retry-now ages a row: the daemon
@@ -194,6 +207,12 @@ def edge_of(name: "str | None") -> "str | None":
     return None
 
 
+def _offers_flag(helptext: str, flag: str) -> bool:
+    """Whether a CLI `--help` text lists `flag` as an option of its own --
+    `--self` must not be read off a longer `--self-x` it happens to prefix."""
+    return re.search(re.escape(flag) + r"(?![\w-])", helptext) is not None
+
+
 def _default_http_get(url: str, timeout: float) -> "bytes | None":
     try:
         with urllib.request.urlopen(url, timeout=timeout) as resp:  # noqa: S310
@@ -250,8 +269,8 @@ class Sources:
         self._rate_cache = _Cache(RATE_CACHE_TTL, clock)
         self._version_cache = _Cache(VERSION_CACHE_TTL, clock)
         self._tasks_cache = _Cache(TASKS_CACHE_TTL, clock)
-        # Tri-state: None = not probed yet (see `_supports_self_scope`).
-        self._self_scope: "bool | None" = None
+        # None = not probed yet (see `_task_list_flags`).
+        self._list_flags: "frozenset[str] | None" = None
         self.boot_wall = int(wall_clock())
 
     # -- thin, failure-tolerant subprocess helpers -------------------------
@@ -438,54 +457,89 @@ class Sources:
         a drain holds. A caller that already holds the listing (None when it
         failed) or the latest snapshot (None before the first pass) hands it
         in; anything not handed in is read here. A failed listing is null
-        counts, never zeros."""
+        counts, never zeros. A dead row backing no lane the seat holds is
+        reported under `gone`, not counted as managed (issue #166)."""
         if latest is _UNREAD:
             snaps = self.snapshots(1)
             latest = snaps[0] if snaps else None
         if listing is _UNREAD:
             listing = self._safe_json(["alissa", "tmux", "ls", "--json"])
         roster = listing if isinstance(listing, list) else None
-        live, managed = parking.roster_counts(roster)
+        snapshot = latest if isinstance(latest, dict) else None
+        queues = self._safe_json(["alissa", "tmux", "queue", "ls", "--json"])
+        # A dead row counts as managed only while it backs a lane the seat
+        # still holds (issue #166).
+        lanes = parking.lane_sessions(
+            snapshot, ledgers=self.ledgers(), queues=queues,
+        )
+        live, managed, gone = parking.roster_counts(roster, lanes)
         return parking.idle_block(
-            latest if isinstance(latest, dict) else None,
-            live=live, managed=managed, queued=self.queued(),
+            snapshot, live=live, managed=managed,
+            queued=parking.queued_items(queues), gone=gone,
             drain=self.drain(), now=self._wall(),
         )
 
-    def _supports_self_scope(self) -> bool:
-        """Whether the installed `alissa` CLI understands `task list --self`.
+    def _task_list_flags(self) -> "frozenset[str]":
+        """Which of the narrowing flags (`--self`, `--status`, `--limit`) the
+        installed `alissa` CLI offers on `task list`.
 
         Read off the CLI's own `--help`, which is local, tokenless and free.
-        The alternative -- send the flag and fall back when the call fails --
+        The alternative -- send a flag and fall back when the call fails --
         cannot tell an unknown flag from an auth hiccup, so it would spend a
-        second sponsor-scoped call on every unlucky refresh, which is the cost
-        this whole path exists to avoid.
+        second, wider call on every unlucky refresh, which is the cost this
+        whole path exists to avoid.
 
         A probe that *answers* is memoized for the process (the CLI cannot
         change under a running console). A probe that fails is deliberately
         NOT memoized: a transient `alissa` failure then degrades this refresh
-        only, instead of pinning the console to the expensive unscoped call
+        only, instead of pinning the console to the expensive unflagged call
         until someone restarts it."""
-        if self._self_scope is None:
+        if self._list_flags is None:
             helptext = self._safe_run(
                 ["alissa", "task", "list", "--help"], timeout=20
             )
             if helptext is None:
-                return False
-            self._self_scope = TASKS_SELF_FLAG in helptext
-        return self._self_scope
+                return frozenset()
+            self._list_flags = frozenset(
+                flag for flag in
+                (TASKS_SELF_FLAG, TASKS_STATUS_FLAG, TASKS_LIMIT_FLAG)
+                if _offers_flag(helptext, flag)
+            )
+        return self._list_flags
 
-    def worker_tasks(self, limit: int = 25) -> "list[dict]":
+    def _supports_self_scope(self) -> bool:
+        """Whether the installed `alissa` CLI understands `task list --self`."""
+        return TASKS_SELF_FLAG in self._task_list_flags()
+
+    def _task_list_argv(self) -> "list[str]":
+        """The `alissa task list` read the pane refreshes from: narrowed by
+        every flag the CLI offers -- the actor's own rows (`--self`), the live
+        statuses the pane shows (`--status`) and a row cap a small multiple
+        of the displayed count (`--limit`). A flag the CLI lacks is simply left
+        off; that per-flag degrade is the ONLY way the read widens."""
+        flags = self._task_list_flags()
+        argv = ["alissa", "task", "list", "--json"]
+        if TASKS_SELF_FLAG in flags:
+            argv.append(TASKS_SELF_FLAG)
+        if TASKS_STATUS_FLAG in flags:
+            argv += [TASKS_STATUS_FLAG, ",".join(TASKS_LIVE_STATUSES)]
+        if TASKS_LIMIT_FLAG in flags:
+            cap = min(TASKS_DISPLAYED * TASKS_LIMIT_FACTOR, TASKS_LIMIT_MAX)
+            argv += [TASKS_LIMIT_FLAG, str(cap)]
+        return argv
+
+    def worker_tasks(self, limit: int = TASKS_DISPLAYED) -> "list[dict]":
         """The worker actor's own tasks via `alissa task list` -- the
         actor-partition bridge (the console runs as the operator, whose actor
         owns the implementation tasks the dev sessions created). Best-effort:
         an old CLI or an auth hiccup just yields an empty list.
 
-        Self-scoped (`--self`) wherever the installed CLI offers it, so a poll
-        reads the console actor's own rows rather than the sponsor's whole
-        non-terminal corpus -- the pane only ever displays the former. An
-        older CLI, or a `--self` call that comes back empty-handed, degrades to
-        the unflagged call: a slower, larger read beats a blank pane.
+        Narrowed (`_task_list_argv`) to what the pane displays wherever the
+        installed CLI offers the flags, so a refresh reads the console actor's
+        live rows rather than the sponsor's whole non-terminal corpus. Only a
+        CLI that lacks a flag reads wider. A narrowed call that fails is never
+        retried unflagged (issue #168: that fallback re-read the sponsor's
+        whole corpus), and a valid but empty `[]` is a real answer.
 
         Cached (TASKS_CACHE_TTL) exactly like the two other remote checks: this
         call rides the shared ALISSA_API_TOKEN the daemon uses, so on the ~10s
@@ -493,16 +547,7 @@ class Sources:
         the API budget. A fetch that fails returns None and keeps the last good
         list (the _Cache contract), never overwriting it with junk."""
         def fetch() -> "list[dict] | None":
-            unscoped = ["alissa", "task", "list", "--json"]
-            self_scoped = self._supports_self_scope()
-            argv = (unscoped + [TASKS_SELF_FLAG]) if self_scoped else unscoped
-            raw = self._safe_json(argv, timeout=45)
-            if raw is None and self_scoped:
-                # The CLI advertised the flag but the call brought nothing
-                # back -- an API that does not serve the scope yet, say. One
-                # unflagged retry keeps the pane populated. A valid but empty
-                # `[]` is a real answer, not a failure, and is never retried.
-                raw = self._safe_json(unscoped, timeout=45)
+            raw = self._safe_json(self._task_list_argv(), timeout=45)
             if not isinstance(raw, list):
                 return None
             rows = [t for t in raw if isinstance(t, dict)]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.42
+Version: 0.8.44
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera
@@ -194,6 +194,32 @@ resolved from the remote name or URL in the directory the push runs in
 no marker are untouched. `ALISSA_SHELL_GUARD=off` disables this guard with
 the rest.
 
+## Seat parking: what counts as managed (issue #166)
+
+The idle block on `GET /api/state` (`parking.idle_block`, issue #153) is what
+orcloop's D2 invariant reads before it drains and parks the seat: idle only
+when `live == managed == queued == owed == 0` with no timer and a fresh pass.
+`live` and `managed` come from `alissa tmux ls --json`:
+
+- a row is **live** unless it says otherwise (its `live` flag, else
+  `status != "gone"`);
+- a row is **managed** when it is live, **or** when it is dead but its
+  session still backs a lane the seat holds — the session named by a stage
+  of the latest poll snapshot that is owed or in flight (`spawned` /
+  `in-flight`), any session the spawn ledgers record on such a stage's lane
+  (an earlier attempt the lane may still resume), or a session the alissa
+  queue holds an undispatched item for;
+- a dead row backing none of these is an **orphan**: it is not managed, and
+  is reported in the block's `gone` field as `{count, sessions}` so the
+  console and orcloop's logs still show it.
+
+Unknown is never idle: a failed listing leaves `live`, `managed` and `gone`
+null, and before the first completed pass (no snapshot to read lanes from)
+every dead row stays managed. The console only reports an orphan — it never
+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.
+
 ## License
 
 Licensed under the

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

@@ -4,29 +4,29 @@ alissa/tools/github/devloop/alissa.py,sha256=TJU4eSZc2MvP35HewCwBKvhPAel32vKjtt3
 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=j6W0Wrz7smFdFdSs3g5S6xadcxfFS5YEhQDL64yAuJk,75109
-alissa/tools/github/devloop/fleet_vitals.py,sha256=Hl2xshweh7A9R0N7fyYRg2WzHN4aNefVlt0TiXCv8zk,24979
+alissa/tools/github/devloop/fleet_vitals.py,sha256=5mWnRkJh8u9soSplud3UMxkelT6EqAiz-ivX8UmfIqk,25477
 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=2Sys1bh_hG8qbq7cO9RxW1F1kAu3dCWHnvwg_iAFVvY,7987
+alissa/tools/github/devloop/parking.py,sha256=vEf-qprN14-I4vu4M53tIFaA3827FiHLpKetBAgN4LQ,12409
 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=AuempWUg4vcEdSLs24Raav8UvlQqlRrI2s1oyudhK4I,7
+alissa/tools/github/devloop/version,sha256=va232A0BU1OdMrEBtZ5PyqpxusfsBdgt4whBySGjLHY,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=Ud8357-Ag4qC39V3mlepqnArui9p1fTJ058bAdN29Jc,36730
+alissa/tools/github/devloop/webui/sources.py,sha256=JJXJEkLKh2qRbpTaIyQwCTu90DuKq_Z3nz6DwLhzlr4,38900
 alissa/tools/github/devloop/webui/sysinfo.py,sha256=ptlogH9alFv0vZ-pQfyUaA3w-K7LQS3tQHGv0d8Tdlk,9649
-alissa_tools_github_devloop-0.8.42.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-alissa_tools_github_devloop-0.8.42.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
-alissa_tools_github_devloop-0.8.42.dist-info/METADATA,sha256=ZITb9-7j5ZOmFkpcc4wmIz6DRT7_1HygSpTD7sHLp50,10759
-alissa_tools_github_devloop-0.8.42.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-alissa_tools_github_devloop-0.8.42.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
-alissa_tools_github_devloop-0.8.42.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
-alissa_tools_github_devloop-0.8.42.dist-info/RECORD,,
+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,,