alissa-tools-github-devloop 0.8.43__py3-none-any.whl → 0.8.45__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/version

@@ -1 +1 @@
-0.8.43
+0.8.45

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 -------------------------
@@ -460,40 +479,67 @@ class Sources:
             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
@@ -501,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.43.dist-info → alissa_tools_github_devloop-0.8.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.43
+Version: 0.8.45
 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.43.dist-info → alissa_tools_github_devloop-0.8.45.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/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=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=w6XCzs4ibf7WAa6RiS5RhCLRVAdNmHRvxJaC9NKDINI,7
+alissa/tools/github/devloop/version,sha256=SvuxweSl5ewBHlA8sLXW9Cnb1QXZFR16TSaeQVx76Nw,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=8_f5kQv6DGD0A2Y4goKH-TSIQAab-O5uoO3f2nNRhI0,37209
+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.43.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-alissa_tools_github_devloop-0.8.43.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
-alissa_tools_github_devloop-0.8.43.dist-info/METADATA,sha256=ostOBBFoEkmV42blENKqNX5CrVK2dCdPHLIxfYVrzuY,12222
-alissa_tools_github_devloop-0.8.43.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-alissa_tools_github_devloop-0.8.43.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
-alissa_tools_github_devloop-0.8.43.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
-alissa_tools_github_devloop-0.8.43.dist-info/RECORD,,
+alissa_tools_github_devloop-0.8.45.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+alissa_tools_github_devloop-0.8.45.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
+alissa_tools_github_devloop-0.8.45.dist-info/METADATA,sha256=UUG6d1BW6ztPi_whOMe8pL-eLbLK7LpT8BEFUECIp0s,13628
+alissa_tools_github_devloop-0.8.45.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+alissa_tools_github_devloop-0.8.45.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
+alissa_tools_github_devloop-0.8.45.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
+alissa_tools_github_devloop-0.8.45.dist-info/RECORD,,