@vibelord/lanes 1.0.0 → 1.0.2

package/payload/lanes/libexec/sidebar.py

@@ -5,10 +5,18 @@ Shows one workspace's lanes with color, icon and live status. Selecting a lane w
 target file and signals the viewport supervisor; the zellij layout is never touched.
 Fully usable from the keyboard (touch/mouse is a bonus):
   ↑/↓ j/k move · Enter/→/Space open · J/K open next/previous lane · / filter · Esc clear · g/G · r reload
-  2 / 3 open the lane under the cursor in the 2nd / 3rd viewport (wide view sessions)
-Upload box (bottom): click it or press U (Ctrl-Alt-u from anywhere), then DROP FILES anywhere on the window. A
-terminal delivers a drop as a paste of the LOCAL path into the focused pane, so the box must have focus first; the
-file itself is then sent by the upload helper on your machine (it only reads folders you allowed there).
+  2 / 3 open the lane under the cursor in the 2nd / 3rd viewport (wide view sessions) · x / × close (asks y/n)
+  ? shows every key in the body until the next key · Tab / Shift-Tab open the next / previous lane that needs you
+Attention first: lanes whose agent needs you, is working, or finished unseen sort into sections above the rest; the
+agent glyph sits in column 2, and every row carries an age (agent `since`, else last output). The cursor is a LANE:
+when a lane changes section the cursor goes with it. The pane title (OSC 2) carries the header counts, and a lane that
+starts needing you raises one desktop notification (OSC 9), both inside the frame's one write — no fork.
+Upload strip (one row above the footer): click it or press U (Ctrl-Alt-u from anywhere), then DROP FILES anywhere
+on the window. A terminal delivers a drop as a paste of the LOCAL path into the focused pane, so the strip must have
+focus first; the file itself is then sent by the upload helper on your machine (it only reads folders you allowed
+there). Below it, when there is room, the strip row: the fleet economy line from the opt-in economy.json
+(`$8.5k/16k 53% · F2 S1 · spill 76%`), else which OTHER workspaces need you (`◆1 Worlds`). Column 34 of a lane row is
+one tail cell by priority: stale `?` > starving ⚠ > downgraded ↓ > mostly paid `$`.
 Truthful under load: a lane statusd could not observe keeps its last glyph, dimmed, with a `?`; the footer line warns
 when the host is under pressure or statusd has fallen behind (age of $STATE/health, measured with our own clock).
 Run via libexec/sidebar (a loop), so it never leaves its pane empty.
@@ -23,6 +31,7 @@ import subprocess
 import sys
 import termios
 import time
+from operator import itemgetter
 from pathlib import Path
 import tty
 import unicodedata
@@ -30,12 +39,125 @@ import unicodedata
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import lanes_lib as L  # noqa: E402
 import session_actions as A  # noqa: E402
+import registrations as R  # noqa: E402
+import tokens  # noqa: E402
 
 STATE = os.environ.get('LANES_STATE') or os.path.expanduser('~/.local/state/lanes')
+# What the harness in a lane is doing (statusd's additive `agent{}`, Task 4/5 vocabulary): `key -> (unicode, ascii,
+# tone)` from the one token source, drawn in column 2 (spec §3). A SEPARATE dict: GLYPHS' keys stay statusd's words.
+AGENT_GLYPHS = tokens.AGENT_GLYPHS
+# The attention queue (spec §4.4): (section key, title, the agent status whose glyph heads the section, members in
+# their order of urgency). Needs you = a blocking prompt, a failure, a finished turn waiting for a prompt.
+ATTENTION = (('needs', 'Needs you', 'needs_approval', ('needs_approval', 'errored', 'needs_input')),
+             ('working', 'Working', 'working', ('working',)),
+             ('done', 'Done', 'done', ('done',)))
+HEADER_COUNTS = ('needs_approval', 'needs_input', 'working', 'done')   # the header's glyph counts (spec §4.3)
+SECTION_OF = {status: key for key, _title, _glyph, members in ATTENTION for status in members}
+NEEDS_RANK = {status: rank for rank, status in enumerate(ATTENTION[0][3])}
+INF = float('inf')
+# Tones by role name. Each Sidebar resolves its own table per device (`apply_look`, spec §2.4); this 16-colour table
+# (the user's own palette) is only the class default for a Sidebar built without `__init__`.
+TONE16 = tokens.sgr_table('16', 'dark')
+THEME_GRACE = 0.3   # seconds to wait for the OSC 11 answer before painting dark (spec §2.4)
+OSC11_QUERY = '\033]11;?\033\\'   # "what is your background colour?", written once at start (start_bytes)
+# One complete OSC sequence (ST- or BEL-terminated). handle() strips these before its key loop: a reply is never an Esc.
+OSC = re.compile(r'\033\]([^\033\007]*)(?:\033\\|\007)')
+# The only incomplete OSC worth holding across reads: a prefix of the OSC 11 answer this sidebar asked for. Anything
+# else (an operator's Esc then `]`) is input as before, so a held tail can never swallow later keys.
+# Agent statuses that put a lane in Needs you: Tab cycles them, and entering one raises one OSC 9 (spec §4.5, §4.9).
+NEEDS_YOU = ATTENTION[0][3]
+# What may not ride inside an OSC string: C0, DEL and C1 (an ESC or BEL would end it and start a sequence of its own).
+OSC_UNSAFE = re.compile(r'[\x00-\x1f\x7f-\x9f]')
+OSC_TEXT_MAX = 200   # characters of one title / notification payload
+OSC11_PREFIX = re.compile(r'\033\](?:1(?:1(?:;(?:r(?:g(?:b(?::[0-9A-Fa-f/]{0,14})?)?)?)?)?)?)?(?:\033)?$')
+
+
+def age3(seconds):
+    """Three cells, right-aligned: how long. None/negative = nothing known = three blanks (spec §4.2)."""
+    if seconds is None or seconds < 0:
+        return '   '
+    if seconds < 60:
+        return f'{int(seconds):2d}s'
+    if seconds < 3600:
+        return f'{int(seconds // 60):2d}m'
+    if seconds < 86400:
+        return f'{int(seconds // 3600):2d}h'
+    return f'{min(99, int(seconds // 86400)):2d}d'
+
+
+def osc_text(text):
+    """A string fit for an OSC payload: control characters dropped, at most OSC_TEXT_MAX characters (spec §4.9)."""
+    return OSC_UNSAFE.sub('', str(text))[:OSC_TEXT_MAX]
+
+
+# ----------------------------------------------------------------- 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
+# 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
+# Tier letters, in strip order (spec §3/§10: the strip row and the Task 15 preview only — never a row at 36 cols).
+# Plain letters, not table glyphs: the same in every glyph mode. The model name decides; an unknown model has none.
+TIERS = (('fable', 'F'), ('opus', 'O'), ('sonnet', 'S'), ('haiku', 'H'), ('gpt', 'G'))
+SPILL_QUIET = ('closed',)      # Throttle `pressure.phase` words (verbatim, DM-LANES-ECONOMY) that are not news
+
+
+def number(value):
+    """value when it is a real number (bool is not), else None: economy.json is a projection, never trusted blindly."""
+    return value if isinstance(value, (int, float)) and not isinstance(value, bool) else None
+
+
+def starving(lane_status, lane_econ):
+    """True when a lane is producing output (`state == 'active'`) while the proxy says it is not being served: no
+    request for more than STARVING_AGE s, or a 429 in the daemon's recent-request ring (spec §2.3, plan Task 12).
+    `last_request_age_s` is the poller's own measurement at economy.json's `at`; it is NOT aged by the sidebar's clock,
+    so a stopped poller freezes the cell instead of turning every active lane into ⚠ — and tail_for() paints a frozen
+    figure (a lane record with `stale: true`, or a document past ECONOMY_STALE) ink-dim, not as a live alarm."""
+    if not lane_econ or (lane_status or {}).get('state') != 'active':
+        return False
+    age, refused = number(lane_econ.get('last_request_age_s')), number(lane_econ.get('status_429'))
+    return (age is not None and age > STARVING_AGE) or (refused is not None and refused > 0)
+
+
+def compact_usd(value):
+    """Dollars in at most five cells for the strip: 950, 8.5k, 16k, 123k, 1.2M (no trailing `.0`)."""
+    value = max(0.0, float(value))
+    if value < 999.5:
+        return f'{value:.0f}'
+    scaled, suffix = (value / 1e3, 'k') if value < 999_500 else (value / 1e6, 'M')
+    text = f'{scaled:.1f}' if scaled < 9.95 else f'{scaled:.0f}'
+    return text.removesuffix('.0') + suffix
+
+
+def tier_of(model):
+    """The tier letter of a model id (`claude-fable-5-1` -> `F`), or '' when no tier is known."""
+    model = model.lower() if isinstance(model, str) else ''
+    return next((letter for word, letter in TIERS if word in model), '')
+
+
+def load_economy(doc):
+    """economy.json as the sidebar uses it: the document when it is a schema-1 object, else {} (a document of another
+    version, or not an object, is ignored rather than half-read). `fleet` and `lanes` are always dicts afterwards."""
+    if not isinstance(doc, dict) or doc.get('v') != ECONOMY_SCHEMA:
+        return {}
+    fleet, lanes = doc.get('fleet'), doc.get('lanes')
+    return dict(doc, fleet=fleet if isinstance(fleet, dict) else {},
+                lanes={k: v for k, v in lanes.items() if isinstance(v, dict)} if isinstance(lanes, dict) else {})
+
+
 # The six words statusd publishes (alignment contract A3) and the helper word for an `exec` lane. There is no
-# seventh: statusd's zmx observer used to publish `idle`, which no other surface knew (DEF-823).
-GLYPHS = {'active': ('●', '32'), 'quiet': ('○', '2'), 'missing': ('✖', '31'), 'absent': ('–', '2'),
-          'dead': ('!', '33'), 'helper': ('·', '2'), 'unknown': ('?', '2')}
+# seventh: statusd's zmx observer used to publish `idle`, which no other surface knew (DEF-823). Values are
+# (unicode, ascii, tone) from the one token source — the tone is a role name from tokens.ROLES, never an SGR code:
+# the device's mode decides the bytes (`apply_look`). The keys stay pinned by the vocabulary gate.
+GLYPHS = tokens.GLYPHS
+GLYPHS_ASCII = {key: value[1] for key, value in GLYPHS.items()}
+MARKS = tokens.MARKS
+ECONOMY_TAIL = tokens.ECONOMY_TAIL
+MOBILE_AGENT_LABELS = tokens.MOBILE_AGENT_LABELS
+# The phone header's words after each glyph count (spec §4.10): ` ◆1 need approval · ◇2 need you · ▸6 working`.
+# Keyed by HEADER_COUNTS, the statuses the desktop header counts.
+MOBILE_COUNT_WORDS = {'needs_approval': 'need approval', 'needs_input': 'need you', 'working': 'working', 'done': 'done'}
 # The phone sidebar spells the same six words (plus `helper`) in full. The keys are GLYPHS's keys and the
 # vocabulary gate pins that: this map kept `idle` for a whole release after DEF-823 removed it from GLYPHS,
 # because the gate read GLYPHS alone and the map was a literal buried inside `render_mobile` (DEF-983).
@@ -44,6 +166,44 @@ MOBILE_LABELS = {'active': 'Active', 'quiet': 'Quiet', 'missing': 'Container off
                  'unknown': 'Checking status'}
 
 
+def resolve_modes(env, meta):
+    """(color, theme, glyphs) from the device file first, then the environment, then the defaults of spec §2.4.
+    Pure; an unknown value falls back to the default rather than raising (a hand-edited file must not kill a pane)."""
+    meta = meta if isinstance(meta, dict) else {}
+    if env.get('NO_COLOR'):
+        color = 'none'
+    else:
+        color = env.get('LANES_COLOR') or ('truecolor' if env.get('COLORTERM') in ('truecolor', '24bit') else '16')
+    color = meta.get('color') or color
+    theme = meta.get('theme') or env.get('LANES_THEME') or 'auto'
+    locale = [env.get(k) or '' for k in ('LC_ALL', 'LC_CTYPE', 'LANG')]
+    utf8 = any('UTF-8' in value.upper() or 'UTF8' in value.upper() for value in locale)
+    glyphs = meta.get('glyphs') or env.get('LANES_GLYPHS') or ('unicode' if utf8 or not any(locale) else 'ascii')
+    if color not in ('truecolor', '16', 'none'):
+        color = '16'
+    if theme not in ('dark', 'light', 'auto'):
+        theme = 'auto'
+    if glyphs not in ('unicode', 'ascii', 'emoji'):
+        glyphs = 'unicode'
+    return color, theme, glyphs
+
+
+def parse_osc11(body):
+    """'11;rgb:RRRR/GGGG/BBBB' (1- to 4-digit hex components) -> 'dark'|'light' by relative luminance (< 0.5 dark);
+    anything else -> None."""
+    if not body.startswith('11;rgb:'):
+        return None
+    parts = body[7:].split('/')
+    if len(parts) != 3 or not all(1 <= len(p) <= 4 for p in parts):
+        return None
+    try:
+        channels = [int(p, 16) / (16 ** len(p) - 1) for p in parts]
+    except ValueError:
+        return None
+    lin = [c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4 for c in channels]
+    return 'light' if 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2] >= 0.5 else 'dark'
+
+
 def viewer_mark(status):
     """The mark after a lane's name when other sessions view it: one dot per viewer, at most three."""
     count = int((status or {}).get('viewers') or 0)
