@vibelord/lanes 1.0.1 → 1.0.3

package/payload/lanes/zellij/config.kdl

@@ -1,8 +1,10 @@
 // lanes host view configuration. Generated from the user's coder-launch keybinding scheme
 // (clear-defaults, Ctrl-Alt prefix: every ordinary key reaches the agent). Edit here; this file is versioned.
+// Ctrl-g is never bound (plan Task 19): it reaches the lane (Claude Code opens its editor on it); the lock is
+// Ctrl-Alt-g, in and out, and the LOCKED ribbon turns on-accent-urgent while it is on (spec §5.2).
 keybinds clear-defaults=true {
     normal {
-        bind "Ctrl g" { SwitchToMode "locked"; }
+        bind "Ctrl Alt g" { SwitchToMode "locked"; }
         bind "Ctrl Alt p" { SwitchToMode "pane"; }
         bind "Ctrl Alt t" { SwitchToMode "tab"; }
         bind "Ctrl Alt n" { SwitchToMode "resize"; }
@@ -12,7 +14,7 @@ keybinds clear-defaults=true {
         bind "Ctrl Alt f" { SwitchToMode "scroll"; }
     }
     locked {
-        bind "Ctrl g" { SwitchToMode "normal"; }
+        bind "Ctrl Alt g" { SwitchToMode "normal"; }
     }
     pane {
         bind "left" { MoveFocus "left"; }
@@ -164,19 +166,40 @@ keybinds clear-defaults=true {
         bind "Ctrl Alt End" { ScrollToBottom; SwitchToMode "normal"; }
         bind "Ctrl Alt c" { Copy; }
         bind "Ctrl Alt left" { GoToPreviousTab; }
-        // lanes: workspaces are tabs (Ctrl-Alt-←/→); lanes live in the sidebar. These reach the sidebar
-        // from anywhere in the tab: it opens the previous/next lane (or starts a filter) and hands focus back.
-        //
-        // WHY THREE MoveFocus "left": a workspace tab is [sidebar | view main | view b | view c] (wide views, at most
-        // 3 viewports) and WriteChars types into whichever pane holds the focus BY THEN. One "left" reaches the
-        // sidebar only from `main`; pressed in viewport b or c it stopped on a LANE and the "J"/"K" was typed into
-        // the agent. Three lefts reach the sidebar from every viewport, and zellij does not wrap at the left edge, so
-        // the surplus moves are no-ops. tests/view.py proves both (3 lefts land on the sidebar, a 4th stays there, the
-        // real Ctrl-Alt-Down bytes from viewport 2 put no "J" on any lane). More viewports = more lefts here.
-        // Known limit: a tab WITHOUT a sidebar (Host, Throttle, the mobile view tab) has nothing to the left, so there
-        // the character still goes to the pane itself.
-        bind "Ctrl Alt down" { MoveFocus "left"; MoveFocus "left"; MoveFocus "left"; WriteChars "J"; }
-        bind "Ctrl Alt up" { MoveFocus "left"; MoveFocus "left"; MoveFocus "left"; WriteChars "K"; }
+        // lanes: workspaces are tabs (Ctrl-Alt-←/→); lanes live in the sidebar. Next / previous lane (plan Task 19)
+        // types nothing: `lanes next|prev --focused` points the FOCUSED viewport (the first one when the sidebar has
+        // the focus) at the neighbouring lane of its board, exactly as Enter in the sidebar does, from a floating pane
+        // that closes when it exits. The focus stays where it was. On a tab without a board (Host, Throttle) it does
+        // nothing — the old WriteChars bind typed its "J"/"K" into that tab's pane. "lanes" is found on the view
+        // server's PATH (bin/lanes clean_env), as for Ctrl-Alt-m below.
+        bind "Ctrl Alt down" {
+            Run "lanes" "next" "--focused" {
+                floating true
+                close_on_exit true
+                name "Lanes"
+                x "0%"
+                y "0%"
+                width "1%"
+                height "1%"
+            }
+        }
+        bind "Ctrl Alt up" {
+            Run "lanes" "prev" "--focused" {
+                floating true
+                close_on_exit true
+                name "Lanes"
+                x "0%"
+                y "0%"
+                width "1%"
+                height "1%"
+            }
+        }
+        // These two still hand a key to the SIDEBAR (a filter and the upload box live there, so the focus must end
+        // on it). WHY THREE MoveFocus "left": a workspace tab is [sidebar | view main | view b | view c] (wide views,
+        // at most 3 viewports) and WriteChars types into whichever pane holds the focus BY THEN; three lefts reach
+        // the sidebar from every viewport and zellij does not wrap at the left edge (tests/view.py). Known limit: a
+        // tab WITHOUT a sidebar (Host, Throttle, the mobile view tab) has nothing to the left, so there the
+        // character still goes to the pane itself.
         bind "Ctrl Alt /" { MoveFocus "left"; MoveFocus "left"; MoveFocus "left"; WriteChars "/"; }
         // Arm the sidebar's upload box, then drop files anywhere on the window (a drop = a paste into the focused pane).
         bind "Ctrl Alt u" { MoveFocus "left"; MoveFocus "left"; MoveFocus "left"; WriteChars "U"; }
@@ -188,6 +211,24 @@ keybinds clear-defaults=true {
             }
         }
     }
+    // Markdown preview (spec §5.4): the newest markdown file the focused lane named, in a floating pane that closes
+    // when the pager quits. Both Run forms parse on Zellij 0.45.1 (measured 2026-10-04, DEF-1534); the multi-line
+    // children are the pinned style, and test_ctrl_alt_m_is_the_multi_line_floating_run_block pins them. "lanes"
+    // is found on the view server's PATH
+    // (bin/lanes clean_env: this checkout's bin/), because this file is read in place, never rendered per host.
+    shared_except "locked" {
+        bind "Ctrl Alt m" {
+            Run "lanes" "preview" "--focused" {
+                floating true
+                close_on_exit true
+                name "Preview"
+                x "10%"
+                y "5%"
+                width "80%"
+                height "90%"
+            }
+        }
+    }
     shared_except "normal" "locked" {
         bind "Alt left" { MoveFocusOrTab "left"; }
         bind "Alt down" { MoveFocus "down"; }
@@ -199,7 +240,7 @@ keybinds clear-defaults=true {
         bind "Alt [" { PreviousSwapLayout; }
         bind "Alt ]" { NextSwapLayout; }
         bind "Alt f" { ToggleFloatingPanes; }
-        bind "Ctrl g" { SwitchToMode "locked"; }
+        bind "Ctrl Alt g" { SwitchToMode "locked"; }
         bind "Alt h" { MoveFocusOrTab "left"; }
         bind "Alt i" { MoveTab "left"; }
         bind "Alt j" { MoveFocus "down"; }
@@ -395,6 +436,16 @@ web_client {
     }
 }
 // END lanes tokens
+// Chrome: straight frames to match the sidebar's ─ rules; the session name is noise in a 14-tab bar; simplified_ui
+// removes the compact-bar's Private-Use-Area chevrons — the one glyph the cockpit needed a Nerd Font for. Tabs
+// render as [ Sakio ] ribbons: accent-on-dark for the active one (ribbon_selected), dim-on-raised for the rest.
+ui {
+    pane_frames {
+        rounded_corners false
+        hide_session_name true
+    }
+}
+simplified_ui true
 default_mode "normal"
 mouse_mode true
 copy_clipboard "system"

package/payload/manifest.json

@@ -1,8 +1,8 @@
 {
  "name": "@vibelord/lanes",
- "version": "1.0.1",
- "commit": "7eefe03dd9362ca62d05abd2d23cbc958d6af346",
- "digest": "sha256:09b4d87fb5687fe5e72140baa68f9518ec96cbf9a3b08c55d7f9e99afb55b295",
+ "version": "1.0.3",
+ "commit": "77ee54d454b851134f0aed88534762c8b457b34c",
+ "digest": "sha256:9d8f4e272d733e6405d471bdab9d950615670f41e181c56c96297fe5ed451ced",
  "executables": [
   "bin/lanes",
   "client/install.sh",
@@ -12,11 +12,13 @@
   "client/omarchy/discover.sh",
   "container/lane",
   "container/lane-run",
+  "container/lane-signal",
   "holders/exec.sh",
   "holders/ssh.sh",
   "holders/tmux.sh",
   "holders/zmx.sh",
   "install.sh",
+  "install/enable-studio-host.sh",
   "install/enable-web.sh",
   "install/host-install.sh",
   "libexec/connection.py",

package/payload/lanes/libexec/legacy_sessions.py

@@ -1,130 +0,0 @@
-"""Track pre-persistence Docker shells without pretending their lost Docker connection is reattachable."""
-import json
-import os
-import select
-import signal
-import sys
-import time
-from pathlib import Path
-
-import lanes_lib as L
-
-
-def process(pid):
-    root = Path(L.proc_root()) / str(pid)
-    stat = (root / 'stat').read_text().rsplit(') ', 1)[1].split()
-    return {'pid': int(pid), 'ppid': int(stat[1]), 'sid': int(stat[3]), 'tty': stat[4], 'start': stat[19],
-            'uid': root.stat().st_uid, 'cgroup': (root / 'cgroup').read_text(),
-            'cwd': os.readlink(root / 'cwd'), 'command': (root / 'comm').read_text().strip()}
-
-
-def observe():
-    lanes, groups = {}, {}
-    for path in (L.STATE / 'legacy-sessions').glob('*.json'):
-        entry = L.read_json(path) or {}
-        identity = entry.get('legacy') or {}
-        try:
-            actual = process(identity['pid'])
-            if actual['start'] != identity['start']:
-                continue
-            state = {'state': 'quiet', 'pid': actual['pid'], 'cwd': actual['cwd'],
-                     'command': actual['command'], 'legacy': True}
-        except (FileNotFoundError, ProcessLookupError, KeyError):
-            continue
-        except OSError:
-            state = {'state': 'unknown', 'observed': 'error', 'legacy': True}
-        lanes[entry['id']] = state
-        groups.setdefault(entry['workspace'], []).append(entry)
-        L.atomic_write(L.STATE / 'resolve.dynamic' / entry['id'],
-                       '\n'.join(['exec', entry['container'], 'legacy', entry['id'], entry['name']]) + '\n')
-    return lanes, groups
-
-
-def close(entry):
-    identity = entry.get('legacy') or {}
-    recorded = L.read_json(L.STATE / 'legacy-sessions' / (entry['id'] + '.json')) or {}
-    if recorded.get('legacy') != identity:
-        raise L.LanesError('Legacy shell identity changed; nothing was closed')
-    try:
-        root = process(identity['pid'])
-    except (OSError, KeyError):
-        raise L.LanesError('Legacy shell could not be checked; nothing was closed')
-    if root['start'] != identity['start'] or root['uid'] != os.getuid():
-        raise L.LanesError('Legacy shell changed; nothing was closed')
-    members = {}
-    for path in Path(L.proc_root()).iterdir():
-        if not path.name.isdigit():
-            continue
-        try:
-            candidate = process(path.name)
-            if candidate['uid'] == root['uid'] and candidate['cgroup'] == root['cgroup']:
-                members[candidate['pid']] = candidate
-        except OSError:
-            continue
-    # The root may have exited and its PID been reused while we scanned /proc.
-    # Keep the recorded identity authoritative rather than adopting the scan's replacement.
-    if members.get(root['pid'], {}).get('start') != root['start']:
-        raise L.LanesError('Legacy shell changed or could not be checked; nothing was closed')
-    chosen = {root['pid']} | {pid for pid, p in members.items()
-                            if p['sid'] == root['sid'] and p['tty'] == root['tty'] and root['tty'] != '0'}
-    while True:
-        children = {pid for pid, p in members.items() if p['ppid'] in chosen}
-        if children <= chosen:
-            break
-        chosen.update(children)
-    handles, root_verified = [], False
-    try:
-        for pid in chosen:
-            fd = None
-            try:
-                fd = os.pidfd_open(pid)
-                if process(pid)['start'] != members[pid]['start']:
-                    os.close(fd)
-                    continue
-                handles.append(fd)
-                if pid == root['pid']:
-                    root_verified = True
-            except (OSError, KeyError):
-                if fd is not None:
-                    os.close(fd)
-                continue
-        if not root_verified:
-            raise L.LanesError('Legacy shell could not be checked; nothing was closed')
-        # pidfds remain attached to these processes even if the kernel recycles their numeric pids.
-        for fd in handles:
-            try:
-                signal.pidfd_send_signal(fd, signal.SIGHUP)
-            except ProcessLookupError:
-                pass
-        remaining, deadline = set(handles), time.monotonic() + 2
-        while remaining and time.monotonic() < deadline:
-            ready, _, _ = select.select(list(remaining), [], [], 0.1)
-            remaining.difference_update(ready)
-        for fd in remaining:
-            try:
-                signal.pidfd_send_signal(fd, signal.SIGKILL)
-            except ProcessLookupError:
-                pass
-    finally:
-        for fd in handles:
-            os.close(fd)
-    (L.STATE / 'legacy-sessions' / (entry['id'] + '.json')).unlink(missing_ok=True)
-
-
-def view(container, lane_id):
-    L._require(L.IDENT, lane_id, 'legacy shell')
-    entry = L.read_json(L.STATE / 'legacy-sessions' / (lane_id + '.json')) or {}
-    if entry.get('container') != container:
-        raise L.LanesError('Legacy shell no longer exists')
-    print('\033[2J\033[H\n  ' + entry['name'] + '\n', flush=True)
-    print('  This shell predates persistent terminals. Its original Docker connection cannot be reattached.\n'
-          '  Its shell and running jobs are preserved. Use × in Unregistered to terminate them.\n'
-          '  New + creates a shell you can leave and reopen.\n', flush=True)
-    print('  Container: ' + container + '\n  Process: ' + str(entry['legacy']['pid']), flush=True)
-    while True:
-        time.sleep(30)
-
-
-if __name__ == '__main__':
-    if len(sys.argv) == 4 and sys.argv[1] == 'view':
-        view(sys.argv[2], sys.argv[3])