alissa-tools-github-devloop 0.8.42__tar.gz → 0.8.43__tar.gz

{alissa_tools_github_devloop-0.8.42/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.42
+Version: 0.8.43
 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 → alissa_tools_github_devloop-0.8.43}/README.md

@@ -172,6 +172,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 → alissa_tools_github_devloop-0.8.43}/src/main/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-0.8.42 → alissa_tools_github_devloop-0.8.43}/src/main/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-0.8.43/src/main/alissa/tools/github/devloop/version

@@ -0,0 +1 @@
+0.8.43

{alissa_tools_github_devloop-0.8.42 → alissa_tools_github_devloop-0.8.43}/src/main/alissa/tools/github/devloop/webui/sources.py

@@ -438,17 +438,25 @@ 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(),
         )
 

{alissa_tools_github_devloop-0.8.42 → alissa_tools_github_devloop-0.8.43/src/main/alissa_tools_github_devloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-devloop
-Version: 0.8.42
+Version: 0.8.43
 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/src/main/alissa/tools/github/devloop/version

@@ -1 +0,0 @@
-0.8.42