@@ -66,6 +226,8 @@ def mtime(path):
 
 
 def cell_width(text):
+    if text.isascii():    # every ASCII character is one cell here (none combines, none is wide): the common case
+        return len(text)
     width = 0
     for ch in text:
         if unicodedata.combining(ch) or ch in '‍️':
@@ -75,6 +237,9 @@ def cell_width(text):
 
 
 def clip(text, width):
+    if text.isascii():    # same answer as the walk below, without it (spec §4.11: one clip per row, cheap)
+        text = text[:max(0, width)]
+        return text, len(text)
     out, used = [], 0
     for ch in text:
         w = cell_width(ch)
@@ -88,14 +253,16 @@ def clip(text, width):
 HEALTH_STALE = 30   # seconds; statusd rewrites $STATE/health every cycle, at most ~12 s apart when it slows itself down
 
 
-def health_banner(health, written, now):
+def health_banner(health, written, now, warning='⚠', sep=' · '):
     """The footer warning; '' = nothing to say. `health` = L.read_health(), `written` = the file's mtime in seconds
     (0 = no such file: a statusd from before it existed — nothing is known, so nothing is claimed).
     statusd is what freezes on a thrashing host, so the age is measured HERE, with our clock, from the file's mtime.
-    The age comes first: a sidebar is 36 cells wide, and "what you see is N minutes old" must survive the clipping."""
+    The age comes first: a sidebar is 36 cells wide, and "what you see is N minutes old" must survive the clipping.
+    `warning` and `sep` are the device's `warning` / ` sep ` marks (spec §4.6(a)); the defaults are the unicode ones,
+    so a three-argument call reads exactly as before."""
     if os.path.exists(os.path.join(STATE, 'flags', 'sockets-lost')):
         # Short, and first: it explains every "not running" on the screen. The fix is one command on the server.
-        return '⚠ lane sockets deleted — lanes run; on the server: lanes sockets repair'
+        return f'{warning} lane sockets deleted{sep}lanes run; on the server: lanes sockets repair'
     if not written:
         return ''
     parts, age = [], int(now - written)
@@ -104,18 +271,76 @@ def health_banner(health, written, now):
     level = health.get('level', 'ok')
     if level != 'ok':
         parts.append('host under memory pressure' if level == 'critical' else 'host busy')
-    return '⚠ ' + ' · '.join(parts) if parts else ''
+    return warning + ' ' + sep.join(parts) if parts else ''
 
 
 SLOTS = ['main', 'b', 'c']
-BOX_ROWS = 4
+BOX_ROWS = 1    # the upload strip (spec §4.6(d)); it was a four-row box
+# The `?` key sheet (spec §4.7): (key, its seven-bit twin, action), one line per key handle() accepts. A line is
+# `  {key:<10}{action}`: the key field is 10 cells and an action at most 23, so a line is at most 35 cells — the
+# sidebar's row width with column 36 never written. `Tab`/`Shift-Tab` are Task 25's keys.
+KEY_SHEET = (('↑ ↓ j k', 'Up Dn j k', 'move'), ('⏎ → Space', 'Enter Spc', 'open the cursor lane'),
+             ('J K', 'J K', 'open next / prev lane'), ('Tab', 'Tab', 'next lane needing you'),
+             ('Shift-Tab', 'Shift-Tab', 'prev lane needing you'), ('2 3', '2 3', 'show in viewport 2 / 3'),
+             ('/', '/', 'find a lane'), ('Esc', 'Esc', 'clear / cancel'), ('g G', 'g G', 'first / last'),
+             ('+', '+', 'new shell'), ('a', 'a', 'add to a workspace'), ('x', 'x', 'close (asks y/n)'),
+             ('R', 'R', 'rename'), ('P', 'P', 'register a session'), ('U', 'U', 'arm the upload strip'),
+             ('r', 'r', 'reload'), ('?', '?', 'this sheet'))
 PASTE_START, PASTE_END = '\033[200~', '\033[201~'
 
 
+def key_length(data, i):
+    """How many characters of `data` from `i` make ONE key: a plain character, a bare Esc, an SS3 key (`\\033OA`), an
+    SGR mouse report (`\\033[<b;x;yM`/`m`) or any other CSI up to its final byte (`\\033[A`, `\\033[5~`). Esc followed
+    by anything else is a bare Esc, as handle() reads it. An unterminated sequence runs to the end of the read, which
+    is how handle() itself drops one."""
+    if data[i] != '\033':
+        return 1
+    rest = data[i + 1:]
+    if rest.startswith('[<'):
+        end = next((k for k, c in enumerate(rest) if c in 'Mm'), -1)
+    elif rest[:1] == '[':
+        end = next((k for k, c in enumerate(rest[1:], 1) if '@' <= c <= '~'), -1)
+    elif rest[:1] == 'O' and len(rest) > 1:
+        return 3
+    else:
+        return 1
+    return len(data) - i if end < 0 else end + 2
+
+
 class Sidebar:
+    # Class-level defaults for the registration state, so a Sidebar built without `__init__` (the
+    # alignment gate constructs one with `__new__` and sets only the fields its rule needs) reads the
+    # 'no registration in progress' shape rather than raising; `__init__` assigns the live values.
+    registration, registration_choices, workspaces = None, (), ()
+    renaming, rename_value, rename_entry = False, '', None
+    promoting, promote_entry = False, None
+    attach_only = False
+    confirming = None           # the entry `x` / `×` asked to close; `y` closes it, any other key cancels
+    seen = {}                   # read-only default; mark_seen() always assigns a fresh dict
+    tone = TONE16
+    glyphs = tokens.glyph_set('unicode')
+    color, glyph_mode, variant = '16', 'unicode', 'dark'
+    theme_pending, theme_deadline, osc_buffer = False, 0.0, ''
+    last_visible = ()           # the list visible() last returned: the one `self.cursor` indexes
+    economy = {}                # read-only default; reload() assigns the loaded economy.json (load_economy)
+    economy_tiers = ''          # this workspace's tier mix from economy.json, `F2 S1` (reload)
+    more_row = 0                # the 1-based screen row of `⋮ N more` (render), 0 = the list fits
+    showing_keys = False        # `?` replaces the body with the key sheet until the next key (spec §4.7)
+    fleet = {}                  # other workspaces' title -> {needs_approval: n, needs_input: n} (reload)
+    board_titles = {}           # workspace id -> title, from the registry (reload)
+    strip_row = False           # render(): the strip row (economy or fleet attention) is drawn this frame
+    last_counts = ''            # the header counts the last OSC 2 title carried ('' = none sent; spec §4.9)
+    notified = {}               # read-only default; __init__ assigns: lane id -> the needs-you status already notified
+
     def __init__(self, device, workspace, slot='main', viewports='1'):
         self.device, self.workspace, self.slot = device, workspace, slot
-        self.mobile = bool((read_json(os.path.join(STATE, 'devices', device + '.json')) or {}).get('mobile'))
+        # devices/<device>.json: `mobile` is read once here; the look keys (`color`, `theme`, `glyphs`) are re-read
+        # whenever the file changes (reload()'s stamp), so `lanes attach DEVICE --ascii` reaches a RUNNING sidebar.
+        self.look_path = os.path.join(STATE, 'devices', device + '.json')
+        meta = read_json(self.look_path)
+        meta = meta if isinstance(meta, dict) else {}
+        self.mobile = bool(meta.get('mobile'))
         self.mobile_owner, self.mobile_titles, self.next_mobile_poll = False, {}, 0
         try:
             self.viewports = max(1, min(len(SLOTS), int(viewports)))
@@ -126,16 +351,35 @@ class Sidebar:
         self.pid_file = self.slot_file(slot, 'pid')
         self.registry_path = os.path.join(STATE, 'registry.json')
         self.status_path = os.path.join(STATE, 'status.json')
+        self.economy_path = os.path.join(STATE, 'economy.json')   # the opt-in poller's projection (Task 11)
         self.health_path = os.path.join(STATE, 'health')
         self.health, self.health_stamp, self.banner = {}, None, ''
         self.entries, self.title, self.errors = [], workspace, []
+        self.attach_only = False
+        self.workspaces, self.registration, self.registration_choices = [], None, []
         self.status, self.unregistered, self.zmx = {}, [], []
         self.cursor, self.top = 0, 0
         self.filter, self.filtering = '', False
         self.renaming, self.rename_value, self.rename_entry = False, '', None
         self.promoting, self.promote_entry = False, None
-        self.stamp = (0, 0, 0)
-        self._prev_entry_count = -1      # for scroll memory
+        self.confirming = None
+        self.dirty = True
+        self.color, self.glyph_mode, self.variant = None, None, None
+        self.theme_pending, self.theme_deadline, self.osc_buffer = False, 0.0, ''
+        self.row_cache = {}                       # lane id -> (key, row text); a look change and `r` empty it
+        self.row_hits, self.row_misses = 0, 0
+        self.economy, self.economy_tiers = {}, ''  # economy.json (reload); tail_for() and the strip read it
+        self.economy_frozen = False                # economy_aged() at the last poll_economy(): a flip repaints
+        self.showing_keys, self.strip_row = False, False
+        self.fleet, self.board_titles = {}, {}
+        self.last_counts, self.notified = '', {}   # '' not None: an agent-less workspace never emits a title
+        self.apply_look(meta)
+        # `done` is sticky until the lane is opened from this device: lane id -> the time it was last opened. Read
+        # once here and again only when a target file changes (never per tick: spec §8's stat budget), written by
+        # mark_seen() and by `lanes next|prev`.
+        self.seen_path = os.path.join(STATE, 'clients', device + '.seen.json')
+        self.seen = L.clean_seen(read_json(self.seen_path))
+        self.stamp = (0, 0, 0, 0, 0)   # registry, status, targets, device look, economy
         self.size = (0, 0)
         self.dirty = True
         self.message = ''
@@ -158,34 +402,124 @@ class Sidebar:
     # ---------------------------------------------------------------- data
     def reload(self, force=False):
         stamp = (mtime(self.registry_path), mtime(self.status_path),
-                 sum(mtime(self.slot_file(slot, 'target')) for slot in SLOTS[:self.viewports]))
+                 sum(mtime(self.slot_file(slot, 'target')) for slot in SLOTS[:self.viewports]),
+                 mtime(self.look_path), mtime(self.economy_path))
         if stamp == self.stamp and not force:
             return
+        if force:
+            self.row_cache.clear()     # `r` and every forced reload repaint every row from scratch (spec §4.11)
+        # The cursor follows the LANE, not the index (spec §4.5, §10): a lane that changes section moves rows above
+        # the cursor, so remember which lane it is on and re-find it after the reload.
+        cursor_id = self.cursor_id
         if stamp[0] != self.stamp[0] or force:
             registry = read_json(self.registry_path) or {}
             boards = registry.get('workspaces', [])
+            self.workspaces = boards
             self.mobile_owner = self.mobile and bool(boards) and boards[0]['id'] == self.workspace
             self.mobile_titles = {w.get('title') or w['id']: w['id'] for w in boards}
+            self.board_titles = {w['id']: w.get('title') or w['id'] for w in boards}
             self.mobile_titles.update({tool['tab']: tool['view'] for tool in registry.get('tools', [])})
             for workspace in registry.get('workspaces', []):
                 if workspace.get('id') == self.workspace:
                     self.title = workspace.get('title') or self.workspace
-                    self.entries = list(workspace.get('lanes', [])) + list(workspace.get('extras', []))
+                    self.entries = list(workspace.get('lanes', []))
                     self.errors = workspace.get('errors', [])
+                    self.attach_only = bool(workspace.get('attach_only'))
                     break
         if stamp[1] != self.stamp[1] or force:
             status = read_json(self.status_path) or {}
             self.status = status.get('lanes', {})
             self.unregistered = (status.get('unregistered') or {}).get(self.workspace, [])
             self.zmx = (status.get('zmx') or {}).get(self.workspace, [])
+        if stamp[0] != self.stamp[0] or stamp[1] != self.stamp[1] or force:
+            self.fleet = self.fleet_counts()
+        if stamp[3] != self.stamp[3] or force:
+            self.apply_look(read_json(self.look_path) or {})
+        if stamp[4] != self.stamp[4] or force:
+            # The seventh stat() of a tick at one viewport (spec §8): re-read only when the poller replaced the file.
+            # A missing file (no poller: the default) is {} — no economy tail on any row, the strip row yields.
+            self.economy = load_economy(read_json(self.economy_path)) if stamp[4] else {}
+            self.economy_tiers = self.tier_mix()
+        if stamp[2] != self.stamp[2] and self.stamp != (0, 0, 0, 0, 0):   # not the first reload: __init__ read it
+            # A viewport was pointed at a lane — by this sidebar, or by `lanes next|prev` (Ctrl-Alt-Down/Up, plan
+            # Task 19), which marks the lane seen in the device's file as open_lane does. Merge the file once per
+            # such change (never per tick: spec §8), so a `done` lane opened that way leaves Done here too.
+            merged = L.clean_seen(read_json(self.seen_path))
+            for key, value in self.seen.items():
+                merged[key] = max(value, merged.get(key, value))
+            self.seen = merged                     # a fresh dict, never the class default mutated in place
         self.stamp = stamp
         self.dirty = True
-        # Scroll memory: preserve scroll top when list length is stable.
-        # Cursor is already clamped by render() on every draw.
-        new_count = len(self.visible())
-        if new_count != self._prev_entry_count:
-            self._prev_entry_count = new_count
-            self.top = 0   # reset scroll position on structural change
+        # `top` is kept (no reset when the list length changes) and shifted by the rows inserted above the cursor, so
+        # the cursor's lane stays on its screen row; render() still clamps both on every draw.
+        self.resolve_cursor(self.visible(), cursor_id)
+
+    # ------------------------------------------------------------------ look
+    def apply_look(self, meta):
+        """Resolve colour / theme / glyph modes from the device file and the environment (spec §2.4). Runs at start and
+        whenever devices/<device>.json changes, so `lanes attach DEVICE --ascii|--theme|--color` against a LIVE session
+        reaches every sidebar of that device within one tick (Zellij panes keep the server's environment from session
+        creation: an environment variable can never reach a running sidebar). Publishes the glyph mode for view.sh."""
+        color, theme, glyphs = resolve_modes(os.environ, meta)
+        changed = (color, glyphs) != (self.color, self.glyph_mode)
+        self.color, self.glyph_mode = color, glyphs
+        variant_changed = False
+        if theme != 'auto':
+            variant_changed = theme != self.variant
+            self.variant, self.theme_pending = theme, False
+        elif self.variant is None:                 # first resolution under `auto`: paint dark, ask the terminal once
+            self.variant, self.theme_pending, self.theme_deadline = 'dark', True, time.monotonic() + THEME_GRACE
+        changed = changed or variant_changed
+        self.tone = tokens.sgr_table(self.color, self.variant)
+        self.glyphs = tokens.glyph_set(self.glyph_mode)
+        glyphs_file = os.path.join(STATE, 'clients', self.device + '.glyphs')
+        if changed or not os.path.exists(glyphs_file):
+            try:
+                L.atomic_write(Path(glyphs_file), self.glyph_mode + '\n')
+            except OSError:
+                pass   # view.sh then keeps its default; the sidebar itself is unaffected
+        if theme != 'auto':
+            self.publish_theme(variant_changed)
+        if changed:
+            self.row_cache.clear()
+            self.dirty = True
+
+    def apply_theme(self, variant):
+        """The OSC 11 answer (or the grace expiry, with the current variant): repaint on a change and publish it."""
+        self.theme_pending = False
+        if not variant:
+            return
+        changed = variant != self.variant
+        if changed:
+            self.variant, self.tone, self.dirty = variant, tokens.sgr_table(self.color, variant), True
+            self.row_cache.clear()
+        self.publish_theme(changed)
+
+    def publish_theme(self, changed):
+        """clients/<device>.theme (`dark`/`light` + newline) for `glow`: written on change or when absent, never per
+        render."""
+        theme_file = os.path.join(STATE, 'clients', self.device + '.theme')
+        if changed or not os.path.exists(theme_file):
+            try:
+                L.atomic_write(Path(theme_file), self.variant + '\n')
+            except OSError:
+                pass
+
+    def strip_osc(self, data):
+        """Remove complete OSC sequences from `data`, apply OSC 11 answers, hold an incomplete OSC 11 tail for the next
+        read (Review Focus 6). An OSC reply is never an Esc: it cannot cancel a filter or a prompt."""
+        data, self.osc_buffer = self.osc_buffer + data, ''
+        if '\033]' not in data:
+            return data
+        for match in OSC.finditer(data):
+            variant = parse_osc11(match.group(1))
+            if variant:
+                self.apply_theme(variant)
+        data = OSC.sub('', data)
+        held = OSC11_PREFIX.search(data)
+        if held:
+            self.osc_buffer, data = data[held.start():], data[:held.start()]
+        return data
 
     def poll_mobile_view(self):
         """One sidebar observes the phone's web client and the first display of each full-width view.
