@vibelord/lanes 1.3.0 → 1.5.1

package/payload/lanes/libexec/update.py

@@ -17,7 +17,12 @@ installed. Its steps run in this order, each whatever the ones before it returne
   systemctl --user try-restart <unit> for each optional service in TRY_RESTART (restarted only when it runs), and
   right after lanes-docsd's, `sh install/enable-docs.sh` of the tree (the docs page's pinned Mermaid, plan W10 W8:
   DOCS_STEP; skipped for a tree that has no such script) ·
-  lanes install-container <name> for each container `lanes sync` recorded with a home volume (containers.json) ·
+  lanes install-container <name> for each container `lanes sync` recorded with a home volume (containers.json), then
+  for the Throttle daemon's container when sync did not record it (daemon_container: site.conf's
+  LANES_THROTTLE_CONTAINER, else the Throttle tab's; DEF-1961) — not run, a warning with `outcome: skipped`, when sync
+  or docker said that container is gone or has no home volume (daemon_gone) — run by the tree just
+  installed — it re-ships the container contract files, the Throttle pulse among them since 1.4.0 (plan W11 Track D:
+  so the pulse updates with the host; spec §2.1 has where its loop runs), after statusd's restart ·
   lanes reload-views (the viewports; sidebars swap by themselves, W9 U5) · lanes ensure --if-layout-changed (W9 U6).
 Step output goes to the log (`update/last.log`); stdout gets one line per step and a summary, which names the Mermaid
 outcome (`mermaid ok`, `mermaid skipped: <reason>`, …) whenever its step ran.
@@ -31,7 +36,9 @@ report of a condition the update neither caused nor can mend — `lanes sync` ex
 enable-docs exiting 1 (a prerequisite or the download), 3 (refused: no valid pin, a digest mismatch) or not finishing
 in STEP_TIMEOUT (the download) — recorded with its rc and `"warning": true`, never a failure. A step with outcomes
 (STEP_OUTCOMES: enable-docs) that did not exit 0 also records `outcome` (`skipped`, `refused`, or `failed` for any
-other status, which is a failure) and `reason`, the last line it wrote (else what its status says). Keys it does not
+other status, which is a failure) and `reason`, the last line it wrote (else what its status says). The daemon
+container's install-container step, when not run (daemon_gone), records rc 1 (DAEMON_SKIP_RC), `"warning": true`,
+`outcome: skipped` and the reason. Keys it does not
 own (a rollback's mark, plan W9 U3) are kept. host-install.sh writes `refused`, `failed` and a `partial` commit through
 `record`; `post-commit` writes its own.
 
@@ -285,6 +292,57 @@ def recorded_containers(state):
                   if L.IDENT.match(name) and isinstance(info, dict) and info.get('home'))
 
 
