@vibelord/lanes 1.0.1 → 1.0.2

package/payload/lanes/docs/SHARING.md

@@ -91,7 +91,7 @@ clears on its next refresh. Previously read output cannot be recalled.
 ## What viewers can see
 
 - The selected workspace's current and future **registered lanes**. Unregistered
-  sessions, legacy shells, extra/tool tabs and unrelated workspaces are excluded.
+  sessions, tool tabs and unrelated workspaces are excluded.
 - Lane names and observed activity; “active” describes recent terminal output,
   not a build verdict.
 - For tmux lanes, a selectable pane and its latest 2,000 lines, capped at

package/payload/lanes/holders/exec.sh

@@ -1,13 +1,10 @@
 #!/bin/sh
 # View-owned displays; interactive shells are persistent tmux sessions created by New +.
-# usage: exec.sh <container> monitor|legacy [cwd-or-id]
+# usage: exec.sh <container> monitor [cwd]   (the `legacy` view of pre-persistence Docker shells was retired by
+# plan Task 19: a leftover `exec … legacy` resolve file now ends as an unknown helper, and `lanes gc` removes it)
 set -u
 container=${1:-} kind=${2:-} cwd=${3:-/home/coder}
 case "$container" in ''|-*|*[!A-Za-z0-9_.-]*) echo 'invalid container' >&2; exit 64 ;; esac
