@vibelord/lanes 1.0.2 → 1.0.3

package/payload/lanes/libexec/sidebar.py

@@ -93,7 +93,7 @@ def osc_text(text):
 # ----------------------------------------------------------------- economy (plan Task 12, spec §4.2/§4.6(c))
 ECONOMY_SCHEMA = 1             # economy.json `v` this reader understands (Task 11, DM-LANES-ECONOMY; additive)
 STARVING_AGE = 600             # seconds without a request while the pane is producing output
-# economy.json older than this by its own `at`, measured with OUR clock, is a frozen picture (DEF-1447): the poller
+# economy.json older than this by its own `at`, measured with OUR clock, is a frozen picture (DEF-1528): the poller
 # rewrites the file at least every economy_poll.HEARTBEAT (60 s) even when nothing changed, so three missed heartbeats
 # mean the poller stopped (crashed, disabled, or a host too loaded to run it) — the same own-clock rule as HEALTH_STALE.
 ECONOMY_STALE = 180
@@ -564,7 +564,7 @@ class Sidebar:
 
     def economy_aged(self, now):
         """True when the loaded economy.json is older than ECONOMY_STALE by its own `at` against `now` (our clock):
-        the poller stopped, so every figure in it is frozen (DEF-1447). False without a document or without a numeric
+        the poller stopped, so every figure in it is frozen (DEF-1528). False without a document or without a numeric
         `at` — nothing is known, so nothing is claimed (health_banner's rule for a missing health file)."""
         at = number(self.economy.get('at')) if self.economy else None
         return at is not None and now - at > ECONOMY_STALE
@@ -682,7 +682,7 @@ class Sidebar:
         marks the fleet `stale` (a frozen picture is not live), ink-dim with the stale mark in front."""
         fleet = self.economy.get('fleet') or {}
         # Frozen two ways: the poller kept its last fleet strip (`/status` down), or the poller itself stopped and the
-        # whole document is older than ECONOMY_STALE by our clock (DEF-1447). Both are painted alike.
+        # whole document is older than ECONOMY_STALE by our clock (DEF-1528). Both are painted alike.
         stale = fleet.get('stale') is True or self.economy_aged(now)
         spend, budget = number(fleet.get('overflow_spend_today_usd')), number(fleet.get('overflow_budget_usd'))
         fraction = number(fleet.get('spent_fraction'))
@@ -766,7 +766,7 @@ class Sidebar:
         """(glyph, role) for column 34, by priority (spec §4.2): not-observed beats everything, then what is
         actionable — stale `?` > starving ⚠ > downgraded ↓ > paid `$` > a blank. `econ` is the lane's economy.json
         object from `self.economy` or None (no poller, or a lane the poller has not joined: the tail is blank).
-        A FROZEN economy figure keeps its glyph but loses the attention tone (ink-dim, DEF-1447): the lane record
+        A FROZEN economy figure keeps its glyph but loses the attention tone (ink-dim, DEF-1528): the lane record
         carries `stale: true` (the poller kept it while `/sessions` was down), or — with `now` — the whole document
         is older than ECONOMY_STALE. A frozen ⚠ is last-known, not a live alarm; the `?` stays statusd's mark."""
         if observed.get('stale'):
@@ -906,7 +906,7 @@ class Sidebar:
         """The cursor is a LANE (spec §4.5). `entries` is a freshly computed list, `cursor_id` the lane the cursor was
         on before it: the index is re-found from the id, and `top` shifts by the rows that appeared above it, so a lane
         that moves between sections never moves the operator's eye. Then the index is clamped. render() and
-        render_mobile() bound the shifted `top` by the list (DEF-1433): a list that fits the body is never scrolled."""
+        render_mobile() bound the shifted `top` by the list (DEF-1514): a list that fits the body is never scrolled."""
         if cursor_id:
             index = next((i for i, e in enumerate(entries) if e.get('id') == cursor_id), None)
             if index is not None and index != self.cursor:
@@ -1107,7 +1107,7 @@ class Sidebar:
             return
         try:
             # Routed by the registry SHAPE, never by the id's spelling: an adopted session keeps its `--x-` id
-            # but its name authority is registered-sessions.json, not user-sessions/ (DEF-1475).
+            # but its name authority is registered-sessions.json, not user-sessions/ (DEF-1556).
             if entry.get('registered_session'):
                 R.rename(entry['id'], new_name)
                 self.message = f'Renamed → {new_name}'
@@ -1142,7 +1142,7 @@ class Sidebar:
             return
         # Gated the way `start_registration` is: only an UNREGISTERED, reconnectable tmux session. A repository
         # lane or an adopted (`registered_session`) lane is already registered; promoting it would append a
-        # second declaration of the same binding to the repository's terminals.json (DEF-1474).
+        # second declaration of the same binding to the repository's terminals.json (DEF-1555).
         if entry.get('registered_session') or entry.get('repo') or entry.get('source'):
             self.message = 'Already a registered lane; nothing to promote'
             self.dirty = True

package/payload/lanes/libexec/statusd.py

@@ -276,7 +276,7 @@ def agent_signals(containers, sessions_by_server):
     (`parse_codex_title`) over a bare-shell foreground can be a harness that ended into its shell, and only the
     child read (`child_liveness`) tells that apart from a live harness launched under `bash -c` or a wrapper. A pane
     a live Claude session file already claims is not probed (the file outranks the title). The key is set only for
-    a known answer: unknown liveness leaves it absent, and an absent key never demotes a title (DEF-1476). A
+    a known answer: unknown liveness leaves it absent, and an absent key never demotes a title (DEF-1557). A
     container whose files cannot be read costs only its own agents, never a lane its `state`."""
     claude = {}
     for container in sorted({container for container, _socket in sessions_by_server}):
