alissa-tools-github-devloop 0.8.45__py3-none-any.whl → 0.8.47__py3-none-any.whl

alissa/tools/github/devloop/config.py

@@ -132,6 +132,36 @@ ENV_REVERT_LABEL = "ALISSA_REVERT_LABEL"
 # worker's worktree as part of the session; the daemon never executes it.
 ENV_REGENERATE = "ALISSA_DEV_REGENERATE"
 
+# The hung-test reaper's window (issue #174): minutes a worker's test-runner
+# tree may sit at under `hungtests.MIN_PROGRESS_SECONDS` of CPU growth before
+# the daemon kills it. Env-only, read straight from the environment like
+# ENV_REGENERATE: not a config key, not a build ARG. Default 20; 0 turns the
+# reaper off; blank falls through to the default; anything that is not a
+# non-negative integer is a config error at boot, by name -- a typo silently
+# read as "off" would leave a 55 h hung suite exactly where it was.
+ENV_HUNG_TEST_MINUTES = "ALISSA_DEV_HUNG_TEST_MINUTES"
+DEFAULT_HUNG_TEST_MINUTES = 20
+
+
+def parse_hung_test_minutes(raw: str) -> int:
+    """The ALISSA_DEV_HUNG_TEST_MINUTES value as minutes (0 = off)."""
+    text = (raw or "").strip()
+    if not text:
+        return DEFAULT_HUNG_TEST_MINUTES
+    try:
+        minutes = int(text)
+    except ValueError:
+        raise ValueError(
+            f"{ENV_HUNG_TEST_MINUTES} must be a whole number of minutes "
+            f"(0 = off), got {raw!r}"
+        ) from None
+    if minutes < 0:
+        raise ValueError(
+            f"{ENV_HUNG_TEST_MINUTES} must be >= 0 (0 = off), got {minutes}"
+        )
+    return minutes
+
+
 # `owner/repo` for a regenerate entry: exactly one `/`, no whitespace, and no
 # `:` (the separator that ends it). Shape only, like the actor-id check.
 _REGENERATE_REPO_RE = re.compile(r"^[^\s/:]+/[^\s/:]+\Z")
@@ -857,6 +887,12 @@ class Config:
     # Read through `regenerate_for(owner, repo)`, never executed here.
     regenerate: tuple[RegenerateRule, ...] = ()
 
+    # The hung-test reaper's window in minutes (issue #174), from
+    # ALISSA_DEV_HUNG_TEST_MINUTES only (no config key, no CLI flag). A
+    # worker's `npm test` / `tsx --test` tree whose CPU grows by under 5 s
+    # across this window is killed; 0 turns the reaper off.
+    hung_test_minutes: int = DEFAULT_HUNG_TEST_MINUTES
+
     dry_run: bool = False
 
     # Derived at build time: `repos` casefolded for matching. GitHub names are
@@ -1118,6 +1154,10 @@ class Config:
         # The regenerable-paths map (issue #138): env-only, validated here so
         # a malformed entry fails the boot by name instead of a directive.
         regenerate = parse_regenerate(env_map.get(ENV_REGENERATE, ""))
+        # The hung-test window (issue #174): env-only, validated here.
+        hung_test_minutes = parse_hung_test_minutes(
+            env_map.get(ENV_HUNG_TEST_MINUTES, "")
+        )
 
         bow_owners = normalize_bow_owners(raw.get("bow_owners", cls.bow_owners))
 
@@ -1430,6 +1470,7 @@ class Config:
             ),
             disk_warn_percent=warn_percent,
             regenerate=regenerate,
+            hung_test_minutes=hung_test_minutes,
             dry_run=bool(raw.get("dry_run", cls.dry_run)),
         )
 

alissa/tools/github/devloop/hungtests.py