+THROTTLE_MONITOR = 'tools--throttle-monitor'    # lanes_lib.build_registry's Throttle tab; bin/lanes THROTTLE_MONITOR
+
+
+def daemon_container(state, home=None):
+    """The container the Throttle daemon (and so the Throttle pulse, plan W11) runs in, as bin/lanes throttle_container
+    names it — the one install-container starts the pulse in: LANES_THROTTLE_CONTAINER in
+    `<home>/.config/lanes/site.conf` (L.site_conf), else the container of `<state>/registry.json`'s Throttle tab; None
+    when neither names an identifier. Never this process's environment: a timer's update, a re-run and a rollback carry
+    none of it, and site.conf is where the operator names it. `lanes sync` records only the containers a board's repositories name (refresh_containers), so
+    a daemon container that hosts no board repository is not among recorded_containers (DEF-1961): post_commit adds it,
+    or the pulse there would keep the release it was first installed with."""
+    named = L.site_conf(home).get('LANES_THROTTLE_CONTAINER')
+    if named and L.IDENT.fullmatch(named):
+        return named
+    registry = L.read_json(Path(state) / 'registry.json', {})
+    tools = registry.get('tools') if isinstance(registry, dict) else None
+    named = next((tool.get('container') for tool in tools if isinstance(tool, dict)
+                  and tool.get('id') == THROTTLE_MONITOR and isinstance(tool.get('container'), str)
+                  and L.IDENT.fullmatch(tool['container'])), None) if isinstance(tools, list) else None
+    return named
+
+
+# The rc recorded for the daemon container's install-container step when it is not run (daemon_gone): the status
+# install-container exits with for that container (bin/lanes cmd_install_container: a LanesError, exit 1). Recorded as
+# a warning with `outcome: skipped` and the reason, never a failure.
+DAEMON_SKIP_RC = 1
+
+
+def daemon_gone(state, container, inspect=None):
+    """Why install-container cannot ship to the daemon's `container` (daemon_container) -> a reason, or None when it
+    may: nobody said it cannot (W11 Track D review). A name in site.conf or the Throttle tab outlives the container it
+    named (a `docker rm`, a rename); run, its install-container would exit 1 on every update, timer re-run and rollback,
+    leave each `partial` and the timer re-running the post-commit — the very thing recorded_containers keeps a gone
+    board container out of the steps for. From what `lanes sync` recorded when it recorded that container (no home
+    volume: it said so already), else from ONE docker inspect (`inspect`, default L.containers_info): docker answered it
+    does not exist, or it has no home volume. Docker giving no answer says nothing about it: None, and the step runs and
+    reports for itself, as a recorded container's does."""
+    document = L.read_json(Path(state) / 'containers.json', {})
+    if isinstance(document, dict) and isinstance(document.get(container), dict):
+        return None if document[container].get('home') else 'lanes sync recorded no home volume for it'
+    try:
+        answers = (L.containers_info if inspect is None else inspect)([container])
+    except (L.LanesError, subprocess.SubprocessError, OSError, ValueError):
+        return None
+    if not isinstance(answers, dict) or container not in answers:
+        return None
+    if answers[container] is None:
+        return 'docker has no such container'
+    return None if answers[container].get('home') else 'home volume not found'
+
+
 def describe(rc, timeout):
     return {124: f'no answer in {timeout:g} s', 127: 'could not start'}.get(rc, f'exit {rc}')
 
@@ -298,11 +356,12 @@ def count(names, noun):
 
 
 def post_commit(tree, state, log, steps=(), before=None, started=None, out=None, run=None, timeout=STEP_TIMEOUT,
-                systemctl='systemctl', environ=None, home=None):
+                systemctl='systemctl', environ=None, home=None, inspect=None):
     """Run the post-commit steps from `tree` (whose bin/lanes runs them) -> the record written. `steps` are the phases
     that ran before, [(name, rc)]. The record says `partial` before the first step, so a run killed half-way stays
     `partial`; after the last step (or an interrupt: a SystemExit or KeyboardInterrupt is recorded as the step's rc,
-    then raised again) it says `ok` when every phase and step exited 0 or only warned (WARN_RC), else `partial`."""
+    then raised again) it says `ok` when every phase and step exited 0 or only warned (WARN_RC), else `partial`.
+    `inspect` (default L.containers_info) is how daemon_gone asks docker about the daemon's container."""
     out = sys.stdout if out is None else out
     run = run_step if run is None else run
     steps = list(steps)