@@ -223,10 +557,25 @@ class Sidebar:
         stamp = mtime(self.health_path)
         if stamp != self.health_stamp:
             self.health_stamp, self.health = stamp, L.read_health(STATE)
-        banner = health_banner(self.health, stamp / 1e9, time.time())
+        marks = self.glyphs['marks']
+        banner = health_banner(self.health, stamp / 1e9, time.time(), marks['warning'], f" {marks['sep']} ")
         if banner != self.banner:
             self.banner, self.dirty = banner, True
 
+    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
+        `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
+
+    def poll_economy(self):
+        """Repaint when economy.json crosses ECONOMY_STALE. Polled every tick like poll_health(): the case that matters
+        is a poller that stopped, where economy.json's mtime — reload()'s only trigger — never changes again."""
+        frozen = self.economy_aged(time.time())
+        if frozen != self.economy_frozen:
+            self.economy_frozen, self.dirty = frozen, True
+
     def current_target(self):
         try:
             with open(self.target_file) as handle:
@@ -238,16 +587,417 @@ class Sidebar:
             except OSError:
                 return ''
 
+    # ------------------------------------------------------------ attention
+    def agent_of(self, lane_id):
+        """The lane's `agent{}` from status.json, or {} (a plain shell, or a statusd that does not publish it)."""
+        agent = (self.status.get(lane_id) or {}).get('agent')
+        return agent if isinstance(agent, dict) else {}
+
+    def seen_done(self, lane_id):
+        """True when this lane's `done` is not news any more: it was opened at or after the turn finished."""
+        since = self.agent_of(lane_id).get('since')
+        return lane_id in self.seen and (since if isinstance(since, (int, float)) else 0) <= self.seen[lane_id]
+
+    def mark_seen(self, lane_id):
+        """Record that the operator opened this lane (only `open_lane` calls it, spec §10): a `done` turn that
+        finished before now leaves the Done section; a later one is news again. Persisted per device, bounded to
+        the lanes status.json knows, so a restarted sidebar does not resurrect what was already looked at.
+        Every workspace tab of a device runs its own sidebar over the SAME file, so a write merges what is on disk
+        (the later mark per lane wins) instead of replacing it with this process's view — `lanes_lib.record_seen`,
+        which `lanes next|prev` (Ctrl-Alt-Down/Up) call too."""
+        since = self.agent_of(lane_id).get('since')
+        self.seen = L.record_seen(self.seen_path, lane_id, since, self.status, self.seen)
+
+    def agent_rows(self, lanes):
+        """[(entry, agent status or None, since or None, attention key or None)] in ONE pass over status.json — the
+        sections, the counts and the header all read this, so a render looks each lane up once (spec §4.11)."""
+        if not lanes:
+            return []
+        status_of, seen, out = self.status, self.seen, []
+        for entry in lanes:
+            agent = (status_of.get(entry.get('id', '')) or {}).get('agent')
+            status = agent.get('status') if isinstance(agent, dict) else None
+            if status not in AGENT_GLYPHS:
+                out.append((entry, None, None, None))
+                continue
+            since = agent.get('since')
+            since = since if isinstance(since, (int, float)) else None
+            key = SECTION_OF.get(status)
+            if key == 'done' and entry['id'] in seen and (since or 0) <= seen[entry['id']]:
+                key = None                              # opened since it finished: not news (seen_done)
+            out.append((entry, status, since, key))
+        return out
+
+    def fleet_counts(self):
+        """{other workspace's title: {needs_approval: n, needs_input: n}} from the status.json already loaded — one pass
+        over its lanes, zero extra reads (spec §4.6(c)); this workspace is never in it. Ordered as the registry lists the
+        workspaces, so the strip does not reshuffle when status.json does."""
+        found = {}
+        for lane_id, entry in self.status.items():
+            board = lane_id.split('--', 1)[0]
+            agent = entry.get('agent') if isinstance(entry, dict) else None
+            status = agent.get('status') if isinstance(agent, dict) else None
+            if board != self.workspace and status in ('needs_approval', 'needs_input'):
+                counts = found.setdefault(board, {})
+                counts[status] = counts.get(status, 0) + 1
+        order = {board: index for index, board in enumerate(self.board_titles)}
+        return {self.board_titles.get(board, board): found[board]
+                for board in sorted(found, key=lambda b: (order.get(b, len(order)), b))}
+
+    def fleet_attention(self, width=None):
+        """The strip row's fleet attention: ` ◆1 Worlds · ◇2 Code`, glyphs in their tones, '' when no other workspace
+        needs you. `width` (cells) drops whole workspaces that would not fit, never half a count."""
+        glyphs, tone = self.glyphs, self.tone
+        sep = f' {glyphs["marks"]["sep"]} '
+        out, used = [], 0
+        for title, counts in self.fleet.items():
+            cells = [(f'{tone[tokens.tone_of(AGENT_GLYPHS, k)]}{glyphs["agent"][k]}{counts[k]}{tone["reset"]}',
+                      f'{glyphs["agent"][k]}{counts[k]}') for k in ('needs_approval', 'needs_input') if counts.get(k)]
+            if not cells:
+                continue
+            plain = ' '.join(c[1] for c in cells) + ' ' + title
+            cost = cell_width((sep if out else ' ') + plain)
+            if width is not None and used + cost > width:
+                break
+            out.append(' '.join(c[0] for c in cells) + ' ' + title)
+            used += cost
+        return ' ' + sep.join(out) if out else ''
+
+    def tier_mix(self):
+        """This workspace's lanes in economy.json by model tier, in TIERS order: `F2 S1` ('' when none is known).
+        Computed once per economy.json change (reload), never per render."""
+        prefix, counts = self.workspace + '--', {}
+        for lane_id, econ in (self.economy.get('lanes') or {}).items():
+            letter = tier_of(econ.get('model')) if lane_id.startswith(prefix) else ''
+            if letter:
+                counts[letter] = counts.get(letter, 0) + 1
+        return ' '.join(f'{letter}{counts[letter]}' for _word, letter in TIERS if counts.get(letter))
+
+    def economy_strip(self, width, now):
+        """(painted, plain) of the strip row's fleet economy line (spec §4.6(c)): ` $8.5k/16k 53% · 429 +4 · F2 S1 ·
+        spill 76% · free 3/19 · reset 2h`, parts in that priority order, a part only when its facts are known, whole
+        parts dropped from the end to fit `width` cells. ('', '') when economy.json knows no fleet fact (no poller,
+        or `LANES_THROTTLE_CONTROL=none`): the strip row then yields to fleet attention. Money over the alert level,
+        new 429s and a spilling pool are in the attention tone; everything else, and the whole line while the poller
+        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.
+        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'))
+        if fraction is None and spend is not None and budget:
+            fraction = spend / budget
+        alert = number(fleet.get('alert_level_pct'))
+        parts = []                                  # (text, role) in priority order
+        if spend is not None:
+            text = '$' + compact_usd(spend) + (f'/{compact_usd(budget)}' if budget is not None else '')
+            text += f' {round(fraction * 100)}%' if fraction is not None else ''
+            parts.append((text, 'tone-attention' if alert is not None and fraction is not None
+                          and fraction * 100 >= alert else 'ink-dim'))
+        new_429 = number(fleet.get('upstream_429_delta'))
+        if new_429 is not None and new_429 > 0:     # the poller reports growth only (None after a daemon restart)
+            parts.append((f'429 +{new_429}', 'tone-attention'))
+        has_fleet_fact = bool(parts)
+        spill, phase = number(fleet.get('spill_fraction')), fleet.get('pressure_phase')
+        free, accounts = number(fleet.get('effective_free')), number(fleet.get('accounts'))
+        reset = number(fleet.get('soonest_reset_5h'))
+        later = []
+        if spill is not None:
+            later.append((f'spill {round(spill * 100)}%',
+                          'tone-attention' if isinstance(phase, str) and phase not in SPILL_QUIET else 'ink-dim'))
+        if free is not None:
+            later.append((f'free {free}' + (f'/{accounts}' if accounts is not None else ''), 'ink-dim'))
+        if reset is not None and reset > now:
+            later.append((f'reset {age3(reset - now).strip()}', 'ink-dim'))
+        if not (has_fleet_fact or later):
+            return '', ''
+        if self.economy_tiers:
+            parts.append((self.economy_tiers, 'ink-dim'))
+        parts += later
+        glyphs, tone = self.glyphs, self.tone
+        sep_plain = f' {glyphs["marks"]["sep"]} '
+        lead = f' {glyphs["marks"]["stale"]} ' if stale else ' '
+        painted, plain, used = [], [], cell_width(lead)
+        for text, role in parts:
+            cost = cell_width(text) + (cell_width(sep_plain) if plain else 0)
+            if used + cost > width:
+                break
+            role = 'ink-dim' if stale else role
+            painted.append(f'{tone[role]}{text}{tone["reset"]}')
+            plain.append(text)
+            used += cost
+        if not plain:
+            return '', ''
+        sep_painted = f'{tone["ink-dim"]}{sep_plain}{tone["reset"]}'
+        lead_painted = f'{tone["ink-dim"]}{lead}{tone["reset"]}' if stale else lead
+        return lead_painted + sep_painted.join(painted), lead + sep_plain.join(plain)
+
+    def attention(self, entry):
+        """The attention section key of a registry entry, or None (the remainder)."""
+        return self.agent_rows([entry])[0][3]
+
+    def counts(self):
+        """{needs, working, agents, shells} over this workspace's registry lanes: `needs` and `working` are the
+        sizes of those sections, `agents` the lanes running a harness (any status but `shell`), `shells` the rest."""
+        needs = working = agents = 0
+        for _entry, status, _since, key in self.agent_rows(self.entries):
+            needs += key == 'needs'
+            working += key == 'working'
+            agents += status is not None and status != 'shell'
+        return {'needs': needs, 'working': working, 'agents': agents, 'shells': len(self.entries) - agents}
+
+    def header_tally(self):
+        """[(agent status, 'glyph+count')] for the header, in `HEADER_COUNTS` order, zeros omitted; a seen `done`
+        is not counted (it left the Done section)."""
+        counts = {}
+        for _entry, status, _since, key in self.agent_rows(self.entries):
+            if status in HEADER_COUNTS and (status != 'done' or key):
+                counts[status] = counts.get(status, 0) + 1
+        agent = self.glyphs['agent']
+        return [(k, f'{agent[k]}{counts[k]}') for k in HEADER_COUNTS if counts.get(k)]
+
+    def header_counts(self):
+        """The header's right side, plain: `◆1 ◇2 ▸6 ✓1`, zeros omitted, '' when no lane has one (spec §4.3)."""
+        return ' '.join(text for _status, text in self.header_tally())
+
+    # ------------------------------------------------------------------ rows
+    def tail_for(self, observed, econ, now=None):
+        """(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
+        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'):
+            return self.glyphs['marks']['stale'], 'ink-dim'
+        if not econ:
+            return ' ', 'ink-dim'
+        if starving(observed, econ):
+            kind = 'starving'
+        elif (number(econ.get('downgraded_5m')) or 0) > 0:
+            kind = 'downgraded'
+        elif (number(econ.get('paid_share')) or 0) > 0.5:
+            kind = 'paid'
+        else:
+            return ' ', 'ink-dim'
+        frozen = econ.get('stale') is True or (now is not None and self.economy_aged(now))
+        return self.glyphs['economy'][kind], 'ink-dim' if frozen else ECONOMY_TAIL[kind][2]
+
+    def row(self, entry, index, target, others, cols, now, section_tone=None):
+        """One lane row (spec §4.2): columns 1-35 written, column 36 never (the caller's `\\033[K` clears it).
+        cursor 1 · agent 2 · mark 3 · name 4-27 · space · age 29-31 · space · stream 33 · tail 34 · × 35.
+        Cached per lane by everything that can change its bytes (spec §4.11); `row_hits`/`row_misses` count it."""
+        observed = self.status.get(entry['id']) or {}
+        agent = observed.get('agent') if isinstance(observed.get('agent'), dict) else {}
+        status = agent.get('status') if agent.get('status') in AGENT_GLYPHS else None
+        econ = (self.economy.get('lanes') or {}).get(entry['id']) if self.economy else None
+        state = observed.get('state', 'helper' if entry.get('holder') == 'exec' else 'unknown')
+        key_state = state if state in GLYPHS else 'unknown'
+        stale = bool(observed.get('stale'))
+        since = agent.get('since') if status else observed.get('activity')
+        age = age3(int(now - since) if isinstance(since, (int, float)) and since > 0 else None)
+        is_cursor, is_viewing = index == self.cursor, entry['id'] == target
+        mark = ' '
+        for slot, name in zip(SLOTS[1:self.viewports], ('viewport-b', 'viewport-c')):
+            if others.get(slot) == entry['id']:
+                mark = self.glyphs['marks'][name]
+        if mark == ' ' and is_viewing and not is_cursor:
+            mark = self.glyphs['marks']['viewing']
+        # A lane statusd never observed already shows `?` as its stream glyph: one `?`, not two.
+        tail, tail_role = self.tail_for(observed if key_state != 'unknown' else {}, econ, now)
+        viewers = viewer_mark(observed).replace('·', self.glyphs['marks']['viewer'])
+        closable = bool(entry.get('closable'))
+        can_register = closable and R.eligible(entry)
+        key = (entry.get('name'), entry.get('color'), entry.get('icon'), closable, can_register, key_state, stale,
+               viewers, status, age, tail, tail_role, is_cursor, is_viewing, mark, cols, section_tone)
+        cached = self.row_cache.get(entry['id'])
+        if cached and cached[0] == key:
+            self.row_hits += 1
+            return cached[1]
+        self.row_misses += 1
+        tone, g, reset = self.tone, self.glyphs, self.tone['reset']
+        icon = ''
+        name_width = cols - 12 - len(viewers)
+        if self.glyph_mode == 'emoji':     # spec §3: the LANE_ICONS column, 3 cells after column 3, taken from the name
+            icon = entry.get('icon') or L.LANE_ICONS.get('terminal', '💻')
+            icon += ' ' * max(0, 3 - cell_width(icon))
+            name_width -= 3
+        name_width = max(1, name_width)
+        name = entry.get('name', entry['id'])
+        clipped, used = clip(name, name_width)
+        if len(clipped) < len(name):       # truncated: one cell less for the name, then `…` (no second width walk)
+            while clipped and used > name_width - 1:
+                used -= cell_width(clipped[-1])
+                clipped = clipped[:-1]
+            clipped, used = clipped + g['marks']['truncation'], used + 1
+        pad = ' ' * max(0, name_width - used)
+        cursor = f'{tone["accent"]}{g["marks"]["cursor"]}{reset}' if is_cursor else ' '
+        agent_cell = ' '
+        if status:
+            agent_role = 'ink-dim' if stale else tokens.tone_of(AGENT_GLYPHS, status)
+            agent_cell = f'{tone[agent_role]}{g["agent"][status]}{reset}'
+        mark_cell = f'{tone["accent"]}{mark}{reset}' if mark != ' ' else ' '
+        color = entry.get('color')
+        # The lane's identity colour (38;5;N) is a colour: under NO_COLOR (`none`) the name is plain ink.
+        fg = f'\033[38;5;{color}m' if isinstance(color, int) and self.color != 'none' else ''
+        lead = (tone['bold'] if is_viewing else '') + fg
+        name_cell = f'{lead}{clipped}{reset}' if lead else clipped
+        if viewers:
+            name_cell += f'{tone["ink-dim"]}{viewers}{reset}'
+        # The `+` register control (README "Daily use") has no column in spec §4.2: it takes the spacer cell 28
+        # (= cols − 8), inside its click box `cols − 8 ≤ x < cols − 4`, so the age keeps its place. It and the `×`
+        # are POSITIONED (CHA): a name whose terminal width disagrees with `cell_width` cannot push either control
+        # off its hit box.
+        spacer = f'\033[{max(1, cols - 8)}G{tone["tone-done"]}{g["marks"]["new"]}{reset}' if can_register else ' '
+        stream_role = 'ink-dim' if (stale or status) else tokens.tone_of(GLYPHS, key_state)
+        stream = f'{tone[stream_role]}{g["stream"][key_state]}{reset}'
+        tail_cell = f'{tone[tail_role]}{tail}{reset}' if tail != ' ' else ' '
+        close = f'\033[{max(1, cols - 1)}G{tone["tone-urgent"]}{g["marks"]["close"]}{reset}' if closable else ' '
+        age_role = section_tone or 'ink-dim'
+        text = (f'{cursor}{agent_cell}{mark_cell}{icon}{name_cell}{pad}{spacer}{tone[age_role]}{age}{reset} '
+                f'{stream}{tail_cell}{close}')
+        self.row_cache[entry['id']] = (key, text)
+        return text
+
+    def sectioned(self, lanes):
+        """Registry lanes in attention order (spec §4.4): Needs you (by urgency, oldest first), Working (oldest
+        first), Done (newest first, unseen only), then the rest in registry order under a workspace header — drawn
+        only when an attention section exists, so a workspace without agents looks exactly as before."""
+        buckets, rest = {key: [] for key, *_ in ATTENTION}, []
+        for entry, status, since, key in self.agent_rows(lanes):
+            if key is None:
+                rest.append(entry)
+            elif key == 'needs':     # urgency, then the oldest `since` first; an unknown `since` sorts last
+                buckets[key].append(((NEEDS_RANK[status], INF if since is None else since), status, entry))
+            elif key == 'working':
+                buckets[key].append((INF if since is None else since, status, entry))
+            else:                    # done: newest first
+                buckets[key].append((INF if since is None else -since, status, entry))
+        if not any(buckets.values()):
+            return rest
+        out = []
+        for key, title, _glyph, _members in ATTENTION:
+            if buckets[key]:
+                bucket = sorted(buckets[key], key=itemgetter(0))
+                # `status`: the most urgent member's, whose glyph heads the section (`── ◆ Needs you (3)`, spec §4.4)
+                out.append({'id': '', 'divider': True, 'name': f'{title} ({len(bucket)})', 'section': key,
+                            'status': bucket[0][1]})
+                out += [entry for _rank, _status, entry in bucket]
+        if rest:
+            out.append({'id': '', 'divider': True, 'name': f'{self.title} ({len(rest)})', 'section': 'rest'})
+        return out + rest
+
     def visible(self):
-        entries = list(self.entries)
+        self.last_visible = entries = self._visible()
+        return entries
+
+    # ---------------------------------------------------------------- cursor
+    @property
+    def cursor_id(self):
+        """The lane the cursor is on: the id of the entry `self.cursor` indexes in `last_visible` (the list it was set
+        against), None on a divider or past the end. Derived, never stored, so it cannot drift from the index."""
+        entries = self.last_visible
+        if 0 <= self.cursor < len(entries) and not entries[self.cursor].get('divider'):
+            return entries[self.cursor].get('id') or None
+        return None
+
+    def resolve_cursor(self, entries, cursor_id):
+        """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."""
+        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:
+                self.top = max(0, self.top + (index - self.cursor))
+                self.cursor = index
+        self.cursor = max(0, min(self.cursor, len(entries) - 1))
+
+    def follow(self):
+        """The current list with the cursor re-resolved onto its lane: what render() and every key in handle() use.
+        The list can change without a reload (opening a `done` lane marks it seen; a close, a new shell)."""
+        cursor_id = self.cursor_id
+        entries = self.visible()
+        self.resolve_cursor(entries, cursor_id)
+        return entries
+
+    def set_cursor(self, index):
+        """Put the cursor on `index` of a list computed NOW (a filter keystroke, the registration picker): the list it
+        indexes is refreshed with it, so the next follow() does not drag it back to the lane it was on before."""
+        entries = self.visible()
+        self.cursor = max(0, min(index, len(entries) - 1))
+
+    def needs_you(self):
+        """The visible lanes whose agent needs you, in section order (approval, errored, input; oldest first)."""
+        out = []
+        for entry in self.visible():
+            agent = None if entry.get('divider') else (self.status.get(entry.get('id', '')) or {}).get('agent')
+            if isinstance(agent, dict) and agent.get('status') in NEEDS_YOU:
+                out.append(entry)
+        return out
+
+    def jump_needs_you(self, step):
+        """Tab / Shift-Tab: open the next / previous lane that needs you, cycling. Relative to the lane this view SHOWS
+        (the target file); relative to the cursor lane when the shown one is not in the list (nothing shown yet, or it
+        does not need you); from the first / last only when neither is — so two Tabs always visit two lanes, also
+        before open_lane has moved the target (spec §4.5)."""
+        lanes = self.needs_you()
+        if not lanes:
+            self.message = 'nothing needs you'
+            return
+        ids = [e['id'] for e in lanes]
+        target, cursor_id = self.current_target(), self.cursor_id
+        if target in ids:
+            index = ids.index(target)
+        elif cursor_id in ids:
+            index = ids.index(cursor_id)
+        else:
+            index = -1 if step > 0 else 0
+        entry = lanes[(index + step) % len(lanes)]
+        self.cursor = self.last_visible.index(entry)    # needs_you() just computed last_visible
+        self.open_lane(entry)
+
+    def osc_bytes(self, target):
+        """The pane title when the header counts changed since the last frame, and one OSC 9 per lane per transition
+        into needs-you — never for `target` (the lane this view shows), never on a phone, never under LANES_NOTIFY=0
+        (spec §4.9). Strings only: they ride the frame's single write, after the footer."""
+        out = ''
+        counts = self.header_counts()
+        if counts != self.last_counts:
+            self.last_counts = counts
+            out += f'\033]2;{osc_text(self.title + (" · " + counts if counts else ""))}\033\\'
+        quiet = self.mobile or os.environ.get('LANES_NOTIFY') == '0'
+        notified, now = self.notified, {}
+        for entry in self.entries:
+            agent = (self.status.get(entry.get('id', '')) or {}).get('agent')
+            status = agent.get('status') if isinstance(agent, dict) else None
+            if status not in NEEDS_YOU:
+                continue
+            now[entry['id']] = status
+            if not quiet and notified.get(entry['id']) != status and entry['id'] != target:
+                text = osc_text(f'{entry.get("name", entry["id"])}: {agent.get("name") or status}')
+                out += f'\033]9;{text}\033\\'
+        self.notified = now        # a lane that left needs-you is forgotten: its next entry is news again
+        return out
+
+    def _visible(self):
+        if self.registration:
+            return self.registration_choices + [{'id': '', 'name': 'Cancel', 'action': 'cancel-registration'}]
+        # Filter mode flattens the sections exactly as before (dividers are dropped below); the agent glyph stays.
+        entries = list(self.entries) if self.filter else self.sectioned(self.entries)
         if self.zmx:
             entries.append({'id': '', 'divider': True, 'name': f'zmx lanes ({len(self.zmx)})'})
             entries += self.zmx
         # Everything statusd lists as unregistered is shown, `view-…` names included: under the viewer rule
-        # those are orphaned or operator-made sessions that are ALIVE, and nothing alive is ever hidden.
-        entries.append({'id': '', 'divider': True, 'name': f'Unregistered ({len(self.unregistered)})'})
-        entries.append({'id': self.workspace + '--new-shell', 'name': 'New +', 'action': 'new-shell', 'icon': '＋'})
-        entries += self.unregistered
+        # those are orphaned or operator-made sessions that are ALIVE, and nothing alive is ever hidden —
+        # except a session that IS registered (it is listed under its workspace instead, never twice).
+        registered = {R.key(lane) for w in self.workspaces for lane in w.get('lanes', []) if lane.get('holder') == 'tmux'}
+        unregistered = [e for e in self.unregistered if not R.eligible(e) or R.key(e) not in registered]
+        if not self.attach_only:
+            entries.append({'id': '', 'divider': True, 'name': f'Unregistered ({len(unregistered)})'})
+            entries.append({'id': self.workspace + '--new-shell', 'name': 'New +', 'action': 'new-shell', 'icon': '＋'})
+            entries += unregistered
         if not self.filter:
             return entries
         needle = self.filter.lower()
@@ -279,6 +1029,12 @@ class Sidebar:
     def open_lane(self, entry, slot=None):
         if entry.get('divider'):
             return
+        if entry.get('action') == 'cancel-registration':
+            self.cancel_registration()
+            return
+        if entry.get('action') == 'register-workspace':
+            self.register_lane(entry['workspace'])
+            return
         slot = slot or self.slot
         if slot not in SLOTS[:self.viewports]:
             self.message = 'this view has no such viewport (open a wide view: lanes-window w2)'
@@ -287,23 +1043,14 @@ class Sidebar:
         if entry.get('action') == 'new-shell':
             self.new_shell(slot)
             return
-        target_file, pid_file = self.slot_file(slot, 'target'), self.slot_file(slot, 'pid')
+        if self.agent_of(entry['id']):
+            self.mark_seen(entry['id'])     # the one caller (spec §10): opening a lane is looking at it
         if self.slot_target(slot) == entry['id']:
             self.focus_lane(slot)
             self.filter, self.filtering, self.dirty = '', False, True
             return
-        os.makedirs(self.view_dir, exist_ok=True)
-        tmp = target_file + f'.{os.getpid()}.tmp'
-        with open(tmp, 'w') as handle:
-            handle.write(entry['id'] + '\n')
-        os.replace(tmp, target_file)
-        try:
-            with open(pid_file) as handle:
-                pid = int(handle.read().strip())
-            with open(f'/proc/{pid}/cmdline', 'rb') as handle:
-                if b'view.sh' in handle.read():
-                    os.kill(pid, signal.SIGUSR1)
-        except (OSError, ValueError):
+        # The one "write the target, wake that view.sh" (lanes_lib.show_lane), shared with `lanes next|prev`.
+        if not L.show_lane(self.view_dir, self.workspace, slot, entry['id']):
             self.message = 'view not running yet'
         self.focus_lane(slot)
         self.filter, self.filtering = '', False
@@ -322,6 +1069,11 @@ class Sidebar:
             self.message = str(error)
         self.dirty = True
 
+    def request_close(self, entry):
+        """`x` or a click on `×`: ask first (spec §4.6(a)); handle() closes on `y` and cancels on anything else."""
+        if entry.get('closable'):
+            self.confirming, self.dirty = entry, True
+
     def close_lane(self, entry):
         if not entry.get('closable'):
             return
@@ -354,21 +1106,26 @@ class Sidebar:
             self.dirty = True
             return
         try:
-            if entry.get('closable') or entry.get('id', '').find('--x-') >= 0:
+            # 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).
+            if entry.get('registered_session'):
+                R.rename(entry['id'], new_name)
+                self.message = f'Renamed → {new_name}'
+                self.reload(force=True)
+            elif entry.get('closable'):
                 # Unregistered session
-                updated = A.rename_session(self.workspace, entry, new_name)
-                for lst in (self.unregistered, self.zmx):
-                    for i, e in enumerate(lst):
-                        if e['id'] == entry['id']:
-                            lst[i] = dict(e, name=new_name)
+                A.rename_session(self.workspace, entry, new_name)
+                for i, e in enumerate(self.unregistered):
+                    if e['id'] == entry['id']:
+                        self.unregistered[i] = dict(e, name=new_name)
                 self.message = f'Renamed → {new_name}'
             else:
-                # Registered lane: write displayNames override to the manifest + sync
-                source = entry.get('source')
+                # Registered lane: a repositories[i].displayNames override in the board manifest + sync.
+                # The lane id never changes, so the cursor, view targets and `lane open <id>` keep working.
                 registry_name = entry.get('registry_name') or entry.get('name', '')
-                if not source:
-                    raise L.LanesError('No manifest source for this lane; edit terminals.json directly')
-                A.rename_registered(source, registry_name, new_name)
+                if not entry.get('repo'):
+                    raise L.LanesError('No repository for this lane; edit the workspace manifest directly')
+                A.rename_registered(L.manifest_path(self.workspace), entry['repo'], registry_name, new_name)
                 # Trigger a registry rebuild
                 import subprocess as _sp
                 _sp.Popen([os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
@@ -383,8 +1140,15 @@ class Sidebar:
         """Begin promotion confirmation for an unregistered session."""
         if entry.get('divider') or entry.get('action'):
             return
-        if not entry.get('closable') and entry.get('holder') != 'tmux':
-            self.message = 'Only tmux sessions can be promoted'
+        # 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).
+        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
+            return
+        if not entry.get('closable') or not R.eligible(entry):
+            self.message = 'Only unregistered tmux sessions can be promoted'
             self.dirty = True
             return
         self.promoting = True
@@ -413,6 +1177,42 @@ class Sidebar:
             self.message = str(error)
         self.dirty = True
 
+    def start_registration(self, entry):
+        if not entry.get('closable') or not R.eligible(entry):
+            return
+        choices = R.destinations({'workspaces': self.workspaces}, entry)
+        choices.sort(key=lambda w: w['id'] != self.workspace)
+        if not choices:
+            self.message, self.dirty = 'No workspace uses this session’s container', True
+            return
+        self.registration = entry
+        self.message = ''
+        self.armed = False
+        self.registration_choices = [{'id': w['id'], 'workspace': w['id'], 'name': w.get('title') or w['id'],
+                                      'action': 'register-workspace'} for w in choices]
+        self.filter, self.filtering, self.top, self.dirty = '', False, 0, True
+        self.set_cursor(0)
+
+    def cancel_registration(self):
+        self.registration, self.registration_choices = None, []
+        self.top, self.dirty = 0, True
+        self.set_cursor(0)
+
+    def register_lane(self, workspace):
+        entry = self.registration
+        if not entry:
+            return
+        try:
+            lane = R.register(self.workspace, entry, workspace)
+            self.unregistered = [e for e in self.unregistered if e['id'] != lane['id']]
+            title = next((w.get('title') or w['id'] for w in self.workspaces if w['id'] == workspace), workspace)
+            self.cancel_registration()
+            self.reload(force=True)
+            self.message = 'Added to ' + title
+        except (L.LanesError, OSError, ValueError) as error:
+            self.message = str(error)
+        self.dirty = True
+
     def spools(self):
         """Where an upload request may be spooled, best first. A suffixed view (mac-2, mac-w2) belongs to the machine
         whose base device (mac) `lanes attach` recorded in devices/<device>.json: that machine's ONE helper serves
@@ -438,12 +1238,13 @@ class Sidebar:
                 token = re.sub(r'%([0-9A-Fa-f]{2})', lambda m: chr(int(m.group(1), 16)), token[7:])
             if token.startswith('/') and '\n' not in token:
                 paths.append(token)
+        fail = self.glyphs['marks']['fail'] + ' '
         if not paths or len(paths) != len(tokens):
-            self.upload_note, self.upload_note_at = 'that was not a file drop', time.time()
+            self.upload_note, self.upload_note_at = fail + 'that was not a file drop', time.time()
             return
         spool = next((s for s in self.spools() if time.time() - mtime(os.path.join(s, 'agent.alive')) / 1e9 <= 12), None)
         if not spool:   # no helper is serving either spool
-            self.upload_note, self.upload_note_at = 'no upload helper on this device (reopen lanes-launch)', time.time()
+            self.upload_note, self.upload_note_at = fail + 'no upload helper on this device (reopen lanes-launch)', time.time()
             return
         request = f'{int(time.time() * 1000)}-{os.getpid()}'
         # The sidecar names the view that asked — the device whose lane gets the paste (`lanes upload --request`).
@@ -457,6 +1258,8 @@ class Sidebar:
         self.upload = {'id': request, 'spool': spool, 'names': [os.path.basename(p) for p in paths], 'at': time.time()}
 
     def poll_upload(self):
+        """Follow the request in flight. The strip repaints only when this changes something — a new `.progress`
+        mtime or the end of the upload (spec §4.6(d)): no spinner, no fast tick."""
         if not self.upload:
             return
         base = os.path.join(self.upload['spool'], self.upload['id'])   # the results land where the request went
@@ -464,18 +1267,20 @@ class Sidebar:
         if progress_at > self.upload.get('progress_at', 0):
             progress = read_json(base + '.progress') or {}
             self.upload.update(progress_at=progress_at, bytes=progress.get('bytes', 0))
+            self.dirty = True
+        ok, fail = self.glyphs['marks']['ok'] + ' ', self.glyphs['marks']['fail'] + ' '
         note = None
         if os.path.exists(base + '.done'):
-            note = '✓ ' + ', '.join(self.upload['names'])[:60]
+            note = ok + ', '.join(self.upload['names'])[:60]
             self.focus_lane()
         elif os.path.exists(base + '.err'):
             try:
                 with open(base + '.err') as handle:
-                    note = '✖ ' + handle.readline().strip()[:70]
+                    note = fail + handle.readline().strip()[:70]
             except OSError:
-                note = '✖ upload failed'
+                note = fail + 'upload failed'
         elif time.time() - max(self.upload['at'], progress_at) > 120:
-            note = '✖ upload timed out'
+            note = fail + 'upload timed out'
         if note:
             for suffix in ('.done', '.err', '.sent', '.req', '.dev', '.progress'):
                 try:
@@ -495,26 +1300,70 @@ class Sidebar:
                 except (OSError, subprocess.SubprocessError):
                     break
 
-    def box_lines(self, cols):
-        """The upload box: BOX_ROWS lines, last rows of the sidebar."""
-        inner = max(4, cols - 2)
+    def strip_line(self, cols):
+        """The upload strip (spec §4.6(d)): ONE row under the body, at most `cols − 1` cells — idle, armed, sending,
+        or the result for 8 s. Every glyph and separator is a mark, so the ASCII frame is seven-bit."""
+        tone, g = self.tone, self.glyphs['marks']
+        sep = f' {g["sep"]} '
         if self.upload:
-            spin = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'[int(time.time() * 8) % 10]
-            body, style = [f'{spin} sending {len(self.upload["names"])} file(s)…', ', '.join(self.upload['names'])], '33'
+            count = len(self.upload['names'])
+            text, style = f' {g["upload"]} sending {count} file{"s" if count != 1 else ""}', tone['tone-working']
             if self.upload.get('bytes'):
-                body[1] = f'{self.upload["bytes"] / 1048576:.1f} MiB · ' + body[1]
+                text += f'{sep}{self.upload["bytes"] / 1048576:.1f} MiB'
         elif self.armed:
-            body, style = ['⬇  DROP FILES NOW', 'anywhere on this window · Esc'], '1;32'
+            text, style = f' {g["armed"]} DROP FILES NOW{sep}anywhere{sep}Esc', tone['bold'] + tone['tone-done']
         elif self.upload_note and time.time() - self.upload_note_at < 8:
-            body, style = [self.upload_note, f'→ {self.workspace}/uploads'], '36'
+            text = ' ' + self.upload_note
+            style = tone['tone-done'] if self.upload_note.startswith(g['ok']) else tone['tone-urgent']
         else:
-            body, style = ['⬆ uploads — click, then drop', f'→ {self.workspace}/uploads  (U)'], '2'
-        lines = [f'\033[{style}m┌{"─" * inner}┐\033[0m']
-        for text in body[:BOX_ROWS - 2]:
-            text, used = clip(' ' + text, inner)
-            lines.append(f'\033[{style}m│\033[0m\033[{style}m{text}{" " * (inner - used)}\033[0m\033[{style}m│\033[0m')
-        lines.append(f'\033[{style}m└{"─" * inner}┘\033[0m')
-        return lines
+            text, style = f' {g["upload"]} uploads{sep}click, then drop  (U)', tone['ink-dim']
+        text, _used = clip(text, cols - 1)
+        return f'{style}{text}{tone["reset"]}'
+
+    def divider_line(self, entry, cols):
+        """`── ◆ Needs you (3) ───` (spec §4.4), shared by the desktop and the phone (§4.10 "section headers as
+        desktop"): the rule ink-faint, the words ink-dim, the glyph of the section's most urgent member in its tone,
+        filled to cols − 1 with the `rule` mark (never a literal: the ASCII frame is seven-bit). Column 36 is never
+        written; the caller adds `\\033[K`."""
+        tone, marks, reset = self.tone, self.glyphs['marks'], self.tone['reset']
+        attention = next((s for s in ATTENTION if s[0] == entry.get('section')), None)
+        rule, dim, faint = marks['rule'], tone['ink-dim'], tone['ink-faint']
+        status = (entry.get('status') if entry.get('status') in AGENT_GLYPHS else attention[2]) if attention else None
+        glyph = f'{self.glyphs["agent"][status]} ' if status else ''
+        label, used_cols = clip(f'{glyph}{entry["name"]}', max(1, cols - 5))
+        if status and label.startswith(glyph):
+            painted = f'{tone[AGENT_GLYPHS[status][2]]}{glyph[:-1]}{reset}{dim} {label[len(glyph):]} {reset}'
+        else:
+            painted = f'{dim}{label} {reset}'
+        fill = rule * max(0, cols - 1 - 4 - used_cols)
+        return f'{faint}{rule * 2} {reset}{painted}{faint}{fill}{reset}'
+
+    def mobile_counts(self):
+        """The phone header (spec §4.10): ` ◆1 need approval · ◇2 need you · ▸6 working`, from the same tally as the
+        desktop header (zeros omitted, a seen `done` not counted), parts joined by the `sep` mark; '' when no lane
+        has an agent status worth counting."""
+        tally = self.header_tally()
+        if not tally:
+            return ''
+        sep = f' {self.glyphs["marks"]["sep"]} '
+        return ' ' + sep.join(f'{text} {MOBILE_COUNT_WORDS[status]}' for status, text in tally)
+
+    def key_sheet(self, cols, body):
+        """`body` lines: the key sheet `?` shows (spec §4.7), `  {key:<10}{action}`, the key ink-dim; padded with
+        blank lines, cut to the body. The seven-bit twins under LANES_GLYPHS=ascii."""
+        index = 1 if self.glyph_mode == 'ascii' else 0
+        dim, reset = self.tone['ink-dim'], self.tone['reset']
+        lines = []
+        for row in KEY_SHEET:
+            key = row[index]
+            action, _ = clip(row[2], max(0, cols - 13))
+            lines.append(f'{dim}  {key:<10}{reset}{action}')
+        return (lines + [''] * body)[:body]
+
+    @staticmethod
+    def tick_timeout():
+        """run()'s select() timeout: 1 s, always. An upload no longer shortens it — its strip repaints on progress."""
+        return 1.0
 
     # ------------------------------------------------------------ rendering
     def render(self):
@@ -526,119 +1375,167 @@ class Sidebar:
         if self.mobile:
             self.render_mobile(cols, rows)
             return
-        entries = self.visible()
-        self.box = rows >= 14
-        body = max(1, rows - 3 - (BOX_ROWS if self.box else 0))
-        self.box_top = 2 + body     # 1-based screen row where the box starts
-        self.cursor = max(0, min(self.cursor, len(entries) - 1))
+        entries = self.follow()      # the cursor re-resolved onto its lane, clamped (spec §4.5)
+        if self.theme_pending and time.monotonic() >= self.theme_deadline:
+            self.apply_theme(self.variant)          # no OSC 11 answer within the grace: dark it is (spec §2.4)
+        now = time.time()
+        # Frame order (spec §4.6): header, body, upload strip (rows ≥ 14), strip row (rows ≥ 18, economy or fleet
+        # attention to show), rule, footer. `box_top` is the upload strip's 1-based row; a click at or below it arms.
+        # The strip row is the fleet economy line when economy.json knows a fleet fact (Task 12), else fleet attention.
+        self.box = rows >= 14 and not self.registration and not self.attach_only
+        economy_line = self.economy_strip(cols - 2, now)[0] if self.economy and rows >= 18 else ''
+        self.strip_row = rows >= 18 and (bool(economy_line) or bool(self.fleet))
+        body = max(1, rows - 3 - (BOX_ROWS if self.box else 0) - (1 if self.strip_row else 0))
+        self.box_top = 2 + body
+        # resolve_cursor()'s eye-preserving shift is bounded by the list: a list that ends inside the body is never
+        # scrolled past its first rows (nothing above would say they are hidden; `⋮` only marks rows below).
+        self.top = max(0, min(self.top, len(entries) - body))
         if self.cursor < self.top:
             self.top = self.cursor
         if self.cursor >= self.top + body:
             self.top = self.cursor - body + 1
+        # The last body row says `⋮ N more` while the list continues (spec §4.7), so it never carries the cursor:
+        # a cursor that would sit under it scrolls the list one row further.
+        if body > 1 and self.top + body < len(entries) and self.cursor >= self.top + body - 1:
+            self.top = self.cursor - body + 2
+        self.more_row = 1 + body if body > 1 and self.top + body < len(entries) else 0   # 1-based screen row, 0 = none
         target = self.current_target()
         others = {slot: self.slot_target(slot) for slot in SLOTS[1:self.viewports]}
         out = ['\033[?25l\033[H']
-        counts = sum(1 for e in self.entries if self.status.get(e['id'], {}).get('state') == 'active')
-        header, used = clip(f' {self.title}', cols - 8)
-        out.append(f'\033[1m{header}\033[0m\033[2m{" " * max(1, cols - used - 7)}{counts:>2}/{len(self.entries):<3}\033[0m\033[K\r\n')
-        for row in range(body):
+        tone = self.tone
+        marks, reset = self.glyphs['marks'], self.tone['reset']
+        # Header (spec §4.3): the title, then the agent glyph counts ending at column 35 (column 36 blank), each in
+        # its tone — the same glyphs as column 2, so they are the legend. No agents: `{n} lanes`, ink-dim. While the
+        # health banner is up the counts are ink-dim too: a frozen status.json is not live.
+        tally = self.header_tally()
+        right = ' '.join(text for _status, text in tally) or f'{len(self.entries)} lanes'
+        right_width = cell_width(right)
+        header, used = clip(' Add to workspace' if self.registration else f' {self.title}', max(1, cols - right_width - 2))
+        if tally and not self.banner:
+            painted = ' '.join(f'{tone[AGENT_GLYPHS[status][2]]}{text}{reset}' for status, text in tally)
+        else:
+            painted = f'{tone["ink-dim"]}{right}{reset}'
+        # Column 36 is never written, not even with a blank (the budget gate's cell walk, DEF-1417): `\033[K` clears it.
+        out.append(f'{tone["bold"]}{header}{reset}{" " * max(1, cols - 1 - used - right_width)}{painted}\033[K\r\n')
+        more = bool(self.more_row) and not self.showing_keys
+        section = None
+        for index in range(self.top):          # the section the first visible row sits in (dividers above `top`)
+            if entries[index].get('divider'):
+                section = entries[index].get('section')
+        g = marks
+        sep, q0, q1 = f' {g["sep"]} ', g['quote-open'], g['quote-close']
+        if self.showing_keys:                  # spec §4.7: `?` replaces the body with the key sheet until any key
+            out.extend(f'{line}\033[K\r\n' for line in self.key_sheet(cols, body))
+        for row in range(0 if self.showing_keys else body):
             index = self.top + row
+            if row == 0 and self.filter and not entries:   # spec §4.7: filter with no hits
+                label, _ = clip(f' no lane matches {q0}{self.filter}{q1}{sep}Esc', cols - 1)
+                out.append(f'{tone["ink-dim"]}{label}{reset}\033[K\r\n')
+                continue
             if index >= len(entries):
                 out.append('\033[K\r\n')
                 continue
+            if more and row == body - 1:       # spec §4.7: the list continues — `  ⋮ N more`, the hidden rows counted
+                label, _ = clip(f'  {marks["more"]} {len(entries) - index} more', cols - 1)
+                out.append(f'{tone["ink-dim"]}{label}{reset}\033[K\r\n')
+                continue
             entry = entries[index]
             if entry.get('divider'):
-                label, used_cols = clip(f'── {entry["name"]} ', cols - 1)
-                out.append(f'\033[2m{label}{"─" * max(0, cols - 1 - used_cols)}\033[0m\033[K\r\n')
+                section = entry.get('section')
+                out.append(self.divider_line(entry, cols) + '\033[K\r\n')
                 continue
-            if entry.get('action'):
-                marker = '▌' if index == self.cursor else ' '
-                label, _ = clip(marker + ' New +', cols - 1)
-                out.append(f'\033[32m{label}\033[0m\033[K\r\n')
+            is_cursor = index == self.cursor
+            cursor = f'{tone["accent"]}{marks["cursor"]}{reset}' if is_cursor else ' '
+            if entry.get('action') == 'new-shell' and not self.entries and not self.filter:
+                # spec §4.7: an empty workspace says so on the New shell row itself (still the row that creates one)
+                label, used_cols = clip(f' no lanes declared{sep}{g["new"]} New shell', max(1, cols - 2))
+                out.append(f'{cursor}{tone["ink-dim"]}{label}{reset}{" " * max(0, cols - 2 - used_cols)}\033[K\r\n')
                 continue
-            observed = self.status.get(entry['id'], {})
-            state = observed.get('state', 'helper' if entry.get('holder') == 'exec' else 'unknown')
-            glyph, glyph_color = GLYPHS.get(state, GLYPHS['unknown'])
-            # stale = statusd got no answer about this lane and republished its LAST state: same glyph, dimmed, and a
-            # '?' in the spare cell after it (no cell is added: rows, clicks and the upload box stay where they are).
-            tail = ' '
-            if observed.get('stale') and glyph != '?':
-                glyph_color, tail = '2;' + glyph_color, '\033[2m?'
-            is_target, is_cursor = entry['id'] == target, index == self.cursor
-            shown = ''.join(mark for slot, mark in zip(SLOTS[1:self.viewports], '²³') if others.get(slot) == entry['id'])
-            shown += viewer_mark(self.status.get(entry['id']))
-            marker = '▌' if is_cursor else ' '
-            icon = entry.get('icon') or '💻'
-            icon_pad = ' ' * (3 - cell_width(icon))
-            name_width = max(1, cols - (12 if entry.get('closable') else 9))
-            # Status age suffix: show how long ago the lane was last active (quiet lanes only, compact)
-            age_suffix = ''
-            if state == 'quiet':
-                activity = observed.get('activity')
-                if activity:
-                    age_s = int(time.time() - activity)
-                    if age_s >= 60:
-                        age_suffix = f'  {age_s // 60}m'
-                    elif age_s >= 10:
-                        age_suffix = f'  {age_s}s'
-            name, name_used = clip(entry.get('name', entry['id']) + shown + age_suffix, name_width)
-            color = entry.get('color')
-            style = ('1;' if is_target else '') + ('4;' if is_cursor else '')
-            fg = f'38;5;{color}' if isinstance(color, int) else '39'
-            background = ''  # theme-agnostic: the cursor row is marked by ▌ + underline, not a fixed color
-            pad = ' ' * max(0, name_width - name_used)
-            close = f'\033[{max(1, cols - 2)}G\033[31m×\033[0m' if entry.get('closable') else ''
-            out.append(f'{background}\033[36m{marker}\033[39m{icon}{icon_pad}\033[{style}{fg}m{name}\033[22;24;39m{pad} '
-                       f'\033[{glyph_color}m{glyph}\033[0m{background}{tail}\033[0m{close}\033[K\r\n')
-        footer_style = '2'
-        if self.renaming:
-            footer = f' Rename: {self.rename_value}█'
-            footer_style = '36'
+            if entry.get('action') == 'new-shell':
+                # ` +  New shell` (spec §4.8): the `new` mark in column 2 (tone-done), the label ink-dim, padded to 35.
+                used_cols = 4 + cell_width('New shell')
+                out.append(f'{cursor}{tone["tone-done"]}{marks["new"]}{reset}  {tone["ink-dim"]}New shell{reset}'
+                           f'{" " * max(0, cols - 1 - used_cols)}\033[K\r\n')
+                continue
+            if entry.get('action'):            # the Add-to-workspace picker's choices and its Cancel
+                label, used_cols = clip(entry['name'], max(1, cols - 4))
+                out.append(f'{cursor}  {tone["tone-done"]}{label}{reset}{" " * max(0, cols - 4 - used_cols)}\033[K\r\n')
+                continue
+            out.append(self.row(entry, index, target, others, cols, now,
+                                'tone-attention' if section == 'needs' else None) + '\033[K\r\n')
+        # The footer ladder (spec §4.6(a)): confirm › rename › promote › (picker) › filter › banner › registry error ›
+        # message › legend. Every prompt has one shape — the `lead` mark, a sentence, `y/n` or the caret — and every
+        # separator, quote, `⏎`, `›` and `⚠` is a mark lookup, so the ASCII footer is seven-bit.
+        lead, caret = g['lead'], ''
+        if self.confirming:
+            footer, footer_style = f" {lead} close {q0}{self.confirming.get('name', '')}{q1}? y/n", tone['tone-urgent']
+        elif self.renaming:
+            footer, footer_style = f' {lead} Rename: {self.rename_value}', tone['ink']
+            caret = f'{tone["tone-working"]}{g["caret"]}{reset}'
         elif self.promoting:
-            name = self.promote_entry.get('name', '') if self.promote_entry else ''
-            footer = f' Promote {name!r} to registered? y/n'
-            footer_style = '33'
+            name = (self.promote_entry or {}).get('name', '')
+            footer, footer_style = f" {lead} Register {q0}{name}{q1}? y/n", tone['tone-attention']
+        elif self.registration:
+            footer, footer_style = ' ' + (self.message or f'Choose a workspace{sep}Esc cancels'), tone['ink-dim']
         elif self.filtering or self.filter:
-            footer = f' /{self.filter}'
-        elif self.banner:   # above everything but the filter being typed: a frozen picture must never look live
-            footer, footer_style = ' ' + self.banner, '33'
+            n = sum(1 for e in entries if not e.get('divider'))
+            footer, footer_style = f' /{self.filter}{sep}{n} match{"es" if n != 1 else ""}', tone['ink']
+        elif self.banner:   # above everything but a prompt and the filter: a frozen picture must never look live
+            footer = ' ' + self.banner
+            footer_style = tone['tone-urgent'] if 'sockets' in self.banner else tone['tone-attention']
         elif self.errors:
-            footer = ' ⚠ registry: ' + self.errors[0]
+            footer, footer_style = f' {g["warning"]} registry: ' + self.errors[0], tone['tone-urgent']
         elif self.message:
-            footer = ' ' + self.message
+            footer, footer_style = ' ' + self.message, tone['ink-dim']
+        elif self.attach_only:   # a remote workspace: nothing to close, no upload strip
+            footer, footer_style = f' {g["enter"]} open{sep}/ find{sep}? keys', tone['ink-dim']
         else:
-            footer = ' ⏎ open · + new · x close · R rename · / find'
-        footer, _ = clip(footer, cols - 1)
+            footer, footer_style = f' {g["enter"]} open{sep}/ find{sep}x close{sep}? keys', tone['ink-dim']
+        footer, _ = clip(footer, cols - (2 if caret else 1))   # the caret takes the last of the 35 cells
+        footer += f'{reset}{caret}' if caret else ''
         if self.box:
-            for line in self.box_lines(cols):
-                out.append(line + '\033[K\r\n')
-        out.append(f'\033[2m{"─" * cols}\033[0m\r\n\033[{footer_style}m{footer}\033[0m\033[K\033[J')
+            out.append(self.strip_line(cols) + '\033[K\r\n')
+        if self.strip_row:   # spec §4.6(c): the fleet economy line first; without one, fleet attention
+            out.append((economy_line or self.fleet_attention(cols - 2)) + '\033[K\r\n')
+        out.append(f'{tone["ink-faint"]}{g["rule"] * cols}{reset}\r\n{footer_style}{footer}{reset}\033[K\033[J')
+        out.append(self.osc_bytes(target))      # title / notification strings: after the footer, same write (§4.9)
         sys.stdout.write(''.join(out))
         sys.stdout.flush()
         self.dirty = False
 
     def render_mobile(self, cols, rows):
-        """Three terminal rows per lane make the entire row a finger-sized touch target."""
-        entries = self.visible()
+        """Three terminal rows per lane make the entire row a finger-sized touch target (spec §4.10): the name with
+        its agent glyph, then `label · age · harness`, then the agent's task."""
+        entries = self.follow()
         self.box = False  # the Mac file-drop helper is not available in a phone browser
         self.entry_top, self.entry_height = 3, 3 if rows >= 8 else 1
         body = max(1, (rows - 3) // self.entry_height)
         self.box_top = self.entry_top + body * self.entry_height
-        self.cursor = max(0, min(self.cursor, len(entries) - 1))
-        self.top = max(0, min(self.top, self.cursor))
+        self.top = max(0, min(self.top, self.cursor, len(entries) - body))   # bounded by the list, as in render()
         if self.cursor >= self.top + body:
             self.top = self.cursor - body + 1
         target = self.current_target()
+        if self.theme_pending and time.monotonic() >= self.theme_deadline:
+            self.apply_theme(self.variant)
         out = ['\033[?25l\033[H']
+        tone, marks = self.tone, self.glyphs['marks']
+        reset = tone['reset']
 
-        def line(value='', style='0', closable=False):
-            value, _ = clip(value, max(1, cols - (5 if closable else 1)))
-            close = f'\033[{max(1, cols - 2)}G\033[31m×\033[0m' if closable else ''
-            out.append(f'\033[{style}m{value}\033[0m{close}\033[K\r\n')
+        def line(value='', style='', closable=False, can_register=False):
+            value, _ = clip(value, max(1, cols - (9 if can_register else 5 if closable else 1)))
+            close = f'\033[{max(1, cols - 2)}G{tone["tone-urgent"]}{marks["close"]}{reset}' if closable else ''
+            add = f'\033[{max(1, cols - 6)}G{tone["tone-done"]}{marks["new"]}{reset}' if can_register else ''
+            out.append(f'{reset}{style}{value}{reset}{add}{close}\033[K\r\n')
 
-        count = sum(not e.get('divider') and not e.get('action') for e in entries)
-        line(f'  LANES  ·  {count}', '1;36')
+        # Header (spec §4.10): the agent counts in words, bold ink — no cyan, no `LANES` banner: the phone shell's own
+        # header carries identity. No agents: ` {n} lanes`, ink-dim, as on the desktop (§4.3).
+        counts = '' if self.registration else self.mobile_counts()
+        if self.registration:
+            line('  ADD TO WORKSPACE', tone['bold'])
+        else:
+            line(counts or f' {len(self.entries)} lanes', tone['ink-dim'] if self.banner or not counts else tone['bold'])
         line()
+        now, sep = time.time(), f' {marks["sep"]} '   # every ` · ` is the sep mark: the ASCII frame stays seven-bit
         for index in range(self.top, self.top + body):
             if index >= len(entries):
                 for _ in range(self.entry_height):
@@ -647,42 +1544,85 @@ class Sidebar:
             entry = entries[index]
             observed = self.status.get(entry['id'], {})
             lane_state = observed.get('state', 'helper' if entry.get('holder') == 'exec' else 'unknown')
-            selected = entry['id'] == target
-            marker = '›' if index == self.cursor else ' '
+            agent = observed.get('agent') if isinstance(observed.get('agent'), dict) else {}
+            status = agent.get('status') if agent.get('status') in AGENT_GLYPHS else None
+            stale = bool(observed.get('stale'))
+            if entry.get('divider'):            # section headers as desktop (§4.4), three rows tall: the touch grid
+                out.append(self.divider_line(entry, cols) + '\033[K\r\n')
+            elif entry.get('action') == 'new-shell':
+                line(f'   {marks["new"]}  New shell', tone['tone-done'])
+            elif entry.get('action'):           # the Add-to-workspace picker's choices and its Cancel
+                line(f'   {entry["name"]}', tone['bold'] + tone['tone-done'])
+            else:
+                # Row A: column 2 the viewing mark (accent), column 3 the agent glyph in its tone (ink-dim while the
+                # status is stale), the name bold in its identity colour. The `›` touch cursor is gone (the cursor
+                # still moves with J/K). The viewer dots are the sidebar's rule, not the desktop render's: the phone
+                # is the one surface where the operator cannot also see the Studio tab (DEF-983).
+                closable = bool(entry.get('closable'))
+                can_register = closable and R.eligible(entry)
+                mark = f'{tone["accent"]}{marks["viewing"]}{reset}' if entry['id'] == target else ' '
+                glyph = ' '
+                if status:
+                    role = 'ink-dim' if stale else tokens.tone_of(AGENT_GLYPHS, status)
+                    glyph = f'{tone[role]}{self.glyphs["agent"][status]}{reset}'
+                viewers = viewer_mark(observed).replace('·', marks['viewer'])
+                width = max(1, cols - 4 - (9 if can_register else 5 if closable else 1) - len(viewers))
+                name, _ = clip(entry.get('name', entry['id']), width)
+                color = entry.get('color')
+                fg = f'\033[38;5;{color}m' if isinstance(color, int) and self.color != 'none' else ''
+                close = f'\033[{max(1, cols - 2)}G{tone["tone-urgent"]}{marks["close"]}{reset}' if closable else ''
+                add = f'\033[{max(1, cols - 6)}G{tone["tone-done"]}{marks["new"]}{reset}' if can_register else ''
+                dots = f'{tone["ink-dim"]}{viewers}{reset}' if viewers else ''
+                out.append(f'{reset} {mark}{glyph} {tone["bold"]}{fg}{name}{reset}{dots}{add}{close}\033[K\r\n')
+            if self.entry_height == 1:
+                continue
             if entry.get('divider'):
-                line('  ' + entry['name'], '2')
-            elif entry.get('action'):
-                line(f'{marker}  New +', '1;32')
+                line(); line()
+                continue
+            # Row B: what the agent needs and since when, and which harness; a shell says its state word and its
+            # output age. Row C: the agent's task, blank for shells. Agent text is pane-title data: control
+            # characters are dropped so a title can never inject a sequence into the frame.
+            task = ''
+            if entry.get('action'):
+                detail = {'new-shell': 'Create a persistent shell', 'register-workspace': 'Add this session',
+                          'cancel-registration': 'Keep unregistered'}.get(entry['action'], '')
+            elif status and status != 'shell':
+                since = agent.get('since')
+                age = age3(now - since if isinstance(since, (int, float)) and since > 0 else None).strip()
+                harness = OSC_UNSAFE.sub('', str(agent.get('harness') or ''))
+                detail = sep.join(part for part in (MOBILE_AGENT_LABELS[status], age, harness) if part)
+                task = OSC_UNSAFE.sub('', str(agent.get('name') or ''))
             else:
-                # The viewer dots are the sidebar's rule, not the desktop render's: the phone is the one
-                # surface where the operator cannot also see the Studio tab, so a lane a browser views has
-                # to say so HERE too (DEF-983).
-                line(f'{marker} {entry.get("icon") or "▧"}  {entry.get("name", entry["id"])}'
-                     + viewer_mark(observed),
-                     '1;32' if selected or entry.get('action') else '1', entry.get('closable', False))
-            if self.entry_height > 1:
-                label = MOBILE_LABELS.get(lane_state, lane_state)
-                detail = ('Viewing · ' if selected else '') + label
-                if entry.get('action'):
-                    detail = 'Create a persistent shell'
-                if observed.get('stale'):
-                    detail += ' · status delayed'
-                line('     ' + detail if not entry.get('divider') else '', '2')
-                line()
+                activity = observed.get('activity')
+                age = age3(now - activity if isinstance(activity, (int, float)) and activity > 0 else None).strip()
+                detail = sep.join(part for part in (MOBILE_LABELS.get(lane_state, lane_state), age) if part)
+            if stale:
+                detail += sep + 'status delayed'
+            line('     ' + detail, tone['ink-dim'])
+            line('     ' + task if task else '', tone['ink-dim'])
         for _ in range(max(0, rows - (2 + body * self.entry_height + 1))):
             line()
-        footer = (' /' + self.filter if self.filtering or self.filter else
+        q0, q1 = marks['quote-open'], marks['quote-close']
+        footer = (f" {marks['lead']} close {q0}{self.confirming.get('name', '')}{q1}? y/n" if self.confirming else
+                  ' ' + (self.message or f'Choose a workspace{sep}Tap Cancel') if self.registration else
+                  ' /' + self.filter if self.filtering or self.filter else
                   ' ' + self.banner if self.banner else
                   ' ' + self.errors[0] if self.errors else
-                  ' ' + self.message if self.message else ' Swipe to scroll · Tap to open')
+                  ' ' + self.message if self.message else f' Swipe to scroll{sep}Tap to open')
         footer, _ = clip(footer, max(1, cols - 1))
-        out.append(f'\033[2m{footer}\033[0m\033[K\033[J')
+        out.append(f'{tone["tone-urgent"] if self.confirming else tone["ink-dim"]}{footer}{reset}\033[K\033[J')
+        out.append(self.osc_bytes(target))      # the phone reads the counts from this pane's title; no OSC 9 here
         sys.stdout.write(''.join(out))
         sys.stdout.flush()
         self.dirty = False
 
     # ---------------------------------------------------------------- input
     def handle(self, data):
+        if isinstance(data, bytes):   # the raw read, as run() gets it from the pty
+            data = data.decode('utf-8', 'replace')
+        # An OSC 11 answer (`\033]11;rgb:…` ST/BEL, possibly split across reads) is a theme, never an Esc: it is taken
+        # out before anything reads the keys, so it cannot cancel a filter or a prompt (spec §2.4, Review Focus 6).
+        data = self.strip_osc(data)
         # Bracketed paste (a drop, or a real paste) can span several reads: buffer until its end marker.
         if self.paste_buffer is not None:
             self.paste_buffer += data
@@ -696,10 +1636,45 @@ class Sidebar:
             self.dropped(pasted)
             self.dirty = True
             data += tail
-        entries = self.visible()
+        entries = self.follow()
         i = 0
         while i < len(data):
+            if self.showing_keys:
+                # spec §4.7: any key closes the key sheet and is consumed, never acted on. Checked per key, not per
+                # read: one read can carry several keys (key repeat, fast typing), so `?j` opens and closes the sheet
+                # with the j consumed, and `?xy` consumes the x — exactly one key or one whole escape sequence each.
+                self.showing_keys, self.dirty = False, True
+                i += key_length(data, i)
+                continue
+            entries = self.follow()   # per key: an action may have changed the list (spec §4.5)
             ch = data[i]
+            if self.confirming is not None:
+                # `y` closes the entry that asked; anything else cancels. A key is consumed by the cancel; an escape
+                # sequence (Esc, an arrow, a click) cancels and is then handled as usual. Only a key or a mouse PRESS
+                # answers: under ?1000h/?1006h the terminal reports the RELEASE that follows every press (the very
+                # release of the `×` click that opened this prompt), and wheel/motion reports are no answer either,
+                # so those are consumed and the prompt stays up.
+                if ch == '\033' and data[i + 1:].startswith('[<'):
+                    rest = data[i + 1:]
+                    end = next((k for k, c in enumerate(rest) if c in 'Mm'), -1)
+                    if end < 0:
+                        break   # an incomplete report is no answer
+                    try:
+                        button = int(rest[2:end].split(';')[0])
+                    except ValueError:
+                        button = -1
+                    if rest[end] == 'm' or (button >= 0 and button & (32 | 64)):
+                        i += end + 2
+                        continue
+                entry, self.confirming, self.dirty = self.confirming, None, True
+                if ch in 'yY':
+                    self.close_lane(entry)
+                    i += 1
+                    continue
+                self.message = 'Cancelled'
+                if ch != '\033':
+                    i += 1
+                    continue
             if ch == '\033':
                 rest = data[i + 1:]
                 if rest.startswith('[<'):  # SGR mouse
@@ -721,8 +1696,13 @@ class Sidebar:
                         index = self.top + (y - self.entry_top) // self.entry_height
                         if 0 <= index < len(entries) and self.entry_top <= y < self.box_top:
                             self.cursor = index
-                            if entries[index].get('closable') and _x >= max(1, self.size[0] - 4):
-                                self.close_lane(entries[index])
+                            if y == self.more_row and not self.mobile:
+                                pass   # `⋮ N more` hides this entry: the click scrolls it into view, never opens it
+                            elif entries[index].get('closable') and _x >= max(1, self.size[0] - 4):
+                                self.request_close(entries[index])
+                            elif (entries[index].get('closable') and R.eligible(entries[index])
+                                  and _x >= max(1, self.size[0] - 8)):
+                                self.start_registration(entries[index])
                             else:
                                 self.open_lane(entries[index])
                     i += end + 2
@@ -736,6 +1716,10 @@ class Sidebar:
                     if entries:
                         self.open_lane(entries[self.cursor])
                     i += 3
+                elif rest[:2] == '[Z':      # Shift-Tab: the previous lane that needs you (a prompt keeps it)
+                    if not (self.renaming or self.promoting):
+                        self.jump_needs_you(-1)
+                    i += 3
                 elif rest[:2] == '[5':
                     self.cursor -= 10; i += 4
                 elif rest[:2] == '[6':
@@ -744,6 +1728,8 @@ class Sidebar:
                     end = next((k for k, c in enumerate(rest[1:], 1) if '@' <= c <= '~'), len(rest) - 1)
                     i += end + 2
                 else:
+                    if self.registration:
+                        self.cancel_registration()
                     if self.armed:
                         self.armed = False
                         self.focus_lane()
@@ -781,13 +1767,15 @@ class Sidebar:
                     self.filter = self.filter[:-1]
                 elif ch.isprintable():
                     self.filter += ch
-                    self.cursor = 0
+                    self.set_cursor(0)   # the top match of the filtered list, not the lane the cursor was on
             elif ch in '\r\n ':
                 if entries:
                     self.open_lane(entries[self.cursor])
             elif ch in '23' and self.viewports > 1:
                 if entries:
                     self.open_lane(entries[self.cursor], SLOTS[int(ch) - 1])
+            elif ch == '\t':  # Tab: the next lane that needs you (spec §4.5)
+                self.jump_needs_you(+1)
             elif ch in 'JK':  # open the next / previous lane relative to the one being shown
                 lanes = [e for e in entries if not e.get('divider')]
                 if lanes:
@@ -806,13 +1794,16 @@ class Sidebar:
             elif ch == 'G':
                 self.cursor = len(entries) - 1
             elif ch == '/':
-                self.filtering, self.filter, self.cursor = True, '', 0
-            elif ch == 'U':
+                self.filtering, self.filter = True, ''
+                self.set_cursor(0)
+            elif ch == 'U' and not self.attach_only:
                 self.armed = True
-            elif ch == '+':
+            elif ch == '+' and not self.registration and not self.attach_only:
                 self.new_shell()
+            elif ch == 'a' and entries:
+                self.start_registration(entries[self.cursor])
             elif ch == 'x' and entries:
-                self.close_lane(entries[min(self.cursor, len(entries) - 1)])
+                self.request_close(entries[min(self.cursor, len(entries) - 1)])
             elif ch == 'R' and entries:
                 entry = entries[min(self.cursor, len(entries) - 1)]
                 self.start_rename(entry)
@@ -821,15 +1812,26 @@ class Sidebar:
                 self.start_promote(entry)
             elif ch == 'r':
                 self.reload(force=True)
+            elif ch == '?':
+                self.showing_keys = True
             self.dirty = True
             i += 1
 
+    def start_bytes(self):
+        """What run() writes once at start: alternate screen, mouse, bracketed paste — and, under LANES_THEME=auto, the
+        ONE OSC 11 background query (spec §2.4: no re-ask; handle() parses the answer, the grace starts now)."""
+        out = '\033[?1049h\033[?1000h\033[?1006h\033[?2004h\033[2J'
+        if self.theme_pending:
+            out += OSC11_QUERY
+            self.theme_deadline = time.monotonic() + THEME_GRACE
+        return out
+
     def run(self):
         fd = sys.stdin.fileno()
         saved = termios.tcgetattr(fd)
         try:
             tty.setraw(fd)
-            sys.stdout.write('\033[?1049h\033[?1000h\033[?1006h\033[?2004h\033[2J')
+            sys.stdout.write(self.start_bytes())
             self.reload(force=True)
             target = self.current_target()
             for index, entry in enumerate(self.visible()):
@@ -847,11 +1849,13 @@ class Sidebar:
                     last_size, self.dirty = size, True
                 self.poll_upload()
                 self.poll_health()
-                if self.upload or self.armed or (self.upload_note and time.time() - self.upload_note_at < 9):
+                self.poll_economy()
+                # An upload in flight no longer forces a frame: poll_upload() dirties on progress and on the end.
+                if self.armed or (self.upload_note and time.time() - self.upload_note_at < 9):
                     self.dirty = True
                 if self.dirty:
                     self.render()
-                ready, _, _ = select.select([fd], [], [], 0.15 if self.upload else 1.0)
+                ready, _, _ = select.select([fd], [], [], self.tick_timeout())
                 if ready:
                     data = os.read(fd, 4096)
                     if not data: