@vibelord/lanes 1.0.1 → 1.0.3

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-1547 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-1572). 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-1559, 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-1541).
+    reason = CLASS_REASONS.get(L.classify_recipe(recipe))
+    if reason:
+        return reason
     words = _words(recipe)
     if words is None:
         return None