@@ -326,6 +385,12 @@ def post_commit(tree, state, log, steps=(), before=None, started=None, out=None,
             steps.append((name, rc, warning, extra))
             print('ok    ' + name if rc == 0 else f"{'WARN' if warning else 'FAIL'}  {name} ({describe(rc, timeout)})",
                   file=out, flush=True)
+
+        def skip(name, reason):
+            # Not run: install-container would exit 1 for it (no such container, no home volume), every run, a
+            # condition the update neither caused nor can mend (DAEMON_SKIP_RC).
+            steps.append((name, DAEMON_SKIP_RC, True, {'outcome': 'skipped', 'reason': reason}))
+            print(f'WARN  {name} (skipped: {reason})', file=out, flush=True)
         try:
             step('daemon-reload', [systemctl, '--user', 'daemon-reload'])
             step('sync', [lanes, 'sync'])
@@ -336,8 +401,16 @@ def post_commit(tree, state, log, steps=(), before=None, started=None, out=None,
                     # `sh`, as the RUNBOOK runs it: a tree whose script lost its mode bit still installs Mermaid. A
                     # tree from before W10 W6 (a rollback's) has no script: nothing to run, no step.
                     step(DOCS_STEP, ['sh', str(Path(tree) / DOCS_SCRIPT)])
-            for container in recorded_containers(state):
+            containers = recorded_containers(state)
+            for container in containers:
                 step('install-container ' + container, [lanes, 'install-container', container])
+            daemon = daemon_container(state, home)
+            if daemon and daemon not in containers:
+                gone = daemon_gone(state, daemon, inspect)
+                if gone:
+                    skip('install-container ' + daemon, gone)
+                else:
+                    step('install-container ' + daemon, [lanes, 'install-container', daemon])
             step('reload-views', [lanes, 'reload-views'])
             step('ensure', [lanes, 'ensure', '--if-layout-changed'])
             finished = True

package/payload/lanes/libexec/users.py

@@ -4,7 +4,7 @@ One JSON file per person under ~/.local/state/lanes/users/ (directory 0700, file
 person owns (members.owner_for decides ownership, as devices/<device>.json records it):
 
     {"version": 1, "login": "anna@example.com", "name": "Anna Berg",
-     "look": {"theme": "light", "color": "256", "glyphs": "ascii"},
+     "look": {"theme": "light", "color": "256", "glyphs": "ascii", "fleet_collapsed": true},
      "seen": {"bw-tools--lanes-zellij": 1791000000.25},
      "workspaces": {"order": ["throttle", "bw-tools"], "hidden": []},
      "lanes": {"pins": ["bw-tools--lanes-zellij"], "hidden": []},
@@ -16,7 +16,8 @@ person owns (members.owner_for decides ownership, as devices/<device>.json recor
     A login whose quoted name would not fit a file name (MAX_STEM) has no profile.
   * Times are epoch seconds. `seen` is DM-LANES-CLIENT-SEEN's {lane id: when it was last opened} for the person (the
     newest MAX_SEEN marks); `look` holds only the keys set, with bin/lanes LOOK_KEYS' values (`notify`/`dim` stay
-    per-device); `notify` holds `quiet_s` only when set; `last_opened` is null until a lane is opened. Lane ids are
+    per-device), and the sidebar's LOOK_FLAGS as JSON booleans (`fleet_collapsed`, the fleet block's `i`, W11);
+    `notify` holds `quiet_s` only when set; `last_opened` is null until a lane is opened. Lane ids are
     L.IDENT (at most MAX_LANE_ID characters), workspace ids L.IDENT at most 64, devices members.device_name, `name`
     one printable line (members._text: no control, format, surrogate, private-use or unassigned character).
   * Readers are tolerant and never raise: an invalid entry is dropped on its own; unknown top-level keys (a newer
@@ -49,7 +50,9 @@ person owns (members.owner_for decides ownership, as devices/<device>.json recor
     (load_all): one written by a desk device within the quiet window is presence, and `notify.quiet_s` is that
     person's own window. `updated_by_device` names the device a change was made AT (a sidebar, `lanes attach`, `lanes
     next|prev`, `lanes here`); the arranging verbs stamp `cli:<command>` and migrate() `cli:migration` instead
-    (writers that are no device, so an admin's verb over SSH is never somebody at a desk: W9 review F3).
+    (writers that are no device, so an admin's verb over SSH is never somebody at a desk: W9 review F3). Since W11
+    (spec 2026-10-11 §3) the sidebar's `i` writes `look.fleet_collapsed` (set_look_flag) and every sidebar of the
+    person folds or unfolds its fleet block from the profile on its next tick (look_flag).
 """
 import copy
 import fcntl
@@ -71,6 +74,13 @@ FIELDS = ('version', 'login', 'name', 'look', 'seen', 'workspaces', 'lanes', 'la
 # bin/lanes LOOK_KEYS' theme/color/glyphs, value for value (test_users pins the equality).
 LOOK = {'theme': ('dark', 'light', 'auto'), 'color': ('truecolor', '256', '16', 'none'),
         'glyphs': ('unicode', 'ascii', 'emoji')}
+# The person's sidebar switches beside LOOK (W11, spec 2026-10-11 §3): JSON booleans in the profile's `look`, written
+# only by a sidebar key (set_look_flag) — never by `lanes attach`, never in a device file, never part of LOOK (so
+# layered_look, device_only, unfolded and migrate's fold never see one). `fleet_collapsed` is the fleet block folded
+# to its one line (`i`); absent is unfolded. A release before W11 drops the key when it normalizes a profile — its
+# writer then stores the profile without it (DEF-1950): a sidebar still running the previous tree during an update
+# unfolds the block for every device of the person once, until the next `i`.
+LOOK_FLAGS = ('fleet_collapsed',)
 MAX_STEM = 200                   # '.' + stem + '.json.' + 8 (L.atomic_write's temp name) stays under NAME_MAX 255
 MAX_LANE_ID = 256                # L.TRACE's cap: a longer lane id cannot be traced either
 MAX_SEEN = 1024                  # newest marks kept; an older mark only re-shows a Done lane until it is opened
@@ -213,6 +223,7 @@ def normalize(document, login=None):
     if isinstance(look, dict):
         profile['look'] = {key: look[key] for key, allowed in LOOK.items() if isinstance(look.get(key), str)
                            and look[key] in allowed}
+        profile['look'].update({key: look[key] for key in LOOK_FLAGS if isinstance(look.get(key), bool)})
     seen = document.get('seen')
     if isinstance(seen, dict):
         profile['seen'] = _bounded({lane: at for lane, at in seen.items() if _valid(check_lane, lane) and _time(at)})
@@ -409,6 +420,23 @@ def update(login, device, fn, now=None, directory=None, timeout=LOCK_S):
         os.close(fd)
 
 
+def look_flag(profile, key):
+    """The LOOK_FLAGS boolean `key` of a normalized profile (read()), False when the profile or the key is absent."""
+    return bool(profile) and profile['look'].get(key) is True
+
+
+def set_look_flag(login, device, key, value, directory=None, timeout=LOCK_S):
+    """Set one LOOK_FLAGS boolean in `login`'s profile look through update() — its lock, its merge, its dropped-write
+    rule (False: the lock was busy within `timeout`, or the profile is not one this release writes). Raises
+    L.LanesError for a key that is no flag or a value that is no bool (a caller's bug, never a person's input)."""
+    if key not in LOOK_FLAGS or not isinstance(value, bool):
+        raise L.LanesError('not a profile look flag')
+
+    def change(profile):
+        profile['look'][key] = value
+    return update(login, device, change, directory=directory, timeout=timeout)
+
+
 # ------------------------------------------------------------------------------------------------------- migration
 
 def _names(directory, suffix):

package/payload/lanes/site/site.example.conf

@@ -13,3 +13,7 @@ LANES_SERVER_NAME=workspace-server.example.ts.net
 LANES_SERVER_USER=workspace
 # Optional public SSH fallback (use only if your server exposes SSH there):
 # LANES_SERVER_PUBLIC=ssh.example.com
+# Optional, read only on the server (its ~/.config/lanes/site.conf): the fleet dashboard the cockpit's host row and
+# `lanes doctor` link to. https only (https://host[:port][/path]); anything else is ignored and doctor says why. Leave
+# it unset until an authenticated Grafana deployment exists — no Lanes command ever writes it.
+# LANES_FLEET_DASHBOARD_URL=https://grafana.example.ts.net/d/fleet

package/payload/manifest.json

@@ -1,8 +1,8 @@
 {
  "name": "@vibelord/lanes",
- "version": "1.3.0",
- "commit": "cf8bfb3df12fb6210350adb6b3e481f29051ffae",
- "digest": "sha256:7e3cce373458d09b77c588dfb98b00777ceda08df504b319bcdf7d26cc3cc206",
+ "version": "1.5.1",
+ "commit": "3b7ac2e84a23ed47f2ab3f404232286c47d3f2e8",
+ "digest": "sha256:1647256dba4c8075b45ba74c973e4ccaf00ae74e2f572f5678c16e7ad1f682bc",
  "executables": [
   "bin/lanes",
   "client/install.sh",
@@ -15,6 +15,7 @@
   "container/lane-mcp",
   "container/lane-run",
   "container/lane-signal",
+  "container/throttle-pulse",
   "holders/exec.sh",
   "holders/ssh.sh",
   "holders/tmux.sh",