@vibelord/lanes 1.1.1 → 1.3.0

package/payload/lanes/install.sh

@@ -4,6 +4,8 @@
 #
 #   ./install.sh                 install or update the client on this machine
 #   ./install.sh --server        install or update the Linux workspace server
+#   ./install.sh --server --update-only   update it: every step after the switch runs whatever the one before it
+#                returned; the run is recorded in ~/.local/state/lanes/update/last.json (exit 0 · 4 · 3 · 1)
 #   ./install.sh --check         verify terminal, SSH path, key and server (changes nothing)
 #   ./install.sh --uninstall     remove what the installer added (your SSH key and ~/Lanes Uploads are kept)
 #
@@ -41,9 +43,14 @@
 # :8443/enrol/) authorizes it — at once for an invite code; without one, on a terminal, the installer offers to ask the
 # site's members and waits up to 10 min (LANES_ENROL_WAIT) for an approval. The client never edits authorized_keys.
 # No service, a refused code, or no code and no terminal: the public key is printed for the admin (exit 3), as before.
+# Run by the npm wrapper with an invite, the installer first asks that service which release the server runs: a newer
+# one than this installer ends the run before anything is installed or redeemed (exit 5), and the wrapper runs the
+# server's release with the same options, which redeems the invite (LANES_NO_SELF_UPDATE=1: never asked).
 #
 # Exit status: 0 ready to use · 3 installed, but this machine's key is not authorized on the server yet ·
 #              4 installed, but not in the tailnet, or the server is not reachable or did not answer in time (busy?) ·
+#              5 nothing installed: the server runs a newer release (only when LANES_WRAPPER_REPLY names the npm
+#                wrapper's hand-over file; the wrapper then runs that release) ·
 #              1 error
 set -eu
 here=$(cd "$(dirname "$0")" && pwd)
@@ -81,7 +88,7 @@ while [ $# -gt 0 ]; do
         --palette) palette=1 ;;
         --no-palette) palette=0 ;;
         --yes|-y) assume_yes=1 ;;
-        -h|--help) sed -n '2,47p' "$0"; exit 0 ;;
+        -h|--help) sed -n '2,54p' "$0"; exit 0 ;;
         *) echo "install.sh: unknown option $1 (see --help)" >&2; exit 1 ;;
     esac
     shift
@@ -1142,7 +1149,7 @@ report_key_taken() {
 # and nobody at a terminal to ask: report_server's exit-3 text, unchanged — except a 409 (the device name or the key is
 # already a member's), which names the re-run that joins instead (report_device_taken, report_key_taken). The code
 # goes in a request body on stdin: never on a command line, in a file or in the output.
-enrol_file=$config/enrol-request enrol_caller= enrol_conflict= enrol_via=
+enrol_file=$config/enrol-request enrol_caller= enrol_conflict= enrol_via= enrol_base= enrol_resolve=
 invite_problem() {   # CODE -> why it is not an invite code for this profile, or nothing. Names the prefix at most.
     ip_bad='not an invite code (letters, digits and dashes, like LN-xxxx-xxxxxxxxxxxx)'
     case "$1" in ''|-*|*-|*--*|*[!A-Za-z0-9-]*) printf '%s' "$ip_bad"; return 0 ;; *-*) ;; *) printf '%s' "$ip_bad"; return 0 ;; esac
@@ -1169,14 +1176,18 @@ json_get() {   # PATH -> the value at that path of $http_body (strings unquoted)
 }
 # -> enrol_base (scheme://host[:port]), enrol_host, enrol_port, enrol_ip (the tailnet address to use when this machine
 # cannot resolve the name: an IPv4 LANES_SERVER_HOST); 1 + enrol_note when there is no service to ask.