@@ -312,7 +312,7 @@ def agent_signals(containers, sessions_by_server):
 SIDECAR_MAX_AGE = 3600   # a hook sidecar whose last event is older than this loses to the live signals
 # The hook sidecars' own directory under the container home. NOT `.lz/state` itself: lane-run writes each zmx lane's
 # `{phase, ...}` record there as `<zmx name>.json` and exports that name as LANE_ID, so a shared name would let a hook
-# overwrite the record `observe_zmx_container` and the container `lane ls` read (DEF-1436).
+# overwrite the record `observe_zmx_container` and the container `lane ls` read (DEF-1572).
 SIDECAR_DIR = ('.lz', 'state', 'hooks')
 
 
@@ -337,7 +337,7 @@ def agent_sidecars(containers, wanted, now=None):
     ~/.lz/state/hooks per cycle, and a read only for the `.json` names in it — lane-run's phase records in the parent
     directory are never listed or read here. A container whose directory cannot be listed simply has no sidecars —
     absent is "no hook installed", never an error a lane pays for. A zmx lane's hook sidecar is named by its zmx
-    session (lane-run's LANE_ID), not by its published `<ws>--z-<name>` id, so it joins no lane yet (DEF-1437)."""
+    session (lane-run's LANE_ID), not by its published `<ws>--z-<name>` id, so it joins no lane yet (DEF-1573)."""
     out = {}
     for container in sorted(wanted):
         info = containers.get(container) or {}
@@ -757,7 +757,7 @@ def observe_zmx_container(container):
         name = fields.get('name', '')
         if not L.IDENT.match(name):
             continue
-        # The meta and state sidecars are written INSIDE the container (DEF-1461): each one is read as an object or
+        # The meta and state sidecars are written INSIDE the container (DEF-1542): each one is read as an object or
         # nothing, each field as one printable line or nothing, and the workspace must be a lanes identifier — it
         # names a host file below. A malformed sidecar costs its own row's labels, never the container's other rows.
         # `lane new` writes exactly these shapes (`ws` checked against IDENT or empty, `zmx_version` a string).
@@ -782,12 +782,22 @@ def observe_zmx_container(container):
     return lanes, groups
 
 
-def observe_zmx(containers, previous=None):
-    """zmx-held lanes describe themselves (labels + meta sidecar): no registry edit is needed to see one."""
+def observe_zmx(containers, previous=None, listed=None):
+    """zmx-held lanes describe themselves (labels + meta sidecar): no registry edit is needed to see one.
+
+    `listed`, when given, receives `{container: unix time the zmx list was ISSUED}` for every container whose listing
+    ANSWERED this cycle (status.json `zmx_listed_at`). A container that timed out or failed is absent from it: its
+    groups are the previous ones republished, which say nothing about a lane created since. The co-located Studio
+    Host prunes a lane it started only on such a listing (design §8.10 C1, review round 6 — it read absence from any
+    fresh status.json and lost stop authority over lanes a timed-out listing had never seen)."""
     lanes, groups = {}, {}
     for container in containers:
+        issued = time.time()
         try:
-            found = observe_zmx_container(container) or kept_zmx(previous or {}, 'timeout', container)
+            answered = observe_zmx_container(container)
+            found = answered or kept_zmx(previous or {}, 'timeout', container)
+            if answered is not None and listed is not None:
+                listed[container] = issued
         except Exception as error:
             log(f'zmx {container}', error)
             found = kept_zmx(previous or {}, 'error', container)
@@ -860,7 +870,7 @@ def build_payload(ctx, level, reconcile=True):
     except Exception as error:
         log('observe', error)
         lanes = {lane_id: keep(previous, lane_id, 'error') for lane_id in previous.get('lanes') or {}}
-        # DEF-1457: COPIES of what was published, never the previous payload itself (`previous` is the very object
+        # DEF-1538: COPIES of what was published, never the previous payload itself (`previous` is the very object
         # `ctx['published']` holds, so a kept list extended in place would grow the published payload), and only
         # observe's own rows (holder 'tmux', the rows `observe` carries over too).
         servers = dict(previous.get('servers') or {})
@@ -876,11 +886,15 @@ def build_payload(ctx, level, reconcile=True):
             reconcile_client_sizes(registry, containers, live)
         except Exception as error:
             log('reconcile', error)
+    listed = {}
     try:
-        zmx_lanes, zmx_groups = observe_zmx(containers, previous)
+        zmx_lanes, zmx_groups = observe_zmx(containers, previous, listed)
     except Exception as error:
         log('zmx', error)
         zmx_lanes, zmx_groups = kept_zmx(previous, 'error')
+        listed = {}
+    # Outside the payload: it changes every cycle, and status.json is rewritten only on change (plus the heartbeat).
+    ctx['zmx_listed_at'] = listed
     lanes.update(zmx_lanes)
     return {'lanes': lanes, 'servers': servers, 'unregistered': unregistered, 'zmx': zmx_groups,
             'containers': {k: {'running': v.get('running', False)} for k, v in containers.items()}}
@@ -919,7 +933,8 @@ def cycle(ctx, reconcile=True):
         if payload != ctx['published'] or started - ctx['status_at'] > HEARTBEAT:
             try:
                 written = time.time()
-                L.atomic_write(L.STATE / 'status.json', json.dumps(dict(payload, health=health, updated_at=written)) + '\n')
+                L.atomic_write(L.STATE / 'status.json', json.dumps(dict(payload, health=health, updated_at=written,
+                                                                        zmx_listed_at=ctx.get('zmx_listed_at') or {})) + '\n')
                 ctx['published'], ctx['status_at'] = payload, written
             except Exception as error:
                 log('status.json', error)