@@ -0,0 +1,481 @@
+"""The hung-test reaper's mechanics (issue #174).
+
+On 2026-10-18 the studio devloop container ran at load ~15 while four worker
+`npm test` runs sat hung, each at about 10 CPU-seconds in total -- one of them
+for 55 hours, its lane long merged. Their test workers had died (esbuild's
+"The service was stopped", EAGAIN with the box out of processes), the
+`tsx --test` runner then waited forever, and the sessions waited on it in an
+`until grep -q '^EXIT=' suite.log` loop. Nothing in the fleet noticed: a
+session waiting on a log reads ALIVE to every check the daemon has.
+
+What lives here is the janitor's split again -- only the MECHANICS: which
+process trees are worker test runs (`find_test_trees`), whether one has made
+CPU progress across a window (`CpuWatch`), how to stop one (`kill_tree`), and
+how to tell its session (`message_session`). The POLICY -- which hung or
+orphaned tree to kill, and when -- lives in `loop.py` next to the janitor
+whose predicates it shares.
+
+The properties everything here is written around:
+
+* Nothing outside a task workspace is ever a candidate. A tree is admitted
+  only when its cwd or one of its args sits inside a watched hub's task
+  workspace, judged by the janitor's own grammar (`parse_task_workspace`), so
+  `main/`, `.source/`, an operator's shell and the daemon itself are never
+  CONSIDERED -- the property the tests pin, rather than "checked and spared".
+* CPU progress, not wall-clock, is the hang signal. A full suite that runs for
+  an hour is fine; a runner that burned under `MIN_PROGRESS_SECONDS` of CPU
+  over the whole window is waiting on something that is not coming back.
+* Nothing raises past its own concern. A process that exits mid-read, an
+  unreadable `/proc` entry, a signal to a pid that is already gone -- all are
+  skipped, because this runs inside a poll pass.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Iterable, Mapping, Sequence
+
+from .janitor import TaskWorkspace, parse_task_workspace
+from .proc import CommandError, run
+
+log = logging.getLogger(__name__)
+
+# Where the process table is read. A module attribute (read at call time,
+# never bound as a default) so the tests point it at a fake tree.
+PROC_ROOT = Path("/proc")
+
+# A tree whose summed CPU time grows by less than this across the window is
+# hung. The incident's trees sat at ~10 CPU-seconds TOTAL over hours; a live
+# runner burns this much in seconds.
+MIN_PROGRESS_SECONDS = 5.0
+
+# TERM, then KILL whatever is still alive this long after.
+KILL_GRACE_SECONDS = 10.0
+
+# How often the TERM→KILL wait re-reads the tree.
+_KILL_POLL_SECONDS = 0.5
+
+# The env a managed seat exports (alissa CLI): the tmux session it runs in and
+# the Alissa session id the session-message path addresses. Inherited by every
+# process the seat starts, detached ones included -- which is why they are
+# read off the tree rather than its ancestry: a `nohup npm test &` whose shell
+# exited is reparented to init and has no ancestor pane at all.
+ENV_TMUX_SESSION = "ALISSA_TMUX_SESSION"
+ENV_SESSION_ID = "ALISSA_SESSION_ID"
+
+# The prefix the CLI puts on a managed session's real tmux name; the roster
+# (`alissa tmux ls --json`'s `name`) carries it bare.
+TMUX_PREFIX = "ali-"
+
+# `npm test` and its aliases, plus `npm run test` / `npm run-script test`.
+_NPM_BINARIES = frozenset({"npm", "npm-cli.js"})
+_NPM_TEST = frozenset({"test", "t", "tst"})
+_NPM_RUN = frozenset({"run", "run-script", "rum", "urn"})
+
+
+@dataclass(frozen=True, slots=True)
+class Proc:
+    """One process, as `/proc/<pid>` described it at read time.
+
+    `cpu` is utime+stime PLUS cutime+cstime, in seconds: the reaped children's
+    time is the runner's progress too. A runner that executes one test file
+    after another reaps each child as it finishes; without the children's
+    share the tree's sum would DROP between samples while it works."""
+
+    pid: int
+    ppid: int
+    state: str
+    start: int
+    cpu: float
+    argv: "tuple[str, ...]"
+    cwd: "str | None"
+
+    @property
+    def alive(self) -> bool:
+        return self.state not in ("Z", "X")
+
+
+@dataclass(frozen=True)
+class TestTree:
+    """One worker test run: the topmost runner process and every descendant,
+    with the task workspace it was admitted under."""
+
+    root: Proc
+    members: "tuple[Proc, ...]"
+    workspace: TaskWorkspace
+    tmux_session: "str | None" = None
+    session_id: "str | None" = None
+    age: float = 0.0
+
+    @property
+    def key(self) -> "tuple[int, int]":
+        """(pid, start ticks): a pid alone is reused; the pair is not."""
+        return (self.root.pid, self.root.start)
+
+    @property
+    def cpu(self) -> float:
+        return sum(member.cpu for member in self.members)
+
+    @property
+    def session(self) -> "str | None":
+        """The owning session's roster name (no `ali-` prefix), or None."""
+        name = self.tmux_session
+        if not name:
+            return None
+        return name[len(TMUX_PREFIX):] if name.startswith(TMUX_PREFIX) else name
+
+    @property
+    def command(self) -> str:
+        return " ".join(self.root.argv)
+
+
+def _clock_ticks() -> int:
+    try:
+        return int(os.sysconf("SC_CLK_TCK")) or 100
+    except (ValueError, OSError, AttributeError):  # pragma: no cover
+        return 100
+
+
+def read_proc(pid: int, root: "Path | None" = None) -> "Proc | None":
+    """`/proc/<pid>` as a Proc, or None when it cannot be read (gone, a
+    kernel thread with no cmdline, permission)."""
+    base = (PROC_ROOT if root is None else root) / str(pid)
+    try:
+        stat = (base / "stat").read_text()
+        raw = (base / "cmdline").read_bytes()
+    except OSError:
+        return None
+    # The comm field is parenthesised and may itself hold spaces or `)`;
+    # everything after the LAST `)` is the fixed-position tail.
+    _, _, tail = stat.rpartition(")")
+    fields = tail.split()
+    try:
+        state, ppid = fields[0], int(fields[1])
+        ticks = sum(int(value) for value in fields[11:15])
+        start = int(fields[19])
+    except (IndexError, ValueError):
+        return None
+    argv = tuple(part.decode("utf-8", "replace") for part in raw.split(b"\0") if part)
+    if not argv:
+        return None
+    try:
+        cwd: "str | None" = os.readlink(base / "cwd")
+    except OSError:
+        cwd = None
+    return Proc(
+        pid=pid, ppid=ppid, state=state, start=start,
+        cpu=ticks / _clock_ticks(), argv=argv, cwd=cwd,
+    )
+
+
+def snapshot(root: "Path | None" = None) -> "dict[int, Proc]":
+    """Every readable process, by pid. An unreadable table yields nothing."""
+    base = PROC_ROOT if root is None else root
+    try:
+        names = [entry.name for entry in base.iterdir()]
+    except OSError as exc:
+        log.warning("hung tests: cannot list %s (%s) — skipped this pass", base, exc)
+        return {}
+    procs = {}
+    for name in names:
+        if not name.isdigit():
+            continue
+        proc = read_proc(int(name), base)
+        if proc is not None:
+            procs[proc.pid] = proc
+    return procs
+
+
+def uptime(root: "Path | None" = None) -> "float | None":
+    """Seconds since boot (`/proc/uptime`), or None."""
+    base = PROC_ROOT if root is None else root
+    try:
+        return float((base / "uptime").read_text().split()[0])
+    except (OSError, IndexError, ValueError):
+        return None
+
+
+def is_test_runner(argv: "Sequence[str]") -> bool:
+    """Is this command line a test runner: `npm test` (or `npm run test`),
+    or anything carrying a bare `--test` argument -- `node --test`,
+    `tsx --test`, `npx tsx --test`, and a `timeout … --test` wrapper around
+    one. Exact tokens only: a `bash -c '… --test …'` is one argument holding
+    the words, and the shell is not the runner."""
+    if "--test" in argv:
+        return True
+    for index, token in enumerate(argv):
+        if os.path.basename(token) not in _NPM_BINARIES:
+            continue
+        rest = [arg for arg in argv[index + 1:] if not arg.startswith("-")]
+        if rest and rest[0] in _NPM_TEST:
+            return True
+        if len(rest) >= 2 and rest[0] in _NPM_RUN and rest[1] == "test":
+            return True
+    return False
+
+
+def _path_in(text: str) -> "str | None":
+    if text.startswith("file://"):
+        text = text[len("file://"):]
+    return text if text.startswith("/") else None
+
+
+def workspace_of(
+    proc: Proc, hubs: "Sequence[Path]"
+) -> "TaskWorkspace | None":
+    """The task workspace `proc`'s cwd or one of its path args sits in, or
+    None. The hub's direct child that holds the path must parse as a task
+    workspace under the janitor's grammar -- `main/`, `.source/` and anything
+    else under a hub never qualify."""
+    candidates = [proc.cwd] if proc.cwd else []
+    candidates += [p for p in (_path_in(arg) for arg in proc.argv) if p]
+    for text in candidates:
+        path = Path(os.path.normpath(text))
+        for hub in hubs:
+            try:
+                relative = path.relative_to(hub)
+            except ValueError:
+                continue
+            if not relative.parts:
+                continue
+            workspace = parse_task_workspace(hub / relative.parts[0], hub)
+            if workspace is not None:
+                return workspace
+    return None
+
+
+def session_env(pid: int, root: "Path | None" = None) -> "tuple[str | None, str | None]":
+    """(ALISSA_TMUX_SESSION, ALISSA_SESSION_ID) from the process's env."""
+    base = (PROC_ROOT if root is None else root) / str(pid)
+    try:
+        raw = (base / "environ").read_bytes()
+    except OSError:
+        return None, None
+    found: "dict[str, str]" = {}
+    for part in raw.split(b"\0"):
+        name, sep, value = part.decode("utf-8", "replace").partition("=")
+        if sep and name in (ENV_TMUX_SESSION, ENV_SESSION_ID) and value:
+            found[name] = value
+    return found.get(ENV_TMUX_SESSION), found.get(ENV_SESSION_ID)
+
+
+def _children(procs: "Mapping[int, Proc]") -> "dict[int, list[int]]":
+    children: "dict[int, list[int]]" = {}
+    for proc in procs.values():
+        children.setdefault(proc.ppid, []).append(proc.pid)
+    return children
+
+
+def descendants(procs: "Mapping[int, Proc]", pid: int) -> "list[Proc]":
+    """`pid` and every process below it, root first."""
+    children = _children(procs)
+    order: "list[Proc]" = []
+    stack = [pid]
+    seen: "set[int]" = set()
+    while stack:
+        current = stack.pop()
+        if current in seen or current not in procs:
+            continue
+        seen.add(current)
+        order.append(procs[current])
+        stack.extend(sorted(children.get(current, ()), reverse=True))
+    return order
+
+
+def _has_runner_ancestor(procs: "Mapping[int, Proc]", proc: Proc) -> bool:
+    """Is any live ancestor of `proc` itself a runner? A `sh -c 'tsx --test'`
+    between two runners is one argument and not a runner, so the parent alone
+    cannot answer -- the whole chain up to init is read."""
+    seen = {proc.pid}
+    current = procs.get(proc.ppid)
+    while current is not None and current.pid not in seen:
+        if current.alive and is_test_runner(current.argv):
+            return True
+        seen.add(current.pid)
+        current = procs.get(current.ppid)
+    return False
+
+
+def find_test_trees(
+    procs: "Mapping[int, Proc]",
+    hubs: "Sequence[Path]",
+    root: "Path | None" = None,
+) -> "list[TestTree]":
+    """Every worker test run inside a task workspace of one of `hubs`.
+
+    A tree is rooted at its TOPMOST runner (a runner with no runner above it),
+    so `timeout 900 npx tsx --test` and the `npm exec` / `tsx` / `node --test`
+    chain under it are one tree, killed together. The workspace is read off
+    the first member, root first, whose cwd or args name one; a tree none of
+    whose members does is not ours and is never returned."""
+    resolved = []
+    for hub in hubs:
+        try:
+            resolved.append(Path(hub).resolve())
+        except OSError:
+            continue
+    boot = uptime(root)
+    ticks = _clock_ticks()
+    trees = []
+    for proc in sorted(procs.values(), key=lambda p: p.pid):
+        if not proc.alive or not is_test_runner(proc.argv):
+            continue
+        if _has_runner_ancestor(procs, proc):
+            continue
+        members = tuple(m for m in descendants(procs, proc.pid) if m.alive)
+        workspace = None
+        for member in members:
+            workspace = workspace_of(member, resolved)
+            if workspace is not None:
+                break
+        if workspace is None:
+            continue
+        tmux_session, session_id = session_env(proc.pid, root)
+        age = 0.0 if boot is None else max(0.0, boot - proc.start / ticks)
+        trees.append(TestTree(
+            root=proc, members=members, workspace=workspace,
+            tmux_session=tmux_session, session_id=session_id, age=age,
+        ))
+    return trees
+
+
+@dataclass
+class CpuWatch:
+    """The last CPU sample per tree, and the hang verdict across a window.
+
+    A tree is sampled the first time it is seen; once `window` seconds have
+    passed since its sample it is judged: hung when it is at least `window`
+    old and its CPU grew by under `MIN_PROGRESS_SECONDS`, otherwise the
+    sample moves forward and a new window starts. A tree that burns CPU is
+    therefore re-judged every window, and a tree younger than one never is.
+    Samples of trees that are no longer seen are dropped."""
+
+    window: float
+    clock: "Callable[[], float] | None" = None
+    samples: "dict[tuple[int, int], tuple[float, float]]" = field(default_factory=dict)
+
+    def observe(self, trees: "Iterable[TestTree]") -> "list[TestTree]":
+        now = (self.clock or monotonic)()
+        hung = []
+        seen = set()
+        for tree in trees:
+            seen.add(tree.key)
+            sample = self.samples.get(tree.key)
+            if sample is None:
+                self.samples[tree.key] = (now, tree.cpu)
+                continue
+            at, cpu = sample
+            if now - at < self.window:
+                continue
+            if tree.age >= self.window and tree.cpu - cpu < MIN_PROGRESS_SECONDS:
+                hung.append(tree)
+                continue
+            self.samples[tree.key] = (now, tree.cpu)
+        for key in list(self.samples):
+            if key not in seen:
+                del self.samples[key]
+        return hung
+
+
+def send_signal(pid: int, signum: int) -> None:
+    """`os.kill`, swallowing a pid that is already gone or not ours."""
+    try:
+        os.kill(pid, signum)
+    except (ProcessLookupError, PermissionError):
+        pass
+
+
+def sleep(seconds: float) -> None:
+    """`time.sleep`, behind a module seam the tests replace."""
+    time.sleep(seconds)
+
+
+def monotonic() -> float:
+    """`time.monotonic`, behind a module seam the tests replace."""
+    return time.monotonic()
+
+
+def _still_alive(member: Proc, root: "Path | None") -> bool:
+    now = read_proc(member.pid, root)
+    return now is not None and now.start == member.start and now.alive
+
+
+def kill_tree(
+    tree: TestTree,
+    *,
+    root: "Path | None" = None,
+    grace: float = KILL_GRACE_SECONDS,
+) -> "tuple[int, int]":
+    """TERM every member of `tree`, wait up to `grace` seconds, then KILL
+    whatever is still alive. Returns (termed, killed).
+
+    The member list is re-read first, so a child the runner spawned since the
+    snapshot is signalled too; every pid is matched on its start time before
+    each signal, so a pid the kernel reused for something else is never hit.
+    """
+    fresh = snapshot(root)
+    current = fresh.get(tree.root.pid)
+    if current is None or current.start != tree.root.start:
+        return 0, 0
+    members = [m for m in descendants(fresh, tree.root.pid) if m.alive]
+    for member in members:
+        send_signal(member.pid, signal.SIGTERM)
+    deadline = monotonic() + grace
+    survivors = [m for m in members if _still_alive(m, root)]
+    while survivors and monotonic() < deadline:
+        sleep(_KILL_POLL_SECONDS)
+        survivors = [m for m in survivors if _still_alive(m, root)]
+    for member in survivors:
+        send_signal(member.pid, signal.SIGKILL)
+    return len(members), len(survivors)
+
+
+def session_id_for(tmux_session: str, runner: "Callable[..., str]" = run) -> "str | None":
+    """The Alissa session id behind a managed tmux session, read off
+    `alissa session list --json`'s `tmuxSession`, or None."""
+    try:
+        out = runner(["alissa", "session", "list", "--json", "--limit", "50"], timeout=60)
+        data = json.loads(out)
+    except (CommandError, OSError, ValueError) as exc:
+        log.debug("hung tests: could not list sessions (%s)", exc)
+        return None
+    if isinstance(data, dict):
+        data = data.get("sessions", [])
+    wanted = {tmux_session, TMUX_PREFIX + tmux_session}
+    for entry in data if isinstance(data, list) else []:
+        if isinstance(entry, dict) and entry.get("tmuxSession") in wanted:
+            value = entry.get("sessionId")
+            if isinstance(value, str) and value:
+                return value
+    return None
+
+
+def message_session(
+    session_id: str, text: str, runner: "Callable[..., str]" = run
+) -> bool:
+    """Post `text` to one session through the session-message path
+    (`alissa session msg send -s <id>`). True when the CLI accepted it."""
+    try:
+        runner(["alissa", "session", "msg", "send", "-s", session_id, text], timeout=60)
+    except (CommandError, OSError) as exc:
+        log.warning("hung tests: could not message session %s (%s)", session_id, exc)
+        return False
+    return True
+
+
+def hung_message(tree: TestTree, minutes: int, reason: str) -> str:
+    """The one message a live session gets after its test run was stopped."""
+    return (
+        f"devloop: your test run in {tree.workspace.path.name} "
+        f"(`{tree.command}`, pid {tree.root.pid}) hung and was stopped "
+        f"({reason}). Do not rerun the full suite and never wait on one for "
+        f"more than {minutes} minutes: run only the test files your diff "
+        f"touches, each on its own, one file per command. CI on the PR runs "
+        f"the full suite."
+    )

