@vibelord/lanes 1.0.0 → 1.0.1

package/payload/lanes/libexec/sidebar.py

@@ -5,7 +5,9 @@ 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)
+  2 / 3 open the lane under the cursor in the 2nd / 3rd viewport (wide view sessions) · x / × close (asks y/n)
+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).
 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).
@@ -23,6 +25,7 @@ import subprocess
 import sys
 import termios
 import time
+from operator import itemgetter
 from pathlib import Path
 import tty
 import unicodedata
@@ -30,8 +33,40 @@ 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. Until Task 22 resolves LANES_COLOR/LANES_THEME per device this is the 16-colour table (the
+# user's own palette); new code paints through role names so Task 22 swaps the table, not the call sites.
+TONE16 = tokens.sgr_table('16', 'dark')
+
+
+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'
+
+
 # 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'),
@@ -113,6 +148,18 @@ PASTE_START, PASTE_END = '\033[200~', '\033[201~'
 
 
 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
+    last_visible = ()           # the list visible() last returned: the one `self.cursor` indexes
+
     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'))
@@ -129,13 +176,22 @@ class Sidebar:
         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.confirming = None
+        self.tone = TONE16
+        # `done` is sticky until the lane is opened from this device: lane id -> the time it was last opened. Read
+        # once here (never per tick: spec §8's stat budget), written only by mark_seen().
+        self.seen_path = os.path.join(STATE, 'clients', device + '.seen.json')
+        seen = read_json(self.seen_path)
+        self.seen = {k: v for k, v in seen.items() if isinstance(k, str) and isinstance(v, (int, float))} \
+            if isinstance(seen, dict) else {}
         self.stamp = (0, 0, 0)
-        self._prev_entry_count = -1      # for scroll memory
         self.size = (0, 0)
         self.dirty = True
         self.message = ''
@@ -161,9 +217,15 @@ class Sidebar:
                  sum(mtime(self.slot_file(slot, 'target')) for slot in SLOTS[:self.viewports]))
         if stamp == self.stamp and not force:
             return
+        # 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. `last_visible` is the list the
+        # cursor indexes (render() and handle() compute it before they use the cursor) — no second sectioning pass.
+        before = self.last_visible
+        cursor_id = before[self.cursor].get('id') if 0 <= self.cursor < len(before) else ''
         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.mobile_titles.update({tool['tab']: tool['view'] for tool in registry.get('tools', [])})
@@ -172,6 +234,7 @@ class Sidebar:
                     self.title = workspace.get('title') or self.workspace
                     self.entries = list(workspace.get('lanes', [])) + list(workspace.get('extras', []))
                     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 {}
@@ -180,12 +243,14 @@ class Sidebar:
             self.zmx = (status.get('zmx') or {}).get(self.workspace, [])
         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.
+        after = self.visible()     # also refreshes last_visible for the next reload
+        if cursor_id:
+            index = next((i for i, e in enumerate(after) 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
 
     def poll_mobile_view(self):
         """One sidebar observes the phone's web client and the first display of each full-width view.
@@ -238,16 +303,131 @@ 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."""
+        since = self.agent_of(lane_id).get('since')
+        disk = read_json(self.seen_path)
+        seen = {k: v for k, v in (disk.items() if isinstance(disk, dict) else ())
+                if isinstance(k, str) and isinstance(v, (int, float))}
+        for key, value in self.seen.items():
+            seen[key] = max(value, seen.get(key, value))
+        seen = {k: v for k, v in seen.items() if k in self.status}
+        seen[lane_id] = max(time.time(), since if isinstance(since, (int, float)) else 0)
+        self.seen = seen
+        try:
+            L.atomic_write(Path(self.seen_path), json.dumps(seen, sort_keys=True) + '\n')
+        except OSError:
+            pass   # the queue still works for this process; only a restart would forget
+
+    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 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
+        return [(k, f'{AGENT_GLYPHS[k][0]}{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())
+
+    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), entry))
+            elif key == 'working':
+                buckets[key].append((INF if since is None else since, entry))
+            else:                    # done: newest first
+                buckets[key].append((INF if since is None else -since, 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))
+                out.append({'id': '', 'divider': True, 'name': f'{title} ({len(bucket)})', 'section': key})
+                out += [entry for _rank, 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
+
+    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 +459,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,6 +473,8 @@ class Sidebar:
         if entry.get('action') == 'new-shell':
             self.new_shell(slot)
             return
+        if self.agent_of(entry['id']):
+            self.mark_seen(entry['id'])     # the one caller (spec §10): opening a lane is looking at it
         target_file, pid_file = self.slot_file(slot, 'target'), self.slot_file(slot, 'pid')
         if self.slot_target(slot) == entry['id']:
             self.focus_lane(slot)
@@ -322,6 +510,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 +547,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-1412).
+            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 +581,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-1411).
+        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 +618,40 @@ 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.cursor, self.top, self.dirty = '', False, 0, 0, True
+
+    def cancel_registration(self):
+        self.registration, self.registration_choices = None, []
+        self.cursor, self.top, self.dirty = 0, 0, True
+
+    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
@@ -527,7 +766,7 @@ class Sidebar:
             self.render_mobile(cols, rows)
             return
         entries = self.visible()
