Add project bind to select ~/Projects

agent-cmd.sh

@@ -1,76 +0,0 @@
-#!/usr/bin/env bash
-# Detect available agents, prompt with fzf, run the selected one.
-# Detaches the client if all panes in the window are dead afterwards.
-
-agents=()
-agent_names=(
-  claude
-  pi
-  opencode
-  codex
-  agy
-)
-for agent_name in ${agent_names[@]}; do
-  command -v $agent_name &>/dev/null && agents+=($agent_name)
-done
-
-if [ ${#agents[@]} -eq 0 ]; then
-  echo "No agent commands found (claude, opencode, gemini)"
-  exit 1
-fi
-
-# This runs as the window's default-command, which tmux starts *before* the
-# popup client attaches. Until then the pane keeps a stale default size (often
-# 80x24), so wait for the attach before measuring — otherwise fzf is sized
-# against the wrong dimensions and renders far too small.
-for _ in $(seq 1 100); do
-  [ "$(tmux display-message -p '#{session_attached}')" -gt 0 ] && break
-  sleep 0.02
-done
-
-# Minimize fzf prompt size while centering it, using the real pane dimensions.
-width=24
-height=$((${#agents[@]} + 6))
-cols=$(tmux display-message -p '#{pane_width}')
-lines=$(tmux display-message -p '#{pane_height}')
-hmargin=$(((cols - width) / 2))
-vpad=$(((lines - height) / 2))
-[ $hmargin -lt 0 ] && hmargin=0
-[ $vpad -lt 0 ] && vpad=0
-tput cup "$vpad" 0
-
-agent=$(printf '%s\n' "${agents[@]}" | fzf \
-  --prompt='agent> ' \
-  --reverse \
-  --border=rounded \
-  --height="$height" \
-  --margin="0,$hmargin" \
-  --padding=1)
-
-# Reset cursor so the agent doesn't render starting where fzf left it.
-tput cup 0 0
-tput ed
-
-if [ -n "$agent" ]; then
-  "$agent" || true
-fi
-
-# Brief delay to let tmux update pane status
-sleep 0.1
-
-window_id=$(tmux display-message -p '#{window_id}')
-my_pane=$(tmux display-message -p '#{pane_id}')
-
-# Count live sibling panes (not us, not dead)
-other_live=$(tmux list-panes -t "$window_id" -F '#{pane_id} #{pane_dead}' \
-  | awk -v me="$my_pane" '$1 != me && $2 == "0"' | wc -l | tr -d ' ')
-
-if [ "$other_live" -eq 0 ]; then
-  # No live siblings — close the popup and kill the window
-  # (also cleans up any dead siblings).
-  tmux detach-client
-  tmux kill-window -t "$window_id" 2>/dev/null || true
-else
-  # User has split off other live panes — only kill ours, keep popup open.
-  tmux kill-pane 2>/dev/null || true
-fi

agent-nav.sh

@@ -1,133 +0,0 @@
-#!/usr/bin/env bash
-# Drive the agent popup from the windows of the session underneath it rather
-# than from the agent session's own window list. Bound inside the agent session
-# to <prefix>C-n and <prefix>C-p ("next"/"prev") and to <prefix>0..9 (a window
-# index) -- see tmux.conf.
-#
-# Root windows with no agent window are stepped over when cycling and do nothing
-# when named by index, so the popup and the session below it never disagree.
-# Neither ever creates an agent window; only <prefix>A does. Both the client
-# underneath and the popup move, so closing the popup leaves you where you went.
-
-set -e
-
-target=${1:-next}
-us=$'\x1f'
-
-# Fall back to plain window cycling within the agent session when there is no
-# usable client underneath (popup opened before this was configured, or the
-# recorded client has gone away).
-fallback() {
-  case $target in
-    next) tmux next-window -t agent ;;
-    prev) tmux previous-window -t agent ;;
-    *) tmux select-window -t "agent:$target" 2>/dev/null || true ;;
-  esac
-  exit 0
-}
-
-popup_client=$(tmux display-message -p '#{@agent_popup_client}' 2>/dev/null || true)
-[ -n "$popup_client" ] || fallback
-
-# The session and window underneath the popup, as the client sees them now.
-client_info=$(tmux list-clients -F "#{client_name}$us#{session_name}$us#{window_id}" \
-  | awk -v FS="$us" -v client="$popup_client" '$1 == client { print $2 FS $3; exit }')
-[ -n "$client_info" ] || fallback
-IFS=$us read -r client_session client_window <<<"$client_info"
-
-# Every agent window, with what it is keyed to.
-agent_ids=()
-agent_dirs=()
-agent_origins=()
-while IFS=$us read -r window_id dir origin; do
-  [ -n "$dir" ] || continue
-  agent_ids+=("$window_id")
-  agent_dirs+=("$dir")
-  agent_origins+=("$origin")
-done < <(tmux list-windows -t agent \
-  -F "#{window_id}$us#{@agent_dir}$us#{@agent_origin_window}" 2>/dev/null || true)
-[ ${#agent_ids[@]} -gt 0 ] || exit 0
-
-# The agent window serving a root window: by recorded origin first, then by the
-# directory its first pane sits in. Mirrors agent-sync.sh's resolution, reversed.
-agent_window_for() {
-  local root_window=$1 start_path=$2 current_path=$3 i
-  for i in "${!agent_ids[@]}"; do
-    if [ -n "${agent_origins[$i]}" ] && [ "${agent_origins[$i]}" = "$root_window" ]; then
-      printf '%s\n' "${agent_ids[$i]}"
-      return 0
-    fi
-  done
-  for i in "${!agent_ids[@]}"; do
-    if [ "${agent_dirs[$i]}" = "$start_path" ] || [ "${agent_dirs[$i]}" = "$current_path" ]; then
-      printf '%s\n' "${agent_ids[$i]}"
-      return 0
-    fi
-  done
-  return 1
-}
-
-# Move the client underneath and the popup together. The agent window is re-keyed
-# to the window being moved to, so the sync hook that the select below fires
-# agrees with what happened here instead of dragging the client back to wherever
-# that window was last opened from.
-move_to() { # move_to <root window id> <agent window id>
-  tmux set-window-option -t "$2" @agent_origin_window "$1"
-  tmux select-window -t "$1"
-  tmux select-window -t "$2"
-  exit 0
-}
-
-# The underlying session's windows, in its own order, each with its index and its
-# first pane's directory. Panes are listed grouped by window in index order.
-root_windows=()
-root_indexes=()
-root_paths=()
-seen_window=""
-while IFS=$us read -r window_id window_index start_path current_path; do
-  [ "$window_id" != "$seen_window" ] || continue
-  seen_window=$window_id
-  root_windows+=("$window_id")
-  root_indexes+=("$window_index")
-  root_paths+=("$start_path$us$current_path")
-done < <(tmux list-panes -s -t "$client_session" \
-  -F "#{window_id}$us#{window_index}$us#{pane_start_path}$us#{pane_current_path}" \
-  2>/dev/null || true)
-
-count=${#root_windows[@]}
-[ "$count" -gt 0 ] || exit 0
-
-# <prefix>0..9: the window with that index in the session underneath. Doing
-# nothing when it has no agent window keeps the popup and that session in step.
-if [ -n "$target" ] && [ -z "${target//[0-9]/}" ]; then
-  for i in "${!root_windows[@]}"; do
-    [ "${root_indexes[$i]}" = "$target" ] || continue
-    IFS=$us read -r start_path current_path <<<"${root_paths[$i]}"
-    target_agent=$(agent_window_for "${root_windows[$i]}" "$start_path" "$current_path") || exit 0
-    move_to "${root_windows[$i]}" "$target_agent"
-  done
-  exit 0
-fi
-
-# Where the client sits in that order.
-current=0
-for i in "${!root_windows[@]}"; do
-  if [ "${root_windows[$i]}" = "$client_window" ]; then
-    current=$i
-    break
-  fi
-done
-
-if [ "$target" = prev ]; then step=-1; else step=1; fi
-
-# Walk in that direction for the first window with an agent window, wrapping.
-# Landing back on the starting window means nothing else has one: selecting it
-# again is a no-op, which is the wanted behaviour.
-i=$current
-for _ in $(seq 1 "$count"); do
-  i=$(( (i + step + count) % count ))
-  target_root=${root_windows[$i]}
-  IFS=$us read -r start_path current_path <<<"${root_paths[$i]}"
-  target_agent=$(agent_window_for "$target_root" "$start_path" "$current_path") || continue
-  move_to "$target_root" "$target_agent"
-done

agent-sync.sh

@@ -1,90 +0,0 @@
-#!/usr/bin/env bash
-# Move the client that opened the agent popup to the root window matching the
-# agent session's current window. Installed by agent.sh as the agent session's
-# session-window-changed hook, so it runs for any window change made inside the
-# popup: <prefix>C-n, <prefix>C-p, select-window, choose-tree or the mouse.
-#
-# Set @agent_follow_session to "off" to keep the opening client in the session
-# it is already on, never switching it to the session owning the match.
-
-set -e
-
-# Fields are joined with a unit separator, not a tab: `read` folds runs of tabs
-# and spaces even when IFS names them, so an unset option in the middle would
-# silently shift every field after it.
-us=$'\x1f'
-
-# Everything recorded about the agent session's current window, in one
-# round-trip. Format lookups rather than show-option, so unset user options come
-# back empty instead of logging "invalid option" into the tmux message log.
-state=$(tmux display-message -p -t agent "#{session_attached}$us#{@agent_dir}\
-$us#{@agent_origin_window}$us#{@agent_popup_client}$us#{@agent_follow_session}" \
-  2>/dev/null || true)
-IFS=$us read -r attached agent_dir origin_window popup_client follow <<<"$state"
-
-# Only sync while a popup is actually attached. Without this guard the
-# detach-client + kill-window agent-cmd.sh performs when an agent exits would
-# drag the root client to whichever window tmux picks next.
-[ "${attached:-0}" -gt 0 ] || exit 0
-[ -n "$agent_dir" ] || exit 0
-
-# An empty session means the recorded client has since gone away.
-client_session=""
-if [ -n "$popup_client" ]; then
-  client_session=$(tmux list-clients -F "#{client_name}$us#{session_name}" \
-    | awk -v FS="$us" -v client="$popup_client" '$1 == client { print $2; exit }')
-fi
-
-target_window=""
-target_session=""
-
-# Prefer the recorded origin window, as long as it still exists.
-if [ -n "$origin_window" ]; then
-  while IFS=$us read -r window_id session_name; do
-    if [ "$window_id" = "$origin_window" ] && [ "$session_name" != agent ]; then
-      target_window=$window_id
-      target_session=$session_name
-      break
-    fi
-  done < <(tmux list-windows -a -F "#{window_id}$us#{session_name}")
-fi
-
-# Otherwise match the recorded directory against root windows. This covers agent
-# windows created before origin recording existed, and root windows that have
-# been recreated since.
-if [ -z "$target_window" ]; then
-  seen_window=""
-  while IFS=$us read -r window_id session_name start_path current_path; do
-    # Panes are listed grouped by window in index order, so the first row for a
-    # window is its first pane.
-    [ "$window_id" != "$seen_window" ] || continue
-    seen_window=$window_id
-    [ "$session_name" != agent ] || continue
-    [ "$start_path" = "$agent_dir" ] || [ "$current_path" = "$agent_dir" ] || continue
-    # Prefer a window in the session the opening client is already on.
-    if [ "$session_name" = "$client_session" ]; then
-      target_window=$window_id
-      target_session=$session_name
-      break
-    fi
-    if [ -z "$target_window" ]; then
-      target_window=$window_id
-      target_session=$session_name
-    fi
-  done < <(tmux list-panes -a -F "#{window_id}$us#{session_name}\
-$us#{pane_start_path}$us#{pane_current_path}")
-fi
-
-# No match: leave the root sessions alone rather than inventing a window.
-[ -n "$target_window" ] || exit 0
-
-# Window ids are server-global, so this moves the owning session whichever
-# client happens to be on it.
-tmux select-window -t "$target_window" 2>/dev/null || exit 0
-
-# Selecting is enough when the client is already on the target session.
-[ -n "$client_session" ] || exit 0
-[ "$follow" != off ] || exit 0
-if [ -n "$target_session" ] && [ "$target_session" != "$client_session" ]; then
-  tmux switch-client -c "$popup_client" -t "$target_session"
-fi

agent.sh

@@ -1,79 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Use the current directory (set via display-popup -d)
-dir="${PWD:-$HOME}"
-# Use the directory basename as window name
-window_name=$dir
-
-# The client that opened the popup, recorded by the `bind A` binding. Its
-# current window is the root window <prefix>A was pressed in; the popup cannot
-# pass that through itself, so resolve it here before attaching.
-popup_client=$(tmux display-message -p '#{@agent_popup_client}' 2>/dev/null || true)
-origin_window=""
-if [ -n "$popup_client" ]; then
-  origin_window=$(tmux list-clients -F $'#{client_name}\x1f#{window_id}' \
-    | awk -v FS=$'\x1f' -v client="$popup_client" '$1 == client { print $2; exit }')
-fi
-
-# Create the agent session if it doesn't exist
-if ! tmux has-session -t agent; then
-  tmux new-session -ds agent -c "$dir" -n "$window_name" "$script_dir/agent-cmd.sh"
-  # Store the directory in a window option for later matching
-  tmux set-window-option -t agent @agent_dir "$dir"
-fi
-
-# Apply session options on every invocation so updates propagate to live sessions
-tmux set-option -t agent status off
-tmux set-option -t agent remain-on-exit on
-tmux set-option -t agent default-command "$script_dir/agent-cmd.sh"
-# Session-scoped (not -g) so the root-session window changes agent-sync.sh makes
-# cannot re-trigger it.
-tmux set-hook -t agent session-window-changed "run -b '$script_dir/agent-sync.sh'"
-
-# Search for an existing window with matching directory
-target_window=""
-for window_id in $(tmux list-windows -t agent -F '#{window_id}'); do
-  window_dir=$(tmux show-window-option -t "$window_id" -v @agent_dir 2>/dev/null || true)
-  if [ "$window_dir" = "$dir" ]; then
-    target_window="$window_id"
-    break
-  fi
-done
-
-if [ -n "$target_window" ]; then
-  # Remember which root window this agent window came from, refreshed on every
-  # invocation. Recorded *before* selecting, so the sync hook select-window
-  # fires sees this invocation's origin rather than the previous one's.
-  if [ -n "$origin_window" ]; then
-    tmux set-window-option -t "$target_window" @agent_origin_window "$origin_window"
-  fi
-  # Select the existing window
-  tmux select-window -t "$target_window"
-else
-  # Create a new window; default-command runs agent-cmd.sh
-  tmux new-window -t agent -c "$dir" -n "$window_name"
-  # Store the directory in a window option for later matching
-  tmux set-window-option -t agent @agent_dir "$dir"
-  if [ -n "$origin_window" ]; then
-    tmux set-window-option -t agent @agent_origin_window "$origin_window"
-  fi
-fi
-
-# Prune windows whose recorded directory no longer exists. This runs after the
-# current directory's window is guaranteed to exist, so the session always
-# keeps at least one live window and is never killed out from under us.
-for window_id in $(tmux list-windows -t agent -F '#{window_id}'); do
-  window_dir=$(tmux show-window-option -t "$window_id" -v @agent_dir 2>/dev/null || true)
-  # Skip windows with no recorded directory rather than risk pruning them.
-  [ -n "$window_dir" ] || continue
-  if [ ! -d "$window_dir" ]; then
-    tmux kill-window -t "$window_id" 2>/dev/null || true
-  fi
-done
-
-# Attach to the session
-tmux attach-session -t agent

check-version.sh

@@ -1,165 +0,0 @@
-#!/usr/bin/env bash
-
-# Compare the current tmux version against one or more version constraints.
-#
-# Each constraint pairs an operator and version in a single argument,
-# e.g. ">= 3.2". Multiple constraints can be joined with the logical operators
-# `and` / `or`, where `and` binds tighter than `or` (standard precedence). This
-# allows a single invocation to express a range without spawning the script
-# multiple times.
-#
-# Exit: 0 if the whole expression is true, 1 if false
-#
-# Examples:
-#   check-version.sh ">= 3.2"
-#   check-version.sh ">= 3.2" and "< 3.3"
-#   check-version.sh "< 2.9" or ">= 3.4"
-
-set -euo pipefail
-
-usage() {
-  cat >&2 <<'EOF'
-usage: check-version.sh <constraint> [and|or <constraint> ...]
-  constraint: <operator> <version>, e.g. ">= 3.2"
-  operators:  < <= == >= >
-  logical:    and or  (and binds tighter than or)
-EOF
-}
-
-if [[ ${1:-} == "-h" || ${1:-} == "--help" ]]; then
-  usage
-  exit 0
-fi
-
-if [[ $# -eq 0 ]]; then
-  usage
-  exit 1
-fi
-
-# Extract tmux version (e.g., "tmux 3.3a" -> "3.3a")
-current_version=$(tmux -V | sed 's/^tmux //')
-
-# Compare two version strings
-# Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
-compare_versions() {
-  local v1="$1"
-  local v2="$2"
-
-  # Strip trailing letters (e.g., "3.3a" -> "3.3") and save them
-  local v1_suffix="${v1##*[0-9]}"
-  local v2_suffix="${v2##*[0-9]}"
-  v1="${v1%[a-zA-Z]*}"
-  v2="${v2%[a-zA-Z]*}"
-
-  # Split into components
-  IFS='.' read -ra v1_parts <<< "$v1"
-  IFS='.' read -ra v2_parts <<< "$v2"
-
-  # Compare numeric parts
-  local max_len=$(( ${#v1_parts[@]} > ${#v2_parts[@]} ? ${#v1_parts[@]} : ${#v2_parts[@]} ))
-  for ((i = 0; i < max_len; i++)); do
-    local p1="${v1_parts[i]:-0}"
-    local p2="${v2_parts[i]:-0}"
-    if ((p1 < p2)); then
-      echo -1
-      return
-    elif ((p1 > p2)); then
-      echo 1
-      return
-    fi
-  done
-
-  # Numeric parts equal, compare suffixes (no suffix < a < b < ...)
-  # A letter suffix indicates a patch release, so 3.6a > 3.6
-  if [[ -z "$v1_suffix" && -n "$v2_suffix" ]]; then
-    echo -1
-    return
-  elif [[ -n "$v1_suffix" && -z "$v2_suffix" ]]; then
-    echo 1
-    return
-  elif [[ "$v1_suffix" < "$v2_suffix" ]]; then
-    echo -1
-    return
-  elif [[ "$v1_suffix" > "$v2_suffix" ]]; then
-    echo 1
-    return
-  fi
-
-  echo 0
-}
-
-# Evaluate a single constraint (e.g. ">= 3.2") against the current version.
-# Returns 0 (true) or 1 (false); exits on a malformed constraint.
-eval_constraint() {
-  local constraint="$1"
-  local operator version
-  read -r operator version <<< "$constraint"
-
-  if [[ -z "$operator" || -z "$version" ]]; then
-    echo "error: invalid constraint: '$constraint' (expected '<operator> <version>', e.g. '>= 3.2')" >&2
-    usage
-    exit 1
-  fi
-
-  local result
-  result=$(compare_versions "$current_version" "$version")
-
-  case "$operator" in
-    '<')  [[ "$result" -eq -1 ]] ;;
-    '<=') [[ "$result" -le 0 ]] ;;
-    '==') [[ "$result" -eq 0 ]] ;;
-    '>=') [[ "$result" -ge 0 ]] ;;
-    '>')  [[ "$result" -eq 1 ]] ;;
-    *)
-      echo "error: invalid operator: '$operator'" >&2
-      usage
-      exit 1 ;;
-  esac
-}
-
-# Walk the alternating constraint/logical sequence, accumulating each `and`
-# group (1 = true) and folding completed groups into the `or` result. Truth
-# values are tracked as ints and converted to an exit code at the end.
-or_result=0
-and_result=1
-expect=constraint
-
-for token in "$@"; do
-  if [[ "$expect" == "constraint" ]]; then
-    case "$token" in
-      and | or)
-        echo "error: expected a constraint, got logical operator: $token" >&2
-        usage
-        exit 1 ;;
-    esac
-    if eval_constraint "$token"; then
-      and_result=$(( and_result & 1 ))
-    else
-      and_result=$(( and_result & 0 ))
-    fi
-    expect=logical
-  else
-    case "$token" in
-      and)
-        ;;
-      or)
-        or_result=$(( or_result | and_result ))
-        and_result=1 ;;
-      *)
-        echo "error: expected 'and' or 'or', got: $token" >&2
-        usage
-        exit 1 ;;
-    esac
-    expect=constraint
-  fi
-done
-
-if [[ "$expect" == "constraint" ]]; then
-  echo "error: expression ends with a logical operator" >&2
-  usage
-  exit 1
-fi
-
-or_result=$(( or_result | and_result ))
-
-[[ "$or_result" -eq 1 ]] && exit 0 || exit 1

hooks/session-create.sh

@@ -2,14 +2,8 @@
 
 session_name=$(tmux display-message -p '#S')
 session_layout=~/.local/share/tmux/layouts/session-$session_name
-# Set by `session -p <project>`, which names the session after the project but
-# can't be relied on for the lookup above since tmux rewrites `.` in names.
-session_project=$(tmux show-environment -t "$session_name" TMUX_PROJECT 2>/dev/null |
-  sed -n 's/^TMUX_PROJECT=//p')
 if [ -f $session_layout ]; then
   $session_layout
-elif [ -n "$session_project" ]; then
+else
-  ~/.local/share/tmux/layouts/session-project "$session_project"
-elif [ "$session_name" != "agent" ]; then
   tmux rename-window home
 fi

install.sh

@@ -31,12 +31,8 @@ symlink $HOME/.config/tmux/layouts/session-infra \
         $HOME/.local/share/tmux/layouts/session-infra
 symlink $HOME/.config/tmux/layouts/session-main \
         $HOME/.local/share/tmux/layouts/session-main
-symlink $HOME/.config/tmux/layouts/session-project \
-        $HOME/.local/share/tmux/layouts/session-project
 symlink $HOME/.config/tmux/layouts/session-visor \
         $HOME/.local/share/tmux/layouts/session-visor
-symlink $HOME/.config/tmux/layouts/session-work \
-        $HOME/.local/share/tmux/layouts/session-work
 symlink $HOME/.config/tmux/layouts/window-auto \
         $HOME/.local/share/tmux/layouts/window-auto
 symlink $HOME/.config/tmux/layouts/window-tall \

layouts/session-config

@@ -14,10 +14,6 @@ tmux new-window -c ~/.config/tmux
 tmux rename-window config/tmux
 `dirname $0`/window-auto
 
-tmux new-window -c ~/.config/git
-tmux rename-window config/git
-`dirname $0`/window-auto
-
 if [ -d ~/.config/work ]; then
   tmux new-window -c ~/.config/work
   tmux rename-window config/work

layouts/session-project

@@ -1,35 +0,0 @@
-#!/usr/bin/env zsh
-
-# usage: session-project <project>
-#
-# Layout for a session created by `session -p <project>`, where <project> is a
-# path in ~/Projects with the prefix removed. The session-created hook passes
-# the project along, taking it from the session environment.
-
-project=$1
-repo=$HOME/Projects/$project
-
-tmux rename-window home
-$(dirname $0)/window-auto
-
-# Without a project there is nothing but the home window, which is all a
-# session created directly from this layout's name can get.
-if [[ -z "$project" ]] || ! git -C "$repo" rev-parse --git-dir &>/dev/null; then
-  exit
-fi
-
-# The remote's default branch, falling back to whatever HEAD points at for
-# repositories without an origin/HEAD, e.g. those with no remote at all.
-branch=$(git -C "$repo" symbolic-ref --short refs/remotes/origin/HEAD 2>/dev/null)
-branch=${branch#origin/}
-if [[ -z "$branch" ]]; then
-  branch=$(git -C "$repo" symbolic-ref --short HEAD 2>/dev/null)
-fi
-if [[ -z "$branch" ]]; then
-  # Detached HEAD, name the window after the commit it sits on.
-  branch=$(git -C "$repo" rev-parse --short HEAD 2>/dev/null)
-fi
-
-tmux new-window -c "$repo"
-tmux rename-window "$branch"
-$(dirname $0)/window-auto

layouts/session-work

@@ -1,9 +0,0 @@
-#!/usr/bin/env sh
-
-tmux rename-window work
-tmux rename-window home
-$(dirname $0)/window-auto
-
-tmux new-window -c ~/Projects/modularml/modular
-tmux rename-window modularml/modular
-$(dirname $0)/window-auto

layouts/window-auto

@@ -2,7 +2,7 @@
 
 cols=`tmux display -p "#{pane_width}"`
 lines=`tmux display -p "#{pane_height}"`
-width=$(( $cols / 2.5 ))
+width=$(( $cols / 2 )).0
 height=$lines.0
 ratio=$(( ($width / $height) * 100 ))
 

layouts/window-wide-left

@@ -1,11 +1,6 @@
-#!/usr/bin/env bash
+#!/usr/bin/env -S tmux source-file
 
-cols=`tmux display -p "#{pane_width}"`
+split-window -h -l 43% -c '#{pane_current_path}'
+select-pane -t 1
 
-if [ "$LAYOUT_FULLSCREEN" = "1" ]; then
+# vim: ft=tmux
-  tmux split-window -h -l 37% -c '#{pane_current_path}'
-  tmux select-pane -t 1
-else
-  tmux split-window -h -l 43% -c '#{pane_current_path}'
-  tmux select-pane -t 1
-fi

layouts/window-wide-right

@@ -1,11 +1,6 @@
-#!/usr/bin/env bash
+#!/usr/bin/env -S tmux source-file
 
-cols=`tmux display -p "#{pane_width}"`
+split-window -h -l 57% -c '#{pane_current_path}'
+select-pane -t 1
 
-if [ "$TMUX_LAYOUT_FULLSCREEN" = "1" ]; then
+# vim: ft=tmux
-  tmux split-window -h -l 63% -c '#{pane_current_path}'
-  tmux select-pane -t 1
-else
-  tmux split-window -h -l 57% -c '#{pane_current_path}'
-  tmux select-pane -t 1
-fi

project.sh

@@ -2,99 +2,19 @@
 
 set -e
 
-projects_dir=$HOME/Projects
+projects=()
 
-list_projects() {
+# Get list of projects from ~/Projects
-  local projects=() dir relative clone worktree projects_real
+for dir in $HOME/Projects/**/*; do
-
+  if [ -d $dir ]; then
-  # git reports symlink-resolved paths, which may not match how we spell it.
+    projects+=(${dir#$HOME/Projects/})
-  projects_real=$(cd "$projects_dir" 2>/dev/null && pwd -P) ||
-    projects_real=$projects_dir
-
-  for dir in "$projects_dir"/*/*/; do
-    [ -d "$dir" ] || continue
-    relative="${dir#$projects_dir/}"
-    relative="${relative%/}"
-
-    if [[ "$relative" != *@* ]]; then
-      projects+=("$relative")
-      continue
   fi
+done
 
-    # `repo@branch` holds the worktrees of the `repo` clone, one level deeper
+project=$(
-    # per `/` in the branch name. Asking git beats a scan deep enough to reach
+  echo "${projects[@]}" | tr ' ' '\n' | sort -u |
-    # them, which walks every working tree under $projects_dir. `worktree list`
+  fzf --layout=reverse --info=hidden --border=rounded --cycle
-    # also names the clone itself, already added above; sort -u collapses it.
+)
-    clone="$projects_dir/${relative%%@*}"
-    while IFS= read -r worktree; do
-      case $worktree in
-        "$projects_dir"/*) worktree=${worktree#"$projects_dir"/} ;;
-        "$projects_real"/*) worktree=${worktree#"$projects_real"/} ;;
-        *) continue ;;
-      esac
-      # Registered but deleted worktrees linger until `git worktree prune`.
-      [ -d "$projects_dir/$worktree" ] || continue
-      projects+=("$worktree")
-    done < <(git -C "$clone" worktree list --porcelain 2>/dev/null |
-      sed -n 's|^worktree ||p')
-  done
 
-  printf '%s\n' "${projects[@]}" | sort -u
+tmux new-window -n $project -c "~/Projects/$project"
-}
+~/.local/share/tmux/layouts/window-auto
-
-# Second pass: runs inside the popup, on the list the first pass built.
-if [[ "${1:-}" == --pick ]]; then
-  listfile=$2
-  trap 'rm -f "$listfile"' EXIT
-
-  project=$(
-    fzf --layout=reverse --info=hidden --border=rounded --cycle < "$listfile"
-  ) || exit 0
-  [ -n "$project" ] || exit 0
-
-  # In a session for this same project the slug just repeats the session name,
-  # so use the branch instead. tmux rewrote `.` and `:` in the session name.
-  window_name=$project
-  session=$(tmux display -p '#S')
-  root=${project%%@*}
-  if [ "${root//[.:]/_}" = "$session" ]; then
-    branch=$(git -C "$projects_dir/$project" symbolic-ref --short HEAD 2>/dev/null ||
-      git -C "$projects_dir/$project" rev-parse --short HEAD 2>/dev/null || true)
-    window_name=${branch:-$project}
-  fi
-
-  tmux new-window -n "$window_name" -c "$projects_dir/$project"
-  ~/.local/share/tmux/layouts/window-auto
-  exit
-fi
-
-# First pass: size the popup, then re-launch inside it. fzf has no width of its
-# own — it fills the popup — so the popup width is what we scale.
-listfile=$(mktemp)
-list_projects > "$listfile"
-
-longest=0
-while IFS= read -r line; do
-  if (( ${#line} > longest )); then
-    longest=${#line}
-  fi
-done < "$listfile"
-
-# run-shell owns no client, so resolve the one that triggered us: without -c
-# the popup gets no tty and fzf can't draw.
-client=$(tmux display -p '#{client_name}')
-cols=$(tmux display -p -c "$client" '#{client_width}')
-
-min=60
-max=$(( cols * 90 / 100 ))
-# 6 = border (2) + pointer gutter (2) + scrollbar (1) + breathing room.
-width=$(( longest + 6 ))
-(( width < min )) && width=$min
-(( width > max )) && width=$max
-
-flags=(-c "$client" -w "$width" -h 10)
-if ~/.config/tmux/check-version.sh ">= 3.3"; then
-  flags+=(-B)
-fi
-
-tmux display-popup "${flags[@]}" -E "'$0' --pick '$listfile'"

session.sh

@@ -4,12 +4,9 @@ set -e
 
 sessions=()
 
-# Get list of predefined session layouts, skipping session-project since it is
+# Get list of predefined session layouts
-# parameterized by `session -p <project>` rather than a session of its own
 for item in $HOME/.local/share/tmux/layouts/session-*; do
-  layout=${item#$HOME/.local/share/tmux/layouts/session-}
+  sessions+=(${item#$HOME/.local/share/tmux/layouts/session-})
-  [ "$layout" = project ] && continue
-  sessions+=($layout)
 done
 
 # Get list of existing sessions

system-info/system-info-Linux.sh

@@ -35,11 +35,11 @@ if upower -e | grep 'BAT' 2> /dev/null; then
     local percentage=$(echo $output | awk '{ print $4 }')
     if [ "$charging" = "Charging," ];then
       echo $percentage | awk '$battery ~ /.*/ {
-        printf " %d%% %s\n", $battery, substr("󰢟󰢜󰂆󰂇󰂈󰢝󰂉󰢞󰂊󰂋󰂅", int($battery / 100 * 11), 1)
+        printf " %d%% %s\n", $battery, substr("󰢟󰢜󰂆󰂇󰂈󰢝󰂉󰢞󰂊󰂋󰂅", int($battery / 9), 1)
       }'
     else
       echo $percentage | awk '$battery ~ /.*/ {
-        printf " %d%% %s\n", $battery, substr("󰂎󰁺󰁻󰁼󰁽󰁾󰁿󰂀󰂁󰂂󰁹", int($battery / 100 * 11), 1)
+        printf " %d%% %s\n", $battery, substr("󰂎󰁺󰁻󰁼󰁽󰁾󰁿󰂀󰂁󰂂󰁹", int($battery / 9), 1)
       }'
     fi
   }
@@ -57,7 +57,7 @@ while true; do
   # Parse the current CPU load on all cores/threads.
   cpu_load=" `mpstat -P ALL -n 1 -u 1 -o JSON | \
     jq '.sysstat.hosts[0].statistics[0]["cpu-load"][1:]|.[].idle' | \
-    awk '$idle ~ /[-.0-9]*/ { printf "%s", substr("█▇▆▅▄▃▂▁ ", int($idle / 100 * 9), 1) }'`"
+    awk '$idle ~ /[-.0-9]*/ { printf "%s", substr("█▇▆▅▄▃▂▁ ", int($idle / 11), 1) }'`"
 
   # Parse the current CPU package temperature.
   cpu_temp=$(get_cpu_temp)

system-info/system-info-WSL.sh

@@ -32,14 +32,14 @@ while true; do
 
   cpu_load=" `mpstat -P ALL -n 1 -u 1 -o JSON | \
     jq '.sysstat.hosts[0].statistics[0]["cpu-load"][1:]|.[].idle' | \
-    awk '$idle ~ /[-.0-9]*/ { printf "%s", substr("█▇▆▅▄▃▂▁ ", int($idle / 100 * 9), 1) }'`"
+    awk '$idle ~ /[-.0-9]*/ { printf "%s", substr("█▇▆▅▄▃▂▁ ", int($idle / 11), 1) }'`"
 
   raw_battery=$($powershell -NoProfile \
     "(Get-WmiObject win32_battery).EstimatedChargeRemaining" \
     | sed 's/\r//')
   if [ "" != "$raw_battery" ]; then
     battery="$(echo $raw_battery | awk '$battery ~ /.*/ {
-      printf " %d%% %s\n", $battery, substr("", int($battery / 100 * 11), 1)
+      printf " %d%% %s\n", $battery, substr("", int($battery / 9), 1)
     }')"
   fi
 

system-info/system-info-macOS.sh

@@ -8,7 +8,68 @@ if [ ! -d $cache_dir ]; then
   mkdir -p $cache_dir
 fi
 
-[ -f $cache_dir/cpu-temp ] && rm $cache_dir/cpu-temp
+if [ ! -f $cache_dir/cpu-temp ]; then
+  clang -x objective-c -Wall -O2 -g -c -o $cache_dir/cpu-temp.o - << EOF
+#import <Foundation/Foundation.h>
+#import <IOKit/hidsystem/IOHIDEventSystemClient.h>
+#include <unistd.h>
+
+#define IOHIDEventFieldBase(type) (type << 16)
+#define kIOHIDEventTypeTemperature 15
+
+typedef struct __IOHIDEvent *IOHIDEventRef;
+typedef struct __IOHIDServiceClient *IOHIDServiceClientRef;
+typedef double IOHIDFloat;
+
+IOHIDEventSystemClientRef
+IOHIDEventSystemClientCreate(CFAllocatorRef allocator);
+int IOHIDEventSystemClientSetMatching(IOHIDEventSystemClientRef client,
+                                      CFDictionaryRef match);
+IOHIDEventRef IOHIDServiceClientCopyEvent(IOHIDServiceClientRef, int64_t,
+                                          int32_t, int64_t);
+CFStringRef IOHIDServiceClientCopyProperty(IOHIDServiceClientRef service,
+                                           CFStringRef property);
+IOHIDFloat IOHIDEventGetFloatValue(IOHIDEventRef event, int32_t field);
+
+int main(int argc, char *argv[]) {
+  NSDictionary *thermalSensors = @{
+    @"PrimaryUsagePage" : [NSNumber numberWithInt:0xFF00],
+    @"PrimaryUsage" : [NSNumber numberWithInt:5],
+  };
+  IOHIDEventSystemClientRef system =
+      IOHIDEventSystemClientCreate(kCFAllocatorDefault);
+  IOHIDEventSystemClientSetMatching(system,
+                                    (__bridge CFDictionaryRef)thermalSensors);
+  NSArray *serviceClients =
+      (__bridge NSArray *)IOHIDEventSystemClientCopyServices(system);
+
+  long count = [serviceClients count];
+  for (NSUInteger i = 0; i < count; i++) {
+    IOHIDServiceClientRef serviceClient =
+        (IOHIDServiceClientRef)serviceClients[i];
+    NSString *name = (NSString *)IOHIDServiceClientCopyProperty(
+        serviceClient, (__bridge CFStringRef) @"Product");
+    if ([name isEqualToString:[NSString stringWithUTF8String:argv[1]]]) {
+      IOHIDEventRef event = IOHIDServiceClientCopyEvent(
+          serviceClient, kIOHIDEventTypeTemperature, 0, 0);
+      NSNumber *value;
+      double temp = 0.0;
+      if (event != 0) {
+        temp = IOHIDEventGetFloatValue(
+            event, IOHIDEventFieldBase(kIOHIDEventTypeTemperature));
+      }
+      value = [NSNumber numberWithDouble:temp];
+      printf("%.1lf°C\n", [value doubleValue]);
+      break;
+    }
+  }
+
+  return 0;
+}
+EOF
+  clang -o $cache_dir/cpu-temp $cache_dir/cpu-temp.o -framework Foundation -framework IOKit
+  rm $cache_dir/cpu-temp.o
+fi
 
 # Cleanup cache file when interrupted.
 trap '[ -f $cache_file ] && rm $cache_file; exit' INT
@@ -20,15 +81,13 @@ ioreg -w0 -l | grep BatteryInstalled &> /dev/null && \
 
 while true; do
   # Get the current CPU temperature.
-  cpu_temp=$(
+  cpu_temp="`$cache_dir/cpu-temp 'PMU tdie0'` "
-    ~/.local/bin/iSMC -o json temp | jq '."PMU tdie1".quantity' | xargs printf "%.1f°C "
-  )
 
   cpu_load=$(sudo powermetrics --format text \
       --sample-rate 1200 --sample-count 1 --samplers cpu_power |
-    grep --color=never -E 'CPU \d active residency:' |
+    grep --color=never -E 'CPU \d idle residency:' |
-    gawk '{print $5}' |
+    grep --color=never -Eo '\d+\.\d+' |
-    gawk '$idle ~ /[-.0-9]*/ { printf "%s", substr(" ▁▂▃▄▅▆▇█", int($idle / 100 * 9), 1) }'
+    gawk '$idle ~ /[-.0-9]*/ { printf "%s", substr("█▇▆▅▄▃▂▁ ", int($idle / 10), 1) }'
   )
 
   # Parse the current battery charge percentage.
@@ -38,7 +97,7 @@ while true; do
       grep --color=never -Eo '\d+%' | \
       grep --color=never -Eo '\d+')"
     battery="$(echo $raw_battery | gawk '$battery ~ /.*/ {
-      printf " %d%% %s\n", $battery, substr("󰂎󰁺󰁻󰁼󰁽󰁾󰁿󰂀󰂁󰂂󰁹", int($battery / 100 * 11), 1)
+      printf " %d%% %s\n", $battery, substr("󰂎󰁺󰁻󰁼󰁽󰁾󰁿󰂀󰂁󰂂󰁹", int($battery / 9), 1)
     }')"
   fi
 

theme.tmux

@@ -3,10 +3,7 @@ if -b '[ "$WSL_DISTRO_NAME" != "" ]' \
   'setw -g status-left " #(hostname)|#{WSL_DISTRO_NAME}|#{session_name}"' \
   'setw -g status-left " #(hostname -s)|#{session_name}"'
 setw -g status-left-style fg=colour240,bg=colour233
-# Only a maximum, and the component is never padded out to it, so leave room
+setw -g status-left-length 32
-# for the hostname beside a full session name: project sessions are named after
-# a path, e.g. modularml/modular@benie/some-branch.
-setw -g status-left-length 100
 
 # Centre status style
 setw -g status-style fg=colour240,bg=colour233
@@ -14,8 +11,7 @@ setw -g status-style fg=colour240,bg=colour233
 # Right status style shows system info, date, and time.
 setw -g status-right "#[fg=colour240]#(cat ~/.cache/tmux/system-info)#[fg=white] %a %d-%m-%y %H:%M "
 setw -g status-right-style fg=white,bg=colour233