alissa/tools/github/devloop/loop.py

@@ -461,6 +461,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Callable, Sequence
 
+from . import hungtests
 from . import janitor
 from . import fleet_vitals as fleet_vitals_mod
 from . import loop_events as loop_events_mod
@@ -776,6 +777,21 @@ _SHELL_RULE = (
     "change the command; do not retry it. "
 )
 
+# The test-run rule (issue #174). On 2026-10-18 four worker `npm test` runs
+# hung -- their test workers dead, the runner waiting forever -- and their
+# sessions waited on them, one for 55 h, in an `until grep -q '^EXIT='` loop.
+# The daemon now stops such a run (`DevWatcher.run_hung_tests`); this rule is
+# the half that keeps a worker from starting one it would wait on. In EVERY
+# directive that carries _SHELL_RULE, right after it, because every one of
+# them runs tests in the same box. The 20 is the issue's own number, not the
+# configured window: the directives are byte-pinned templates.
+_TEST_RULE = (
+    "Never wait on a full-suite test run for more than 20 minutes: prefer "
+    "targeted test files — only the files your diff touches, each on its "
+    "own — because CI on the PR is the full run (the daemon stops a worker "
+    "test run that makes no CPU progress for 20 minutes). "
+)
+
 # The regenerate-on-conflict rule (issue #138), rendered into every worker
 # directive that can end up merging main into its branch -- develop, resume,
 # fix, fix-resume and maintain -- and ONLY for a repo with entries in