-# LANES_ENROL_URL replaces the base (development and tests); the name and address logic stays the same.
+# LANES_ENROL_URL replaces the base (development and tests); the name and address logic stays the same. Called again in
+# the same run (the K3 question before the install, then enrol), it keeps the --resolve the first calls learned for the
+# same base: a name this machine cannot resolve is not tried again (each try costs up to curl's 5 s to connect).
 enrol_target() {
-    enrol_base=${LANES_ENROL_URL:-} enrol_resolve= enrol_note=
+    et_known=$enrol_base
+    enrol_base=${LANES_ENROL_URL:-} enrol_note=
     if [ -z "$enrol_base" ]; then
         if [ -z "$server_name" ]; then enrol_note='this site profile names no LANES_SERVER_NAME (its enrolment service answers under that name)'; return 1; fi
         enrol_base=https://${server_name%.}:8443
     fi
     enrol_base=${enrol_base%/}
+    [ "$enrol_base" = "$et_known" ] || enrol_resolve=
     et_hostport=${enrol_base#*://}
     case "$enrol_base" in http://*|https://*) ;; *) enrol_note='LANES_ENROL_URL is not an http(s) URL'; return 1 ;; esac
     case "$et_hostport" in ''|*/*|*[!A-Za-z0-9.:-]*) enrol_note='LANES_ENROL_URL is not scheme://host[:port]'; return 1 ;; esac
@@ -1289,7 +1300,8 @@ enrol_site() {   # GET /enrol/site -> 0, request_mode and enrol_caller; or 1 and
     # (a server without the service hands /enrol/site to its web client: a page, not this document)
     if ! enrol_json; then enrol_note="no enrolment service at $enrol_base/enrol/ (the answer is not JSON)"; return 1; fi
     # lanes-enrold's /site always says request_mode, true or false: that is what tells it from any other JSON. Its
-    # `version` is the server's Lanes release, not a wire number (wire v1 is additive only, and none is served).
+    # `version` is the server's Lanes release, not a wire number (wire v1 is additive only, and none is served): only
+    # enrol_preflight reads it, to hand an invite over to that release's installer; no admission ever depends on it.
     request_mode=$(json_get /request_mode)
     case "$request_mode" in
         true|false) ;;
@@ -1298,6 +1310,55 @@ enrol_site() {   # GET /enrol/site -> 0, request_mode and enrol_caller; or 1 and
     # The tailnet login the service received (null outside request mode): the owner a request is filed under.
     enrol_caller=$(enrol_clean "$(json_get /caller)")
 }
+# ---- the server's release first (W9 K3, LNS-88) ---------------------------------------------------------------------
+# An invite is redeemed once, so the installer that redeems it should be the server's own release. Run by the npm
+# wrapper (which names a file in LANES_WRAPPER_REPLY) with an invite (--invite or LANES_INVITE), the installer asks the
+# enrolment service which release the server runs — /enrol/site's `version` — BEFORE anything is installed, sent or
+# redeemed. A newer one than this tree's VERSION ends the run: `update-to=<release>` into that file, one line, exit 5.
+# The wrapper then runs `npx --yes @vibelord/lanes@<release>` with the same options (the code moved to LANES_INVITE)
+# and LANES_NO_SELF_UPDATE=1, which skips this question: one hand-over at most. Anything else changes nothing and the
+# install goes on with this tree: no invite; LANES_NO_SELF_UPDATE (any value); a tailnet site this machine is not in
+# yet (one `tailscale status`, no login — the install's own Tailscale step follows); no service or no answer (one
+# bounded call, as enrol_call makes every call); an equal, older or unparseable release on either side. Without the
+# wrapper (a checkout's ./install.sh) a newer server is one line and the install goes on.
+release_key() {   # RELEASE -> "MAJOR MINOR PATCH", nothing for what is no release
+    # The rule `lanes hello` compares by (bin/lanes version_key): major.minor.patch, an optional -/+ suffix that is not
+    # compared, at most 32 characters — and here each number at most 9 digits, so test(1) compares it exactly.
+    case "$1" in ''|*[!A-Za-z0-9.+-]*) return 0 ;; esac
+    [ "${#1}" -le 32 ] || return 0
+    printf '%s\n' "$1" | sed -n 's/^\([0-9]\{1,9\}\)\.\([0-9]\{1,9\}\)\.\([0-9]\{1,9\}\)\([-+][A-Za-z0-9.]\{1,\}\)\{0,1\}$/\1 \2 \3/p'
+}
+release_newer() {   # SERVER MINE -> 0 when both are releases and SERVER's major.minor.patch is the higher, as numbers
+    rn_server=$(release_key "$1") rn_mine=$(release_key "$2")
+    [ -n "$rn_server" ] && [ -n "$rn_mine" ] || return 1
+    # shellcheck disable=SC2086
+    set -- $rn_server $rn_mine                       # (digits only: no glob, no blank inside a number)
+    if [ "$1" -ne "$4" ]; then [ "$1" -gt "$4" ]; return; fi
+    if [ "$2" -ne "$5" ]; then [ "$2" -gt "$5" ]; return; fi
+    [ "$3" -gt "$6" ]
+}
+enrol_preflight() {
+    [ -n "$invite" ] && [ -z "${LANES_NO_SELF_UPDATE:-}" ] || return 0
+    if tailnet_site; then
+        ts=$(tailscale_bin) || return 0
+        tailscale_look
+        [ "$ts_state" = Running ] && [ "$ts_online" = true ] || return 0
+    fi
+    enrol_target && enrol_site || return 0
+    pf_server=$(json_get /version)
+    pf_mine=dev; if [ -r "$here/VERSION" ]; then pf_mine=$(tr -cd 'A-Za-z0-9._+-' < "$here/VERSION"); fi
+    release_newer "$pf_server" "$pf_mine" || return 0
+    if [ -z "${LANES_WRAPPER_REPLY:-}" ]; then
+        say "server runs $pf_server; this installer is $pf_mine — going on with $pf_mine"
+        return 0
+    fi
+    if ! { printf 'update-to=%s\n' "$pf_server" > "$LANES_WRAPPER_REPLY"; } 2>/dev/null; then
+        warn "server runs $pf_server; this installer is $pf_mine, and the npm wrapper's hand-over file cannot be written — going on with $pf_mine"
+        return 0
+    fi
+    say "server runs $pf_server: fetching that installer first (this one is $pf_mine; nothing is installed yet, and the invite is kept for it)"
+    exit 5
+}
 enrol_key() {   # -> enrol_pubkey "ssh-ed25519 <base64>" (enrold writes its own comment); 1, said, for any other key
     enrol_pubkey= kt= kb=
     if [ -r "$key.pub" ]; then read -r kt kb _ < "$key.pub" || :; fi
@@ -1451,7 +1512,7 @@ enrol() {
 do_install() {
     command -v ssh >/dev/null 2>&1 || die 'OpenSSH (ssh) is required'
     case "$os" in Darwin|Linux) ;; *) die "unsupported system: $os (macOS and Linux only)" ;; esac
-    resolve_options; load_site; check_invite; src=$here/client
+    resolve_options; load_site; check_invite; enrol_preflight; src=$here/client
     head_ "lanes client $(cat "$here/VERSION" 2>/dev/null || echo dev) -> $server_user@$server_alias"
     choose_device; choose_key; ensure_key
     install_client; src=$target
@@ -1488,7 +1549,7 @@ do_install() {
             say 'Open the window:   lanes-window          (Omarchy: Super+Shift+L · macOS: the Lanes app)'
             say 'In any terminal:   lanes-launch          one lane only: lanes-launch lane <id> · list: lanes-launch ls'
             say 'Phone or browser:  lanes-launch web phone · lanes-launch web laptop   (in your own terminal: a login token)'
-            say 'Keys:  Ctrl-Alt-←/→ board · Ctrl-Alt-↑/↓ lane · Ctrl-Alt-/ find · Ctrl-Alt-u upload box · close the window to detach'
+            say 'Keys:  Ctrl-Alt-←/→ board · Ctrl-Alt-↑/↓ lane · Ctrl-Alt-/ find · Ctrl-Alt-u upload box · Ctrl-Alt-l sidebar · close the window to detach'
             exit 0 ;;
         unauthorized) exit 3 ;;
         *) exit 4 ;;

package/payload/lanes/libexec/agent_state.py

@@ -8,7 +8,8 @@ braille spinner while working, and rings BEL on turn completion. Claude's title
 
 The agent{} status vocabulary is fixed here and reused by statusd, the sidebar, the hook sidecar and the phone:
 working | needs_input | needs_approval | done | errored | shell | idle. It is a NEW key beside status.json's
-six-word `state`, never a replacement for it.
+six-word `state`, never a replacement for it. So are the attention SECTION each word belongs to and its RANK, and
+`settle`, the debounce statusd applies between `merge`'s verdict and what it publishes (cockpit v3 S1).
 
 Two stale-signal traps, both MEASURED 2026-10-04 on this host: (1) a Claude session file outlives its pid, and pids
 wrap (pid_max 4194304, live pids already ~2.3M), so a recycled pid would resurrect a dead session — every file
@@ -37,6 +38,15 @@ SHELL_TITLES = {'', 'work', 'bash', 'sh', 'zsh', 'fish'}
 STATUS_FROM_CLAUDE = {'busy': 'working', 'idle': 'needs_input', 'shell': 'shell', 'waiting': 'needs_input'}
 STATUSES = ('working', 'needs_input', 'needs_approval', 'done', 'errored', 'shell', 'idle')
 SHELL_COMMANDS = {'bash', 'sh', 'dash', 'zsh', 'fish', 'ksh', 'tcsh', 'csh'}
+# The attention section each status belongs to (None = the workspace's other lanes) and how urgent a section is: the
+# ONE table statusd's `settle` and the sidebar's sections (`sidebar.SECTION_OF`, its ATTENTION order) read.
+SECTION = {'needs_approval': 'needs', 'errored': 'needs', 'needs_input': 'needs', 'working': 'working', 'done': 'done',
+           'shell': None, 'idle': None}
+RANK = {'needs': 3, 'working': 2, 'done': 1, None: 0}
+# Seconds a LOWER-ranked word must hold before the published status leaves a section, keyed by the section LEFT.
+# Entering a higher section never waits. GONE_DWELL: seconds without any agent signal before agent{} is dropped.
+DWELL = {'needs': 8, 'working': 5, 'done': 5, None: 0}
+GONE_DWELL = 5
 
 
 def pane_has_child(proc_root, pid):
@@ -244,3 +254,66 @@ def merge(pane_row, claude_by_pane, sidecar):
             title['since'] = 0
         return title
     return None
+
+
+def _stamp(value):
+    """A usable epoch second from a published or source field, or None (absent, bool, zero, negative, not a number)."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or value <= 0:
+        return None
+    return int(value)
+
+
+def settle(prev, raw, now):
+    """The agent{} statusd publishes for one lane this cycle: `merge`'s verdict `raw` debounced against `prev`, the
+    agent{} it published last cycle (statusd's previous payload — status.json itself after a restart), at `now` on
+    statusd's clock. None = publish no agent key. Pure; neither input is mutated.
+
+    Until cockpit v3 (plan context item 4, read in the code 2026-10-06) statusd published `merge`'s word every 3 s
+    cycle with no hysteresis, so a lane whose signal flips (a turn ending and restarting, a dialog opened and closed, a
+    Codex title losing its spinner for a frame) moved between the sidebar's sections every cycle, and its `since`
+    restarted on every flip — for a Codex lane read from its title, on every output (`window_activity`). Rules (S1,
+    LNS-59), by SECTION and RANK:
+
+      * higher section than the one published: publish now (a question or an approval is never delayed);
+      * same section: publish now, `stable_since` kept (needs_input -> needs_approval changes only the urgency);
+      * lower section: publish only once the raw word has held for DWELL[section left] — `now - raw_since`;
+      * no agent at all: the published agent{} stays until GONE_DWELL has passed, then the key goes.
+
+    Published keys: `merge`'s own (harness, name, session_id, pid, source, event) from the verdict that was PUBLISHED —
+    a held status keeps the dict it was published with — plus `status` (the debounced word), `since` (when that status
+    began: the source's own start, never later than the cycle that first saw it, and kept while the status is
+    unchanged, so a moving source stamp is no longer a clock), `raw_status` (`merge`'s word this cycle, None while the
+    agent is gone), `raw_since` (statusd's clock when that word was first seen; reset only when it differs from the
+    previous `raw_status`, never a source timestamp) and `stable_since` (statusd's clock when the lane entered the
+    section it is published in). All stamps are integer seconds, so a steady lane publishes byte-identically and
+    status.json is not rewritten. A `prev` that is not an agent{} (a zmx row's lane-run record, an unknown word) is no
+    previous cycle; one written before these keys existed is adopted with `raw_since`/`stable_since` = `now`."""
+    now = int(now)
+    if not (isinstance(raw, dict) and raw.get('status') in STATUSES):
+        raw = None
+    if not (isinstance(prev, dict) and prev.get('status') in STATUSES):
+        prev = None
+    if prev is None:
+        return None if raw is None else _published(raw, now, now)
+    word = raw['status'] if raw else None
+    last = prev['raw_status'] if 'raw_status' in prev else prev['status']   # a pre-v3 entry: its status
+    raw_since = (_stamp(prev.get('raw_since')) if word == last else None) or now
+    stable = _stamp(prev.get('stable_since')) or now
+    held = dict(prev, raw_status=word, raw_since=raw_since, stable_since=stable)
+    if raw is None:
+        return None if now - raw_since >= GONE_DWELL else held
+    old, new = SECTION[prev['status']], SECTION[word]
+    if new == old:
+        kept = _stamp(prev.get('since')) if word == prev['status'] else None
+        return dict(_published(raw, raw_since, stable), since=kept) if kept else _published(raw, raw_since, stable)
+    if RANK[new] > RANK[old] or now - raw_since >= DWELL[old]:
+        return _published(raw, raw_since, now)
+    return held
+
+
+def _published(raw, raw_since, stable_since):
+    """`raw` as published: its `since` the start of the status (the source's, capped at `raw_since`, the cycle that
+    first saw the word), then the three settle keys."""
+    source = _stamp(raw.get('since'))
+    return dict(raw, since=min(source, raw_since) if source else raw_since, raw_status=raw['status'],
+                raw_since=raw_since, stable_since=stable_since)

package/payload/lanes/libexec/cursor_sync.py

@@ -9,6 +9,7 @@ The repository's `.vscode/terminals.json` stays the source of truth for WHICH la
     view shows the lane);
   * the ORIGINAL command and the exact binding are preserved next to it in a top-level `lanes` block, which the
     extension and Throttle ignore:  lanes.terminals[<name>] = {id, holder, tmux{socketName,sessionName}, create}.
+    An entry's optional `displayName` (the container's display layer for the lane, LNS-33) is carried as is.
 
 Text is edited minimally (command strings replaced in place, the `lanes` block inserted before the final brace) so
 git diffs stay small. Dry-run by default: prints a unified diff. `--write` applies (with a timestamped backup).
@@ -179,6 +180,11 @@ def normalized_text(text, lanes_by_name, canonicalize=None):
                     entry.pop('create', None)
                     entry['create'] = recipe
                     entry['createPrevious'] = create
+        if 'displayName' in previous:
+            # LNS-33: the container's display layer (lanes_lib._workspace_lanes reads it; the host manifest's
+            # displayNames win over it). Carried verbatim and last, never dropped: this tool rebuilds the entry from
+            # the registry and validates nothing it does not own — the reader ignores a value that is no lane name.
+            entry['displayName'] = previous['displayName']
         block['terminals'][term['name']] = entry
         commands[term['name']] = ENTRY + lane['id']
     # Nothing to do: leave the file byte-identical (never reformat somebody else's JSON).

package/payload/lanes/libexec/device_sync.py

@@ -1,4 +1,13 @@
-"""Reconcile catalog tabs without switching focus or touching persistent agents."""
+"""Reconcile catalog tabs without switching focus or touching persistent agents.
+
+The one tab this ever closes (cockpit v3 R4, LNS-77) is one whose panes IDENTIFY a workspace the owner's profile hides
+(`hidden`): its sidebar and view.sh panes are viewers — the lanes they show live in containers, so closing the tab loses
+nothing, and the workspace comes back as a new tab when it is shown again. A tab that only carries such a title, an
+unmanaged tab, and every other identity are left open. Such a close never leaves the device without a workspace tab:
+it waits while the hidden boards' tabs are the only workspace tabs the device HAS — counted over the tabs that exist,
+not the specs, because a board added while no client was attached has no tab yet (W9 review F2) — and a reconcile
+whose specs want no workspace at all is refused. Closing the tab a client is looking at moves that client to a
+neighbouring tab (the person hid it)."""
 import fcntl
 import json
 import shlex
@@ -28,7 +37,9 @@ def observe(device, call):
 
 
 def identities(device, tabs, panes, registry, mobile):
-    """Read workspace IDs from the launched commands, independent of tab labels."""
+    """Read workspace IDs from the launched commands, independent of tab labels — and of the tree path: a tree file
+    is matched by its suffix (lanes_lib.tree_file_at), so a pane started from a `pkg/<version>` layout written before
+    W9 U1, from one written through the `current` link since, or from a checkout keeps its identity across updates."""
     by_tab = {}
     for pane in panes:
         if pane.get('is_plugin'):
@@ -38,10 +49,10 @@ def identities(device, tabs, panes, registry, mobile):
         except ValueError:
             continue
         for script in ('sidebar', 'view.sh'):
-            path = str(L.REPO / 'libexec' / script)
-            if path not in args:
+            at = L.tree_file_at(args, 'libexec/' + script)
+            if at is None:
                 continue
-            tail = args[args.index(path) + 1:]
+            tail = args[at + 1:]
             if len(tail) < 2 or tail[0] != device:
                 continue
             workspace = tail[1]
@@ -51,9 +62,9 @@ def identities(device, tabs, panes, registry, mobile):
                 role = 'picker' if mobile and script == 'sidebar' else 'view'
                 key = f'workspace/{workspace}/{role}'
             by_tab.setdefault(pane['tab_id'], set()).add(key)
-        holder = str(L.REPO / 'holders/ssh.sh')
-        if holder in args:
-            tail = args[args.index(holder) + 1:]
+        at = L.tree_file_at(args, 'holders/ssh.sh')
+        if at is not None:
+            tail = args[at + 1:]
             for workspace in registry.get('ssh_workspaces', []):
                 if (len(tail) == 3 and tail[:2] == [workspace['host'], workspace['command']]
                         and any(pane['id'] == tail[2] for pane in workspace['panes'])):
@@ -72,7 +83,16 @@ def identities(device, tabs, panes, registry, mobile):
     return result
 
 
-def reconcile(device, registry, specs, mobile, call):
+def reconcile(device, registry, specs, mobile, call, hidden=()):
+    """Make the device's tabs the `specs` (bin/lanes tab_specs): add each missing one (only while a client is attached),
+    rename a changed title, order them; close the tab of each workspace id in `hidden` (the boards the owner's profile
+    hides, cockpit v3 R4) whose identity is `workspace/<id>/…` and that no spec wants — an unknown id is ignored. ->
+    the changes made, as words. Two guards keep a workspace tab on the device:
+      * specs that want no workspace at all with such a tab to close: refused (L.LanesError, before any change);
+      * no workspace tab the device has would stay open — every EXISTING `workspace/…` tab is one to close, the
+        shown boards having none yet (one added while no client was attached, W9 review F2): nothing is closed and
+        the words say so (`kept <titles> open although hidden: …`); the rest runs — the missing tabs are added
+        once a client is attached — and a later reconcile, counting again, closes them."""
     lock = L.STATE / 'locks' / f'device-sync.{device}.lock'
     lock.parent.mkdir(parents=True, exist_ok=True)
     with lock.open('a') as handle:
@@ -88,6 +108,22 @@ def reconcile(device, registry, specs, mobile, call):
                 raise L.LanesError(f'{device}: {args[0]} failed: {error or "no answer"}')
             return output
 
+        keys, hidden = {spec['key'] for spec in specs}, set(hidden)
+        doomed = [tab for key, tab in known.items()
+                  if key.startswith('workspace/') and key.split('/')[1] in hidden and key not in keys]
+        if doomed and not any(key.startswith('workspace/') for key in keys):
+            raise L.LanesError(f'{device}: closing every workspace tab is refused (one workspace stays shown); '
+                               'no tab was closed')
+        if doomed and len([key for key in known if key.startswith('workspace/')]) - len(doomed) == 0:
+            them, they = ('it', 'it closes') if len(doomed) == 1 else ('them', 'they close')
+            changes.append(f"kept {', '.join(tab['name'] for tab in doomed)} open although hidden: no other workspace "
+                           f'has a tab yet (closing {them} would leave none); {they} once a shown workspace has one')
+            doomed = []
+        for tab in doomed:
+            action(['close-tab', '--tab-id', str(tab['tab_id'])])
+            tabs = [t for t in tabs if t['tab_id'] != tab['tab_id']]
+            changes.append('closed ' + tab['name'])
+
         for spec in specs:
             tab = known.get(spec['key'])
             if tab is None:
@@ -115,7 +151,8 @@ def reconcile(device, registry, specs, mobile, call):
             wanted.append(tab['tab_id'])
 
         # Sort managed tabs by adjacent moves using stable IDs. Each observation
-        # must answer. Unmanaged tabs remain open; no close/rebuild/focus action exists.
+        # must answer. Unmanaged tabs remain open; no rebuild/focus action exists, and the
+        # only close is a hidden workspace's identified tab above.
         for position, tab_id in enumerate(wanted):
             for _ in range(len(tabs) + 1):
                 rc, output, error = call(['-s', device, 'action', 'list-tabs', '--json'], 20)