-if -b '[ "`uname`" = "Darwin" ]' \
+if -b '[ "`uname`" != "Darwin" ]' \
-  'run "tmux setw -g status-right-length $((`sysctl -n hw.ncpu` + 48))"' \
   'run "tmux setw -g status-right-length $((`nproc --all` + 48))"'
 
 # Active window status style

tmux.conf

@@ -28,24 +28,13 @@ set -g status-interval 2
 set -g default-terminal "tmux-256color"
 
 # Enable true-color
-if '~/.config/tmux/check-version.sh "< 3.2"' \
+if '[[ "$TMUX_VERSION" < "3.2" ]]' \
   'set-option -as terminal-features ",xterm*:Tc"' \
   'set-option -as terminal-features ",xterm*:RGB"'
 
-# Declare clipboard (OSC-52) support so tmux emits it for copy-pipe.
-set -as terminal-features ',xterm*:clipboard'
-
 # Focus events enabled for terminals that support them
 set -g focus-events on
 
-# Forward modifier information so apps, csi-u format requires tmux 3.5+.
-if -b '~/.config/tmux/check-version.sh ">= 3.2"' {
-  set -g extended-keys on
-}
-if -b '~/.config/tmux/check-version.sh ">= 3.5"' {
-  set -g extended-keys-format csi-u
-}
-
 # Aggressively resize the chosen window to smallest/largest session
 setw -g aggressive-resize on
 
