alissa-tools-github-devloop 0.8.5__tar.gz → 0.8.7__tar.gz

{alissa_tools_github_devloop-0.8.5/src/main/alissa_tools_github_devloop.egg-info → alissa_tools_github_devloop-0.8.7}/PKG-INFO

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

alissa_tools_github_devloop-0.8.7/src/main/alissa/tools/github/devloop/version

@@ -0,0 +1 @@
+0.8.7

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

@@ -8,10 +8,12 @@ in strict budget order:
    call: the daemon already wrote everything down.
 2. **Local process state** -- `alissa tmux ls --json` for the session list, and
    a `/proc` walk (sysinfo) of each session's pane-PID tree for CPU%/RSS.
-3. **Two cached remote checks** -- `gh api rate_limit` (60s cache) for the rate
-   meter, and the PyPI version JSON (10m cache) for the running-vs-latest drift
-   chip. These are the *only* network calls, and both are cached so a room full
-   of refreshing operators cannot move the daemon's rate budget.
+3. **Three cached remote checks** -- `gh api rate_limit` (60s cache) for the
+   rate meter, the PyPI version JSON (10m cache) for the running-vs-latest
+   drift chip, and `alissa task list` (5m cache, self-scoped where the CLI
+   allows it) for the tasks pane. These are the *only* network calls, and all
+   three are cached so a room full of refreshing operators cannot move the
+   daemon's rate budget -- nor the sponsor's.
 4. **Config echo + log tail** -- the effective config the daemon resolved, and
    the tail of its log file.
 
@@ -49,7 +51,14 @@ RATE_CACHE_TTL = 60.0
 VERSION_CACHE_TTL = 600.0
 # `alissa task list` rides the shared ALISSA_API_TOKEN, so it is cached like the
 # other remote checks to keep a room of open tabs off the daemon's rate budget.
-TASKS_CACHE_TTL = 60.0
+# Five minutes rather than the rate meter's sixty seconds: the pane is a
+# monitoring glance, not a live feed, and every uncached read is served
+# sponsor-scoped -- a tab left open on the 60s TTL paid the sponsor's entire
+# 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`.
+TASKS_SELF_FLAG = "--self"
 # 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
@@ -132,6 +141,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
         self.boot_wall = int(wall_clock())
 
     # -- thin, failure-tolerant subprocess helpers -------------------------
@@ -160,9 +171,9 @@ class Sources:
         with a daemon write and raise `sqlite3.OperationalError` (State's
         default 5s busy_timeout narrows this window but does not close it, and
         a corrupt db raises regardless). Catching here honors this module's
-        contract (line 19): a state access never raises an exception that would
-        blank the dashboard or 500 the retry action -- it degrades like every
-        other source."""
+        failure-tolerance contract (the module docstring): a state access never
+        raises an exception that would blank the dashboard or 500 the retry
+        action -- it degrades like every other source."""
         try:
             with State(self.config.state_db) as st:
                 return fn(st)
@@ -239,19 +250,57 @@ class Sources:
             )
         return out
 
+    def _supports_self_scope(self) -> bool:
+        """Whether the installed `alissa` CLI understands `task list --self`.
+
+        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 --
+        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.
+
+        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
+        until someone restarts it."""
+        if self._self_scope 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
+
     def worker_tasks(self, limit: int = 25) -> "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.
 
-        Cached (TASKS_CACHE_TTL) exactly like the two remote checks: this call
-        rides the shared ALISSA_API_TOKEN the daemon uses, so on the ~10s poll
-        an unbounded call per open tab would contend with the daemon for the
-        API budget. A fetch that fails returns None and keeps the last good
+        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.
+
+        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
+        poll an unbounded call per open tab would contend with the daemon for
+        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":
-            raw = self._safe_json(["alissa", "task", "list", "--json"], timeout=45)
+            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)
             if not isinstance(raw, list):
                 return None
             rows = [t for t in raw if isinstance(t, dict)]

{alissa_tools_github_devloop-0.8.5 → alissa_tools_github_devloop-0.8.7/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.5
+Version: 0.8.7
 Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_devloop-0.8.5/src/main/alissa/tools/github/devloop/version

@@ -1 +0,0 @@
-0.8.5