-        self.box = rows >= 14
+        self.box = rows >= 14 and not self.registration and not self.attach_only
         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))
@@ -538,9 +777,20 @@ class Sidebar:
         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')
+        tone, now = self.tone, time.time()
+        # 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}{tone["reset"]}' for status, text in tally)
+        else:
+            painted = f'{tone["ink-dim"]}{right}{tone["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'\033[1m{header}\033[0m{" " * max(1, cols - 1 - used - right_width)}{painted}\033[K\r\n')
         for row in range(body):
             index = self.top + row
             if index >= len(entries):
@@ -548,15 +798,22 @@ class Sidebar:
                 continue
             entry = entries[index]
             if entry.get('divider'):
-                label, used_cols = clip(f'── {entry["name"]} ', cols - 1)
+                section = next((s for s in ATTENTION if s[0] == entry.get('section')), None)
+                if section:   # `── ◆ Needs you (3) ───`: the glyph in its tone, the words and the rule as before
+                    glyph, _ascii, role = AGENT_GLYPHS[section[2]]
+                    label, used_cols = clip(f'── {glyph} {entry["name"]} ', cols - 1)
+                    label = label.replace(glyph, f'\033[0m{tone[role]}{glyph}\033[0m\033[2m', 1)
+                else:
+                    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')
                 continue
             if entry.get('action'):
                 marker = '▌' if index == self.cursor else ' '
-                label, _ = clip(marker + ' New +', cols - 1)
+                label, _ = clip(marker + ' ' + entry['name'], cols - 1)
                 out.append(f'\033[32m{label}\033[0m\033[K\r\n')
                 continue
             observed = self.status.get(entry['id'], {})
+            agent = observed.get('agent') if isinstance(observed.get('agent'), dict) else {}
             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
@@ -564,40 +821,51 @@ class Sidebar:
             tail = ' '
             if observed.get('stale') and glyph != '?':
                 glyph_color, tail = '2;' + glyph_color, '\033[2m?'
+            elif agent.get('status') in AGENT_GLYPHS:
+                glyph_color = '2'     # the agent glyph carries the tone; the stream glyph stays readable, dimmed
+            # Column 2 (spec §3/§4.2): what the harness is doing, in its tone; ink-dim when stale; blank for a shell.
+            agent_cell = ' '
+            if agent.get('status') in AGENT_GLYPHS:
+                agent_glyph, _ascii, agent_role = AGENT_GLYPHS[agent['status']]
+                agent_role = 'ink-dim' if observed.get('stale') else agent_role
+                agent_cell = f'{tone[agent_role]}{agent_glyph}{tone["reset"]}'
             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)
+            can_register = entry.get('closable') and R.eligible(entry)
+            # 5 cells more than before go to the agent cell (1) and the age (4): the `+`/`×` columns do not move.
+            name_width = max(1, cols - (21 if can_register else 17 if entry.get('closable') else 14))
+            # Every row says how long (spec principle 7): the agent's `since` when it has one, else the last output.
+            since = agent.get('since') if agent.get('status') in AGENT_GLYPHS else observed.get('activity')
+            age = age3(int(now - since) if isinstance(since, (int, float)) and since > 0 else None)
+            name, name_used = clip(entry.get('name', entry['id']) + shown, 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')
+            add = f'\033[{max(1, cols - 6)}G\033[32m+\033[0m' if can_register else ''
+            age_role = 'tone-attention' if agent.get('status') in ATTENTION[0][3] else 'ink-dim'
+            out.append(f'{background}\033[36m{marker}\033[39m{agent_cell}{icon}{icon_pad}\033[{style}{fg}m{name}\033[22;24;39m{pad} '
+                       f'{tone[age_role]}{age}{tone["reset"]} '
+                       f'\033[{glyph_color}m{glyph}\033[0m{background}{tail}\033[0m{add}{close}\033[K\r\n')
         footer_style = '2'
-        if self.renaming:
+        if self.confirming:   # spec §4.6(a): the destructive confirm tops the footer ladder, one prompt shape
+            footer = f" › close ‘{self.confirming.get('name', '')}’? y/n"
+            footer_style = '31'
+        elif self.renaming:
             footer = f' Rename: {self.rename_value}█'
             footer_style = '36'
         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'
+        elif self.registration:
+            footer = ' ' + (self.message or 'Choose a workspace · Esc cancels')
         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
@@ -607,7 +875,7 @@ class Sidebar:
         elif self.message:
             footer = ' ' + self.message
         else:
-            footer = ' ⏎ open · + new · x close · R rename · / find'
+            footer = ' Enter open · j/k select' if self.attach_only else ' ⏎ open · a add · x close · R rename · + new'
         footer, _ = clip(footer, cols - 1)
         if self.box:
             for line in self.box_lines(cols):
@@ -631,13 +899,14 @@ class Sidebar:
         target = self.current_target()
         out = ['\033[?25l\033[H']
 
-        def line(value='', style='0', closable=False):
-            value, _ = clip(value, max(1, cols - (5 if closable else 1)))
+        def line(value='', style='0', 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\033[31m×\033[0m' if closable else ''
-            out.append(f'\033[{style}m{value}\033[0m{close}\033[K\r\n')
+            add = f'\033[{max(1, cols - 6)}G\033[32m+\033[0m' if can_register else ''
+            out.append(f'\033[{style}m{value}\033[0m{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')
+        line('  ADD TO WORKSPACE' if self.registration else f'  LANES  ·  {count}', '1;36')
         line()
         for index in range(self.top, self.top + body):
             if index >= len(entries):
@@ -652,37 +921,43 @@ class Sidebar:
             if entry.get('divider'):
                 line('  ' + entry['name'], '2')
             elif entry.get('action'):
-                line(f'{marker}  New +', '1;32')
+                line(f'{marker}  {entry["name"]}', '1;32')
             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))
+                     '1;32' if selected or entry.get('action') else '1', entry.get('closable', False),
+                     entry.get('closable') and R.eligible(entry))
             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'
+                    detail = {'new-shell': 'Create a persistent shell', 'register-workspace': 'Add this session',
+                              'cancel-registration': 'Keep unregistered'}.get(entry['action'], '')
                 if observed.get('stale'):
                     detail += ' · status delayed'
                 line('     ' + detail if not entry.get('divider') else '', '2')
                 line()
         for _ in range(max(0, rows - (2 + body * self.entry_height + 1))):
             line()
-        footer = (' /' + self.filter if self.filtering or self.filter else
+        footer = (f" › close ‘{self.confirming.get('name', '')}’? y/n" if self.confirming else
+                  ' ' + (self.message or 'Choose a workspace · 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')
         footer, _ = clip(footer, max(1, cols - 1))
-        out.append(f'\033[2m{footer}\033[0m\033[K\033[J')
+        out.append(f'\033[{"31" if self.confirming else "2"}m{footer}\033[0m\033[K\033[J')
         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')
         # 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
@@ -699,7 +974,36 @@ class Sidebar:
         entries = self.visible()
         i = 0
         while i < len(data):
+            entries = self.visible()
+            self.cursor = max(0, min(self.cursor, len(entries) - 1))
             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
@@ -722,7 +1026,10 @@ class Sidebar:
                         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])
+                                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
@@ -744,6 +1051,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()
@@ -807,12 +1116,14 @@ class Sidebar:
                 self.cursor = len(entries) - 1
             elif ch == '/':
                 self.filtering, self.filter, self.cursor = True, '', 0
-            elif ch == 'U':
+            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)