@@ -60,7 +49,7 @@ unbind -T copy-mode-vi MouseDragEnd1Pane
 # Enable changing cursor shape per pane, vim or zsh should emit escape
 # sequences to change cursor shape.
 # iTerm2 only requires this before tmux 2.9
-if '[ -n $ITERM_PROFILE ] && ~/.config/tmux/check-version.sh "< 2.9"' \
+if '[ -n $ITERM_PROFILE ] && [[ "$TMUX_VERSION" < "2.9" ]]' \
   'set -ga terminal-overrides "*:Ss=\E]1337;CursorShape=%p1%d\7"'
 # VTE compatible terminals.
 if '[ ! -n $ITERM_PROFILE ]' \
@@ -69,64 +58,22 @@ if '[ ! -n $ITERM_PROFILE ]' \
 # Enable strikethrough on VTE compatible terminals.
 set -ga terminal-overrides 'xterm*:smxx=\E[9m'
 
-if -b '~/.config/tmux/check-version.sh ">= 3.2" and "< 3.3"' {
+# Set only on macOS where it's required
-  bind A if -F '#{==:#{session_name},agent}' { detach-client } {
+if -b '[ "`uname`" = "Darwin" ]' \
-    # Record the opening client so agent-sync.sh can move it along with the
+  'set -g default-command "reattach-to-user-namespace -l $SHELL"'
-    # window selected inside the popup.
-    run-shell "tmux set -g @agent_popup_client '#{client_name}'"
-    display-popup -d '#{pane_current_path}' -w 50% -h 90% -E ~/.config/tmux/agent.sh
-  }
-  bind H display-popup -w 75% -h 75% -E htop
-  bind I display-popup -d '#{pane_current_path}' -E ~/.config/tmux/interpreter.sh
-  bind N display-popup -d '#{pane_current_path}' -w 60% -h 75% -E nvim
-  bind S display-popup -w 60 -h 10 -E ~/.config/tmux/session.sh
-  bind T display-popup -d '#{pane_current_path}' -E $SHELL
-}
-if -b '~/.config/tmux/check-version.sh ">= 3.3"' {
-  bind A if -F '#{==:#{session_name},agent}' { detach-client } {
-    # Record the opening client so agent-sync.sh can move it along with the
-    # window selected inside the popup.
-    run-shell "tmux set -g @agent_popup_client '#{client_name}'"
-    display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -w 75% -h 90% -E ~/.config/tmux/agent.sh
-  }
-  bind H display-popup -S fg=#54546D -b rounded -w 50% -h 75% -E htop
-  bind I display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -E ~/.config/tmux/interpreter.sh
-  bind N display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -w 60% -h 75% -E nvim
-  bind S display-popup -B -w 60 -h 10 -E ~/.config/tmux/session.sh
-  bind T display-popup -S fg=#54546D -d '#{pane_current_path}' -E $SHELL
-}
 