@@ -833,6 +849,7 @@ DEV_DIRECTIVE = (
     "main). "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "Implement to the issue's acceptance criteria and VERIFY locally (run the "
     "repo's test/style/type scripts) before publishing. {regenerate_rule}"
     "Open a DRAFT PR whose "
@@ -899,6 +916,7 @@ RESUME_DIRECTIVE = (
     "(the origin task AND your implementation task) — restoring them if the "
     "dead session did not. "
     + _SHELL_RULE
+    + _TEST_RULE
     + _RESUME_DELIVERY_NOTE
     + " "
     "If the PR already carries review findings, the ORDER is load-bearing: "
@@ -958,6 +976,7 @@ DISCOVERY_DIRECTIVE = (
     "main). "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "READ the code at the pinned SHA and nowhere else, read-only: "
     "`{read_repo}` at `{read_sha}` (the issue's `Alissa-Reads:` trailer). "
     "If this workspace holds a hub of {read_repo} (a sibling of your hub "
@@ -1064,6 +1083,7 @@ FIX_DIRECTIVE = (
     "main). "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "FIRST verify the triage of every prior review finding per CR8: exactly "
     "one reasoned `[triage:*]` reply on each finding's thread — post any that "
     "are missing. Then fix the pursued findings on the same branch and VERIFY "
@@ -1119,6 +1139,7 @@ FIX_RESUME_DIRECTIVE = (
     "rename, never a clone, never main, and NEVER a second PR. "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "The dead session may have posted SOME of its CR8 triage replies already: "
     "read every finding's thread and post exactly the ones that are missing — "
     "one reasoned `[triage:*]` reply per finding, NEVER a duplicate on a "
@@ -1167,6 +1188,7 @@ MAINTAIN_DIRECTIVE = (
     "main). "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "FIRST the idempotent no-op check: if the branch is already conflict-free "
     "AND current vs origin/main, remove the `{label}` label from the PR "
     "(`gh pr edit {number} --remove-label \"{label}\"`) and exit — push "
@@ -1227,6 +1249,7 @@ REVERT_DIRECTIVE = (
     "the revert below. "
     + _BRANCH_RULE
     + _SHELL_RULE
+    + _TEST_RULE
     + "Revert by merge shape. `git cat-file -p {merge_sha}` lists the "
     "parents. TWO `parent` lines mean a merge commit: run `git revert "
     "--no-edit -m 1 {merge_sha}`. ONE parent means a squash OR a rebase "
@@ -3874,6 +3897,13 @@ class DevWatcher:
         # keys and re-capturing the pane (issue #127); injectable so a test
         # never sleeps.
         self._sleep: "Callable[[float], None]" = time.sleep
+        # The hung-test reaper's per-process state (issue #174): the last CPU
+        # sample per test tree, when its sweep last ran (the janitor's
+        # cadence, on its own clock), and the trees it already stopped --
+        # each is stopped, and its session told, once.
+        self._hung_watch: "hungtests.CpuWatch | None" = None
+        self._hung_tests_at: "float | None" = None
+        self._hung_reaped: "set[tuple[int, int]]" = set()
 
     # -- per-issue decision ------------------------------------------------
 
@@ -11176,6 +11206,192 @@ class DevWatcher:
         self._log_disk(reclaim)
         return reclaim
 
+    # -- the hung-test reaper (issue #174) ---------------------------------
+
+    def run_hung_tests(self, roster: "SessionLiveness | None") -> int:
+        """Stop worker test runs that hung, or that outlived their lane, and
+        tell a live session once. Returns how many trees were stopped.
+
+        The 2026-10-18 incident: four worker `npm test` trees, their test
+        workers dead, sat at ~10 CPU-seconds for 52 min to 55 h while their
+        sessions polled a log for an `EXIT=` line that was never coming.
+        Every check the daemon has reads such a session ALIVE, so nothing
+        else will ever free it.
+
+        Runs on the janitor's cadence (`janitor_interval_minutes`, on its own
+        clock) after the janitor, and is off when `hung_test_minutes` is 0.
+        Mechanics are `hungtests`' -- which trees are worker test runs inside
+        a task workspace, and which grew by under 5 s of CPU across the
+        window; the verdict is `_hung_test_verdict`. Nothing in here may
+        take a poll down."""
+        minutes = self.config.hung_test_minutes
+        if minutes <= 0:
+            return 0
+        window = float(minutes * 60)
+        if self._hung_watch is None or self._hung_watch.window != window:
+            self._hung_watch = hungtests.CpuWatch(window=window)
+        interval = self.config.janitor_interval_seconds
+        now = time.monotonic()
+        if (
+            self._hung_tests_at is not None
+            and interval > 0
+            and now - self._hung_tests_at < interval
+        ):
+            return 0
+        self._hung_tests_at = now
+        try:
+            return self._reap_hung_tests(roster)
+        except (CommandError, OSError) as exc:
+            log.error("hung tests: sweep failed (%s) — skipped this pass", exc)
+            return 0
+
+    def _reap_hung_tests(self, roster: "SessionLiveness | None") -> int:
+        """One sweep: every test tree inside a watched hub's task workspace,
+        judged and, when the verdict says so, stopped."""
+        assert self._hung_watch is not None
+        hubs: "dict[Path, tuple[str, str]]" = {}
+        for owner, repo in self._watched_repos():
+            hub = self.config.hub_for(owner, repo)
+            if hub.is_dir():
+                hubs[hub.resolve()] = (owner, repo)
+        if not hubs:
+            return 0
+        trees = hungtests.find_test_trees(hungtests.snapshot(), list(hubs))
+        hung = {tree.key for tree in self._hung_watch.observe(trees)}
+        # A stopped tree that is still listed (a member stuck in D state)
+        # stays remembered, so it is never stopped -- or its session told --
+        # twice; one that is gone is forgotten.
+        self._hung_reaped &= {tree.key for tree in trees}
+        stopped = 0
+        for tree in trees:
+            if tree.key in self._hung_reaped:
+                continue
+            owner, repo = hubs[tree.workspace.hub]
+            verdict = self._hung_test_verdict(
+                tree, owner, repo, roster, hung=tree.key in hung
+            )
+            if verdict is None:
+                continue
+            stopped += self._stop_hung_tree(tree, verdict, roster)
+        return stopped
+
+    def _hung_test_verdict(
+        self,
+        tree: "hungtests.TestTree",
+        owner: str,
+        repo: str,
+        roster: "SessionLiveness | None",
+        *,
+        hung: bool,
+    ) -> "str | None":
+        """Why `tree` must be stopped, or None to leave it running.
+
+        Cheapest first:
+
+        * its session is GONE -- the seat env the tree inherited
+          (`ALISSA_TMUX_SESSION`) names a session a successful listing does
+          not carry. Stopped at once: nothing is waiting on the run;
+        * it is HUNG -- under 5 s of CPU growth across the window;
+        * its anchor is TERMINAL -- the janitor's own test: the branch has
+          pull requests, none open, and the newest one's state is terminal
+          per `anchor_terminal`. Stopped at once: the lane is over;
+        * for a tree whose env names no session, the janitor's liveness
+          read of the branch's PR (`_orphan_liveness`) is DEAD.
+
+        A listing that failed, or a GitHub read that failed, is never
+        evidence of death: those gates leave the tree to the CPU window."""
+        session = tree.session
+        if (
+            session is not None
+            and roster is not None
+            and roster.of(session) is Liveness.DEAD
+        ):
+            return f"its session {session} is gone"
+        if hung:
+            return (
+                f"hung — under {hungtests.MIN_PROGRESS_SECONDS:g} s of CPU in "
+                f"{self.config.hung_test_minutes} min"
+            )
+        try:
+            pulls = self.github.branch_pulls(owner, repo, tree.workspace.branch)
+        except (RateLimited, CommandError) as exc:
+            log.debug(
+                "hung tests: %s anchor could not be read (%s) — left to the "
+                "CPU window", tree.workspace.slug, exc,
+            )
+            return None
+        if not pulls:
+            return None
+        if not any(pull.state == "open" for pull in pulls):
+            newest = max(pulls, key=lambda pull: pull.number)
+            reason = anchor_terminal(newest.state, is_issue=False)
+            if reason is not None:
+                return f"its anchor #{newest.number} is terminal ({reason})"
+        if session is None:
+            open_pulls = [pull for pull in pulls if pull.state == "open"]
+            newest = max(open_pulls or pulls, key=lambda pull: pull.number)
+            liveness, _ = self._orphan_liveness(newest, roster)
+            if liveness is Liveness.DEAD:
+                return f"no worker session for #{newest.number} is listed"
+        return None
+
+    def _stop_hung_tree(
+        self,
+        tree: "hungtests.TestTree",
+        reason: str,
+        roster: "SessionLiveness | None",
+    ) -> int:
+        """TERM the whole tree, KILL what is left after 10 s, and post ONE
+        message to its session when that session is live."""
+        self._hung_reaped.add(tree.key)
+        slug = tree.workspace.slug
+        if self.config.dry_run:
+            log.info(
+                "[dry-run] would stop the test run %s in %s (pid %d): %s",
+                tree.command, slug, tree.root.pid, reason,
+            )
+            return 0
+        termed, killed = hungtests.kill_tree(tree)
+        if self._hung_watch is not None:
+            self._hung_watch.samples.pop(tree.key, None)
+        if termed == 0:
+            log.info(
+                "hung tests: %s (pid %d) exited before it could be stopped",
+                slug, tree.root.pid,
+            )
+            return 0
+        log.warning(
+            "hung tests: stopped `%s` in %s (pid %d, %.1f CPU-s) — %s; TERM "
+            "to %d process(es), KILL to %d",
+            tree.command, slug, tree.root.pid, tree.cpu, reason, termed, killed,
+        )
+        session = tree.session
+        if (
+            session is not None
+            and roster is not None
+            and roster.of(session) is Liveness.ALIVE
+        ):
+            self._message_hung_session(tree, reason)
+        return 1
+
+    def _message_hung_session(
+        self, tree: "hungtests.TestTree", reason: str
+    ) -> None:
+        """The session-message half: one message, through `alissa session
+        msg send`, to the session the tree's env names."""
+        session_id = tree.session_id
+        if not session_id and tree.tmux_session:
+            session_id = hungtests.session_id_for(tree.tmux_session)
+        if not session_id:
+            log.warning(
+                "hung tests: stopped a test run of %s but its Alissa session "
+                "id is unknown — no message sent", tree.session,
+            )
+            return
+        text = hungtests.hung_message(tree, self.config.hung_test_minutes, reason)
+        if hungtests.message_session(session_id, text):
+            log.info("hung tests: told %s its test run was stopped", tree.session)
+
     def _janitor_due(self) -> bool:
         """Has `janitor_interval_minutes` elapsed since the last expensive
         half? The first pass of a process always runs (nothing has been swept
@@ -11910,6 +12126,10 @@ class DevWatcher:
         # and the rate budget: nothing above consumes the disk it frees, and
         # its telemetry line reads best next to the summary below it.
         self.run_janitor(roster)
+        # The hung-test reaper (issue #174) on the janitor's cadence: a
+        # worker's test run that stopped making CPU progress, or outlived its
+        # lane, is stopped and its live session told once.
+        self.run_hung_tests(roster)
 
         counts = Counter(decision.action for _, decision in results)
         self._write_snapshot(

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.45
+0.8.47

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.45.dist-info → alissa_tools_github_devloop-0.8.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.45
+Version: 0.8.47
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera
@@ -244,7 +244,46 @@ that alone. The daemon kills the row's own session (`alissa tmux kill
 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.
+outlived it (re-parented to init) are not reaped — a known follow-up; test
+runs are the exception (see *Hung test runs* below).
+
+## Hung test runs (issue #174)
+
+A worker's test run whose test workers died (esbuild's "The service was
+stopped", EAGAIN on a box out of processes) leaves its `tsx --test` runner
+waiting forever, and a session polling a log for the run's exit waits with
+it — on 2026-10-18 one had waited 55 h. The daemon now stops such runs.
+
+- **What is a test run.** A process tree rooted at its topmost `npm test`
+  (`npm t`, `npm run test`) or `--test` runner (`node --test`, `tsx --test`,
+  `npx tsx --test`, a `timeout … --test` wrapper), read from `/proc`, whose
+  cwd or args sit inside a watched hub's task workspace — the janitor's
+  `TASK-<n>-<DESC>` grammar. `main/`, `.source/` and anything outside a hub
+  are never considered.
+- **Hung.** The tree's summed CPU time (utime+stime of every member, plus
+  the reaped children's cutime+cstime) grew by under 5 s across a window of
+  `ALISSA_DEV_HUNG_TEST_MINUTES` (default **20**; **0 = off**; runtime env
+  only — not a config key, not a build ARG; a value that is not a
+  non-negative integer fails the boot by name). A tree younger than the
+  window, or one that keeps burning CPU, is left alone.
+- **Stopped at once**, without the window: a tree whose session (the
+  `ALISSA_TMUX_SESSION` the seat exported, inherited by detached runs too)
+  is gone from a successful `alissa tmux ls`, or whose branch's pull
+  requests are all closed with a terminal newest anchor (the janitor's
+  `anchor_terminal`); for a tree carrying no seat env, the janitor's
+  liveness read of the branch's PR answering DEAD. A listing or a GitHub
+  read that failed is never evidence of death.
+- **How.** TERM to every member, KILL to whatever is alive 10 s later; each
+  pid is matched on its start time, so a reused pid is never signalled.
+- **Told once.** When the tree's session is live it gets one message
+  (`alissa session msg send`) per tree, never repeated: the run hung and
+  was stopped; run only the test files the diff touches, each on its own;
+  CI on the PR runs the full suite. Every worker directive says the same up
+  front: never wait on a full-suite run for more than 20 minutes.
+
+Runs at the end of every poll on the janitor's cadence
+(`janitor_interval_minutes`, its own clock, independent of
+`janitor_enabled`); dry-run only logs.
 
 ## License
 

{alissa_tools_github_devloop-0.8.45.dist-info → alissa_tools_github_devloop-0.8.47.dist-info}/RECORD

@@ -3,30 +3,31 @@ 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=j6W0Wrz7smFdFdSs3g5S6xadcxfFS5YEhQDL64yAuJk,75109
+alissa/tools/github/devloop/config.py,sha256=ZgGb7DQR3hOOfCXnRIjmG52m3A2SfQHFX94xEJcBzXo,76861
 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/hungtests.py,sha256=LKBLg0fmswEhGz6GcPWoOx1bDJf0NCBd0UGJLl0K6Yo,18185
 alissa/tools/github/devloop/janitor.py,sha256=R8REoHBeY2cfW7fYJVhKr-F5z9Mjlc-vmv-z4KtvBZc,27360
-alissa/tools/github/devloop/loop.py,sha256=I5rZy082JqplmFm1t2XgYkstc7IdkJJdX-FXAfwqcKk,624114
+alissa/tools/github/devloop/loop.py,sha256=5ZYrsB8JGBECNnmb8xd8Zb70QsFcXQ9Z0vy_vMUFwGw,633862
 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/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=SvuxweSl5ewBHlA8sLXW9Cnb1QXZFR16TSaeQVx76Nw,7
+alissa/tools/github/devloop/version,sha256=VWqpVUhR_phcVHDPOXJg-3ydEhyvkS-oMkQnmypBdUs,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.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,,
+alissa_tools_github_devloop-0.8.47.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+alissa_tools_github_devloop-0.8.47.dist-info/licenses/NOTICE,sha256=FKstNs3uw_tQod4_1XcFLD1FUTJQXf4FC0oXJAOA_HE,260
+alissa_tools_github_devloop-0.8.47.dist-info/METADATA,sha256=ttfErUIcNrjotDmbztORzK-ERI0VjiK9SzoVp5t3fzY,15973
+alissa_tools_github_devloop-0.8.47.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+alissa_tools_github_devloop-0.8.47.dist-info/entry_points.txt,sha256=8aC7Ajzx4bu9ZRR37a40IDfuStacvZP5KsAxY1dbFKU,145
+alissa_tools_github_devloop-0.8.47.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
+alissa_tools_github_devloop-0.8.47.dist-info/RECORD,,