-if [ "$kind" = legacy ]; then
-    repo=$(cd "$(dirname "$0")/.." && pwd)
-    exec python3 -S -E "$repo/libexec/legacy_sessions.py" view "$container" "$cwd"
-fi
 case "$cwd" in /*) ;; *) cwd=/home/coder ;; esac
 case "$cwd" in *[!A-Za-z0-9_./-]*) cwd=/home/coder ;; esac
 common="-it -u coder -e TERM=xterm-256color -e COLORTERM=truecolor -e LANG=C.UTF-8"

package/payload/lanes/holders.lock

@@ -3,3 +3,6 @@
 # zellij 0.45.1: tarball digest matches GitHub's asset digest; inner binary d006c521…19dd matches the published .sha256sum.
 zellij 0.45.1 40bcc2e03f5d5ae8e054e39f676081fe12ab70871506996ba595834c3718eefc https://github.com/zellij-org/zellij/releases/download/v0.45.1/zellij-x86_64-unknown-linux-musl.tar.gz
 zmx 0.8.1 dfd75720b942466f28870731cc86dbc07afa72fb8f3bd5eeb4ff707e4eecebe8 https://github.com/neurosnap/zmx/releases/download/v0.8.1/zmx-0.8.1-linux-x86_64.tar.gz
+# glow 3.0.0 (markdown preview, `lanes preview`): tarball digest matches GitHub's asset digest and the release's checksums.txt;
+# the binary sits in glow_3.0.0_Linux_x86_64/. Installed only when no glow is on PATH; without either, the preview uses less -R.
+glow 3.0.0 13e05e4b2acc18d2aee44291aefe6325b077ec321b631a0cfa780e8e3bc33f78 https://github.com/charmbracelet/glow/releases/download/v3.0.0/glow_3.0.0_Linux_x86_64.tar.gz

package/payload/lanes/install/host-install.sh

@@ -34,10 +34,15 @@ fi
 share=${LANES_SHARE:-$HOME/.local/share/lanes}
 state=${LANES_STATE:-$HOME/.local/state/lanes}
 mkdir -p "$share/bin" "$share/dl" "$state/flags"
+# The view server's PATH (bin/lanes clean_env): the Run pane that renders `lanes preview` sees this, never the
+# installer's PATH, so a glow in ~/.local/bin or ~/go/bin does not count as installed.
+pane_path=$share/bin:$repo/bin:/usr/local/bin:/usr/bin:/bin
 grep -v '^#' "$repo/holders.lock" | while read -r name version sha url; do
     [ -n "$name" ] || continue
     target=$share/bin/$name-$version
     if [ -x "$target" ]; then echo "ok  $name $version"; continue; fi
+    # The markdown preview's renderer is optional: a glow the pane can find serves `lanes preview` as well.
+    if [ "$name" = glow ] && system_glow=$(PATH=$pane_path; command -v glow); then echo "ok  glow (system: $system_glow)"; continue; fi
     archive=$share/dl/$(basename "$url")
     curl -fsSL --retry 3 -o "$archive" "$url"
     actual=$(sha256sum "$archive" | cut -d' ' -f1)
@@ -45,7 +50,11 @@ grep -v '^#' "$repo/holders.lock" | while read -r name version sha url; do
     temporary=$(mktemp -d)
     trap 'rm -rf "$temporary"' EXIT HUP INT TERM
     tar -xzf "$archive" -C "$temporary"
-    install -m 0755 "$temporary/$name" "$target"
+    binary=$temporary/$name
+    # zellij and zmx ship the binary at the top of the tarball; glow nests it in glow_<version>_Linux_x86_64/.
+    [ -f "$binary" ] || binary=$(find "$temporary" -type f -name "$name" | head -n 1)
+    [ -n "$binary" ] && [ -f "$binary" ] || { echo "no $name binary in $archive" >&2; exit 1; }
+    install -m 0755 "$binary" "$target"
     rm -rf "$temporary"
     trap - EXIT HUP INT TERM
     echo "installed $target"

package/payload/lanes/install/services.py

@@ -14,7 +14,28 @@ def unit_value(value, command=False):
     return value.replace('$', '$$') if command else value
 
 
-def register(repo, home, share, state, workspaces=None):
+# The opt-in economy poller's settings (libexec/economy_poll.py). Rendered into lanes-economy.service only, and only
+# when set in the installer's environment; the unit itself is never enabled by an install (operator gate).
+ECONOMY_SETTINGS = ('LANES_THROTTLE_CONTROL', 'LANES_THROTTLE_TOKEN_FILE', 'LANES_THROTTLE_LOG_DIR',
+                    'LANES_THROTTLE_CONTAINER')
+ECONOMY_UNITS = ('lanes-economy.service',)
+# The opt-in push notifier's config path (libexec/notify.py), rendered into lanes-notify.service only and only when
+# set in the installer's environment (a config FILE path; the ntfy token stays in the file its token_file names).
+NOTIFY_SETTINGS = ('LANES_NOTIFY_CONF',)
+NOTIFY_UNITS = ('lanes-notify.service',)
+
+
+def economy_settings(environ):
+    """The non-empty LANES_THROTTLE_* settings of `environ` (a token FILE path, never a token)."""
+    return {name: environ[name] for name in ECONOMY_SETTINGS if environ.get(name)}
+
+
+def notify_settings(environ):
+    """The non-empty LANES_NOTIFY_* settings of `environ`."""
+    return {name: environ[name] for name in NOTIFY_SETTINGS if environ.get(name)}
+
+
+def register(repo, home, share, state, workspaces=None, economy=None, notify=None):
     repo, home, share, state = (Path(p).resolve() for p in (repo, home, share, state))
     current = home / '.local/share/lanes/current'
     links = ((current, repo), (home / '.local/bin/lanes', repo / 'bin/lanes'))
@@ -25,6 +46,10 @@ def register(repo, home, share, state, workspaces=None):
     if workspaces:
         settings.append(('LANES_WORKSPACES', Path(workspaces).resolve()))
     environment = ''.join(f'Environment="{name}={unit_value(value)}"\n' for name, value in settings)
+    economy_environment = ''.join(f'Environment="{name}={unit_value(value)}"\n'
+                                  for name, value in sorted((economy or {}).items()) if name in ECONOMY_SETTINGS)
+    notify_environment = ''.join(f'Environment="{name}={unit_value(value)}"\n'
+                                 for name, value in sorted((notify or {}).items()) if name in NOTIFY_SETTINGS)
     rendered = {}
     for source in sorted((repo / 'systemd').iterdir()):
         if source.name.startswith('.') or source.suffix not in ('.service', '.timer', '.slice') or not source.is_file():
@@ -33,7 +58,9 @@ def register(repo, home, share, state, workspaces=None):
         content = content.replace('@SHARE@', unit_value(share, command=True))
         content = content.replace('@CADDY@', unit_value(shutil.which('caddy') or '/usr/bin/caddy', command=True))
         if '[Service]\n' in content:
-            content = content.replace('[Service]\n', '[Service]\n' + environment, 1)
+            extra = (economy_environment if source.name in ECONOMY_UNITS else
+                     notify_environment if source.name in NOTIFY_UNITS else '')
+            content = content.replace('[Service]\n', '[Service]\n' + environment + extra, 1)
         rendered[source.name] = '# Generated by lanes/install/services.py; re-run the server installer to update.\n' + content
     units = home / '.config/systemd/user'
     units.mkdir(parents=True, exist_ok=True)
@@ -58,4 +85,4 @@ if __name__ == '__main__':
     register(Path(__file__).resolve().parents[1], Path.home(),
              os.environ.get('LANES_SHARE', Path.home() / '.local/share/lanes'),
              os.environ.get('LANES_STATE', Path.home() / '.local/state/lanes'),
-             os.environ.get('LANES_WORKSPACES'))
+             os.environ.get('LANES_WORKSPACES'), economy_settings(os.environ), notify_settings(os.environ))

package/payload/lanes/install.sh

@@ -16,6 +16,8 @@
 #   --coder-launch    also provide the command name `coder-launch` (an existing one is kept as coder-launch-legacy)
 #   --no-desktop      skip desktop integration (Lanes.app / .desktop entry / Hyprland key binding)
 #   --no-uploads      skip the uploads watch folder and the upload helper service
+#   --palette         give the lanes window the cockpit's own Ghostty palette instead of your everyday theme
+#                     (off by default; a re-run without it puts the inherited look back)
 #   --yes             never prompt (a new key is then created WITHOUT a passphrase)
 #
 # Exit status: 0 ready to use · 3 installed, but this machine's key is not authorized on the server yet ·
@@ -35,7 +37,7 @@ stamp=$(date -u +%Y%m%dT%H%M%SZ)
 label=ai.beyondwork.lanes-upload
 helper_label=ai.beyondwork.lanes-helper
 
-mode=install device= key= site_file=$here/site/site.conf link=0 coder_launch=0 desktop=1 uploads=1 assume_yes=0
+mode=install device= key= site_file=$here/site/site.conf link=0 coder_launch=0 desktop=1 uploads=1 assume_yes=0 palette=0
 [ -r "$site_file" ] || site_file=$config/client-site.conf
 while [ $# -gt 0 ]; do
     case "$1" in
@@ -48,8 +50,9 @@ while [ $# -gt 0 ]; do
         --coder-launch) coder_launch=1 ;;
         --no-desktop) desktop=0 ;;
         --no-uploads) uploads=0 ;;
+        --palette) palette=1 ;;
         --yes|-y) assume_yes=1 ;;
-        -h|--help) sed -n '2,22p' "$0"; exit 0 ;;
+        -h|--help) sed -n '2,24p' "$0"; exit 0 ;;
         *) echo "install.sh: unknown option $1 (see --help)" >&2; exit 1 ;;
     esac
     shift
@@ -214,6 +217,108 @@ install_client() {
       cat "$target/ghostty/common.conf"
       if [ "$os" = Darwin ]; then cat "$target/ghostty/macos.conf"; else cat "$target/ghostty/omarchy.conf"; fi
     } > "$config/ghostty.conf"
+    install_palette
+}
+
+# The Ghostty binary, for its version only: on PATH, else inside the macOS app bundle.
+ghostty_bin() {
+    if command -v ghostty >/dev/null 2>&1; then command -v ghostty; return 0; fi
+    for app in /Applications/Ghostty.app "$HOME/Applications/Ghostty.app"; do
+        [ -x "$app/Contents/MacOS/ghostty" ] && { printf '%s' "$app/Contents/MacOS/ghostty"; return 0; }
+    done
+    return 1
+}
+# Ghostty >= 1.1 reads `theme = light:…,dark:…` (with absolute theme paths); unknown or older = no.
+ghostty_pairs_themes() {
+    gb=$(ghostty_bin) || return 1
+    ver=$("$gb" +version 2>/dev/null | sed -n '1s/^Ghostty \([0-9][0-9]*\)\.\([0-9][0-9]*\).*/\1 \2/p')
+    [ -n "$ver" ] || return 1
+    # shellcheck disable=SC2086  # split "MAJOR MINOR" into two words on purpose
+    set -- $ver
+    [ "$1" -gt 1 ] || { [ "$1" -eq 1 ] && [ "$2" -ge 1 ]; }
+}
+# Ghostty applies a `theme` UNDER every colour key set explicitly anywhere in the loaded configuration, whatever the
+# file order (Config.zig `loadTheme`: the theme loads, then the configuration is replayed over it). The lanes window
+# includes the everyday config first, so when that config — or a file it reaches through `config-file` (Omarchy: the
+# current theme's ghostty.conf) — sets a colour key, a theme pair would be a silent no-op.
+# And Ghostty loads `config-file` entries as ONE first-in-first-out list (Config.zig `loadRecursiveFiles` iterates the
+# list while each loaded file appends its own includes to the end): breadth-first, so a file two includes deep loads
+# after every direct include of the lanes ghostty.conf — the palette included there last included. Last assignment wins.
+# Walks the include graph from $1 the same way (bounded at 64 entries, cycle-safe: a repeat is skipped as Ghostty skips
+# it; `?`, quotes, `~/` and paths relative to the including file as Ghostty reads them) and sets
+#   ec_colour = the first file (in Ghostty's load order) that sets a colour key, empty when none does;
+#   ec_depth  = the deepest include depth of an existing file ($1 = 0, its direct includes = 1).
+scan_everyday_chain() {
+    ec_nl='
+'
+    ec_tab=$(printf '\t')
+    ec_queue="0$ec_tab$1$ec_nl" ec_seen=$ec_nl ec_n=0 ec_colour='' ec_depth=0
+    while [ -n "$ec_queue" ] && [ "$ec_n" -lt 64 ]; do
+        ec_e=${ec_queue%%"$ec_nl"*}; ec_queue=${ec_queue#*"$ec_nl"}; ec_n=$((ec_n + 1))
+        ec_d=${ec_e%%"$ec_tab"*}; ec_f=${ec_e#*"$ec_tab"}
+        case "$ec_seen" in *"$ec_nl$ec_f$ec_nl"*) continue ;; esac
+        ec_seen="$ec_seen$ec_f$ec_nl"
+        [ -f "$ec_f" ] && [ -r "$ec_f" ] || continue
+        [ "$ec_d" -gt "$ec_depth" ] && ec_depth=$ec_d
+        if [ -z "$ec_colour" ] && grep -Eq '^[[:space:]]*(background|foreground|palette|cursor-color|cursor-text|selection-background|selection-foreground)[[:space:]]*=' "$ec_f"; then
+            ec_colour=$ec_f
+        fi
+        ec_dir=$(dirname "$ec_f") ec_c=$((ec_d + 1))
+        ec_incs=$(sed -n 's/^[[:space:]]*config-file[[:space:]]*=[[:space:]]*//p' "$ec_f" \
+            | sed -e 's/[[:space:]]*$//' -e 's/^?//' -e 's/^"\(.*\)"$/\1/' -e 's/^?//')
+        while IFS= read -r ec_inc; do
+            case "$ec_inc" in
+                '') ;;
+                '~/'*) ec_queue="$ec_queue$ec_c$ec_tab$HOME/${ec_inc#"~/"}$ec_nl" ;;
+                /*) ec_queue="$ec_queue$ec_c$ec_tab$ec_inc$ec_nl" ;;
+                *) ec_queue="$ec_queue$ec_c$ec_tab$ec_dir/$ec_inc$ec_nl" ;;
+            esac
+        done <<EOF
+$ec_incs
+EOF
+    done
+}
+# --palette (spec §7): the cockpit tokens instead of the everyday theme. Two rules make it win:
+#  1. ORDER — the include is the last line of ghostty.conf, hence the last depth-1 entry of Ghostty's breadth-first
+#     list; the palette keys go in a chain of one-include hop files (ghostty-palette.conf → ghostty-palette.1.conf → …)
+#     so they sit at the everyday chain's deepest depth, where they are the last entry of that depth (every hop is its
+#     parent's only include) and nothing loads later. Omarchy's theme file sits two deep: one hop.
+#  2. KIND — a theme pair loses to ANY explicit colour key in the everyday chain (above), so the pair is installed only
+#     when that chain sets none; otherwise the explicit dark palette (last assignment wins) and `say` names the file.
+# Both rules are read from Ghostty's source, not observed on a running Ghostty here (DEF-1466 holds the live check).
+# Without the flag the include is absent and every earlier palette file is removed: inherit-first is the default.
+install_palette() {
+    rm -f "$config"/ghostty-palette*.conf
+    [ "$palette" = 1 ] || return 0
+    scan_everyday_chain "$config/ghostty.conf"
+    hops=0; [ "$ec_depth" -gt 1 ] && hops=$((ec_depth - 1))
+    keys="$config/ghostty-palette.conf" i=0
+    while [ "$i" -lt "$hops" ]; do
+        i=$((i + 1))
+        printf '%s\n' "# lanes palette hop $i of $hops (install.sh --palette): Ghostty loads includes breadth-first, so the palette" \
+            '# keys sit as deep as the everyday config'"'"'s deepest include and load after it.' \
+            "config-file = ?$config/ghostty-palette.$i.conf" > "$keys"
+        keys="$config/ghostty-palette.$i.conf"
+    done
+    cp "$target/ghostty/lanes-palette-light.conf" "$config/ghostty-palette-light.conf"
+    if ghostty_pairs_themes; then
+        if [ -n "$ec_colour" ]; then
+            cp "$target/ghostty/lanes-palette.conf" "$keys"
+            variant="dark only: $(tilde "$ec_colour") sets colours explicitly, which would override a light/dark theme pair (light variant: ghostty-palette-light.conf)"
+        else
+            # Both as theme files: explicit colours in the included file would override the pair, so it holds only this.
+            cp "$target/ghostty/lanes-palette.conf" "$config/ghostty-palette-dark.conf"
+            printf '%s\n' '# lanes cockpit palette (install.sh --palette): follows the system light/dark setting.' \
+                "theme = light:$config/ghostty-palette-light.conf,dark:$config/ghostty-palette-dark.conf" > "$keys"
+            variant='light and dark, following the system'
+        fi
+    else
+        cp "$target/ghostty/lanes-palette.conf" "$keys"
+        variant='dark (Ghostty 1.1+ follows the system; light variant: ghostty-palette-light.conf)'
+    fi
+    [ "$hops" -gt 0 ] && variant="$variant; $hops include hop(s) deep, after the everyday config's deepest include (depth $ec_depth)"
+    printf '\n# palette (install.sh --palette): the cockpit tokens instead of the everyday theme; remove with a plain re-run\nconfig-file = ?%s/ghostty-palette.conf\n' "$(tilde "$config")" >> "$config/ghostty.conf"
+    say "Ghostty palette: lanes tokens, $variant"
 }
 
 find_terminal() {
@@ -591,7 +696,7 @@ do_uninstall() {
     rm -rf "$share/client" "$state"
     # A Linux account can run both roles. Keep server catalogs and any files
     # the client did not create in the shared configuration directory.
-    rm -f "$config/device" "$config/ghostty.conf" "$config"/ghostty.*.conf \
+    rm -f "$config/device" "$config/ghostty.conf" "$config"/ghostty.*.conf "$config"/ghostty-palette*.conf \
         "$config/client-site.conf" "$config/client-known-hosts" "$config/site.cache" \
         "$config/upload-allow" "$config/uploads-dir" "$config/upload-watch.log"
     rmdir "$config" 2>/dev/null || :

package/payload/lanes/libexec/agent_state.py

@@ -187,6 +187,38 @@ def claude_sessions(sessions_dir, proc_root):
     return out
 
 
+def read_sidecar_dict(d, now, max_age, proc_root=None):
+    """A hook-written sidecar (`~/.lz/state/hooks/<lane id>.json`, container `lane-signal`), or None when it is not
+    ours, malformed, older than `max_age` seconds, or written by an agent that no longer runs — an hour-old hook state
+    loses to the live signals (`merge` falls through to the session file / title).
+
+    Freshness is the LAST event (`at`; `since` when a writer predates `at`), while `since` is when the status began:
+    a `working` stretch re-signalled by every tool call keeps its start. lane-run's `{phase, exit, at, pid}` records
+    live one directory up and are never a sidecar (no `v`; the two writers never share a file name, DEF-1436). With
+    `proc_root` (the container's /proc as the host sees it) a recorded `pid` must be live and, when the writer
+    recorded `start`, still be the same process (field 22 of /proc/<pid>/stat, as `claude_sessions` checks Claude's
+    `procStart`): a crashed agent's last word is never published. `pid` 0 means the writer could not name its agent;
+    freshness alone then decides."""
+    if not isinstance(d, dict) or d.get('v') != 1 or d.get('status') not in STATUSES:
+        return None
+    try:
+        since = int(d.get('since') or 0)
+        at = int(d.get('at') or since)
+        pid = int(d.get('pid') or 0)
+    except (TypeError, ValueError):
+        return None
+    if since <= 0 or now - at > max_age:
+        return None
+    if proc_root is not None and pid > 0:
+        if not os.path.exists(os.path.join(proc_root, str(pid))):
+            return None
+        if d.get('start') is not None and not _same_process(proc_root, str(pid), d['start']):
+            return None
+    return {'harness': str(d.get('harness') or ''), 'status': d['status'], 'since': since,
+            'name': str(d.get('name') or ''), 'session_id': str(d.get('session') or ''),
+            'pid': pid, 'source': 'hook', 'event': str(d.get('event') or '')}
+
+
 def merge(pane_row, claude_by_pane, sidecar):
     """Precedence: hook sidecar (event-driven, both harnesses) > Claude session file > Codex title > bell.
     Any Codex title — idle, spinner or Action Required, bell or not — over a bare-shell pane whose shell has no

package/payload/lanes/libexec/cursor_sync.py

@@ -14,13 +14,14 @@ Text is edited minimally (command strings replaced in place, the `lanes` block i
 git diffs stay small. Dry-run by default: prints a unified diff. `--write` applies (with a timestamped backup).
 
 `--canonicalize` additionally replaces every tmux lane's `create` that cannot create the lane — null, attach-only
-(`attach-session` without `new`), or naming a script that is missing in the container — with
+(`attach-session` without `new`), naming the retired in-container coder-launch config (the three classes `lanes
+doctor` warns about), or naming a script that is missing in the container — with
 `lanes_lib.canonical_recipe()` (the recorded binding + the repository folder + `bash -l`), which is also what gives a
 NEW lane its identity (LANE_ID, LANE_WS, the lanes/<ws>/<id> trace). `--identity` additionally gives a WORKING
 recipe of the plain shape `[exec] tmux -L <socket> new -ADs <session> [-c <dir>] <command…>` the same identity
 (`plain_tmux_new`: the command argv is kept, only the `-e` flags are added); any other working recipe is left
 alone and its lane carries no identity. The old value is kept as `createPrevious` in both cases. Identity reaches a
-tmux lane ONLY through these `-e` flags: `lane open` never exports it (DEF-1422, lanes/docs/ARCHITECTURE.md).
+tmux lane ONLY through these `-e` flags: `lane open` never exports it (DEF-1478, lanes/docs/ARCHITECTURE.md).
 Boards whose registry lives outside a repository are additionally PROJECTED into the file Cursor
 reads for that folder, named by `"cursor": "<path>"` on the repository entry of the workspace manifest.
 """
@@ -45,6 +46,8 @@ ATTACH_VERBS = {'attach-session'[:n] for n in range(1, 15)}             # tmux t
 NEW_VERBS = {'new-session'[:n] for n in range(3, 12)}
 TMUX_OPTION_ARGS = {'-L', '-S', '-f', '-T', '-c'}
 SCRIPT_SUFFIXES = ('.sh', '.bash', '.py', '.js', '.mjs', '.cjs', '.rb', '.pl')
+CLASS_REASONS = {'null': 'no create recipe', 'attach-only': 'attach-only',
+                 'retired-path': 'retired coder-launch path'}
 
 
 def _words(text, depth=3):
@@ -79,6 +82,11 @@ def needs_canonical(create, folder, exists):
     if not isinstance(create, str) or not create.strip():
         return 'no create recipe'
     recipe = create.replace('${workspaceFolder}', folder).replace('[workspaceFolder]', folder)
+    # Every class `lanes doctor` warns about (lanes_lib.classify_recipe: null, attach-only, retired-path) is one this
+    # repairs, read by the same parser, so the doctor's "fix with --canonicalize" is never a no-op (DEF-1460).
+    reason = CLASS_REASONS.get(L.classify_recipe(recipe))
+    if reason:
+        return reason
     words = _words(recipe)
     if words is None:
         return None