-bind P run-shell ~/.config/tmux/project.sh
+# Open a popup with running the default shell
+bind T display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -E $SHELL
+# Open a popup with session creator/switcher
+bind S display-popup -B -w 60 -h 10 -E '~/.config/tmux/session.sh'
+# Open a popup with project selector
+bind P display-popup -B -w 60 -h 10 -E '~/.config/tmux/project.sh'
+# Open a popup to pick an interpreter then launch it
+bind I display-popup -S fg=#54546D -b rounded -d '#{pane_current_path}' -E '$SHELL -i ~/.config/tmux/interpreter.sh'
 
-# Restore old next/previous window bindings. Inside the agent popup these walk
+# Restore old next/previous window bindings
-# the windows of the session underneath instead, skipping any that have no agent
+bind C-n next-window
-# window, so the popup and the client below it move together.
+bind C-p previous-window
-bind C-n if -F '#{==:#{session_name},agent}' {
-  run -b '~/.config/tmux/agent-nav.sh next'
-} {
-  next-window
-}
-bind C-p if -F '#{==:#{session_name},agent}' {
-  run -b '~/.config/tmux/agent-nav.sh prev'
-} {
-  previous-window
-}
-
-# Numbered window selection. Inside the agent popup the number addresses the
-# underlying session's windows, doing nothing if that window has no agent window.
-bind 0 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 0'" 'select-window -t :=0'
-bind 1 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 1'" 'select-window -t :=1'
-bind 2 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 2'" 'select-window -t :=2'
-bind 3 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 3'" 'select-window -t :=3'
-bind 4 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 4'" 'select-window -t :=4'
-bind 5 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 5'" 'select-window -t :=5'
-bind 6 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 6'" 'select-window -t :=6'
-bind 7 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 7'" 'select-window -t :=7'
-bind 8 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 8'" 'select-window -t :=8'
-bind 9 if -F '#{==:#{session_name},agent}' "run -b '~/.config/tmux/agent-nav.sh 9'" 'select-window -t :=9'
-
-# Kill current window
-bind W kill-window
 
 # Make new splits open in current directory
 bind '"' split-window -c '#{pane_current_path}'
@@ -196,13 +143,12 @@ if -b '[ "$SSH_TTY" != "" ]' \
   'set-option -g set-clipboard on'
 
 # Yank to the system clipboard in copy mode.
+# TODO: reattach-to-user-namespace not necessary with tmux > 2.6
 if -b '[ "`uname`" = "Darwin" ]' \
-  'bind -T copy-mode-vi y send-keys -X copy-pipe "pbcopy"'
+  'bind -T copy-mode-vi y send-keys -X copy-pipe "reattach-to-user-namespace pbcopy"'
 # When not in WSL2 use xsel, when in WSL use win32yank.exe to avoid UI lockups.
-if -b '[ "`uname`" != "Darwin" ]' {
+if -b '[ "$WSLENV" = "" ]' \
-  if -b '[ "$WSLENV" = "" ]' \
   'bind -T copy-mode-vi y send-keys -X copy-pipe "xsel -i --clipboard"' \
   'bind -T copy-mode-vi y send-keys -X copy-pipe "win32yank.exe -i -crlf"'
-}
 
 source-file ~/.config/tmux/theme.tmux