brew install --cask ghostty

# Theme -- run `ghostty +list-themes` to browse options
theme = Monokai Pro Light Sun

brew install tmux

# Mouse support -- enables trackpad/mouse scrolling in tmux panes
set -g mouse on

# Fix terminal colors and mouse inside tmux (for Ghostty)
set -g default-terminal "tmux-256color"
set -ag terminal-features ",xterm-ghostty:RGB:mouse:usstyle:clipboard:title"

# Keep sessions alive when terminal is closed
set -g destroy-unattached off

# --- Agent Teams focus protection ---
# Problem: when Claude Code spawns a teammate pane, leaked keystrokes
# corrupt the startup command. Four-layer fix:
#   1. C-u clears any keystrokes that leaked during split-window
#   2. select-pane -l returns focus to the lead pane immediately
#   3. Guard catches Claude Code's subsequent select-pane commands
#   4. Retry script (after 3s) detects and re-executes failed spawns
set-hook -g after-split-window "send-keys C-u; select-pane -l; set-option -g @split_guard 1; run-shell -b 'sleep 3 && $HOME/path/to/tmux-retry-teammate.sh; /opt/homebrew/bin/tmux set-option -g -u @split_guard 2>/dev/null'"
set-hook -g after-select-pane "if-shell -F '#{==:#{@split_guard},1}' 'set-option -g -u @split_guard; select-pane -l'"

#!/bin/bash
# Detects and retries failed Claude Code teammate spawns.
TMUX_BIN=/opt/homebrew/bin/tmux

for pane in $($TMUX_BIN list-panes -F '#{pane_id}' 2>/dev/null); do
    content=$($TMUX_BIN capture-pane -t "$pane" -p -J 2>/dev/null) || continue

    # Match panes with both a shell error AND a Claude agent startup pattern
    if echo "$content" | grep -q "command not found" \
        && echo "$content" | grep -q "CLAUDE_CODE_EXPERIMENTAL"; then

        # Extract the intended command
        cmd=$(echo "$content" \
            | grep "CLAUDE_CODE_EXPERIMENTAL" \
            | grep -o 'cd /[^ ]* && env CLAUDE_CODE.*' \
            | head -1)

        if [ -n "$cmd" ]; then
            $TMUX_BIN send-keys -t "$pane" C-c C-u
            sleep 0.2
            $TMUX_BIN send-keys -t "$pane" "$cmd" Enter
        fi
    fi
done

brew install starship

# Claude Code agent teams
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

# Starship prompt
eval "$(starship init zsh)"

# Minimal prompt for agent team workflows
add_newline = false
command_timeout = 500

format = """$directory$git_branch$git_status$character"""

[directory]
truncation_length = 1
truncate_to_repo = true
style = "bold cyan"

[git_branch]
format = " on [$branch]($style) "
style = "bold purple"

[git_status]
format = "[$all_status$ahead_behind]($style)"
style = "bold red"

[character]
success_symbol = "[>](bold green)"
error_symbol = "[>](bold red)"

#!/usr/bin/env bash
# ghostty-claude.sh -- launch Ghostty+tmux+Claude Code with remote control
# Usage: ghostty-claude.sh [project-path]

set -euo pipefail

INPUT_DIR="${1:-$(pwd)}"

# Walk up to find the git root (project root)
PROJECT_DIR="$(cd "$INPUT_DIR" && git rev-parse --show-toplevel 2>/dev/null || echo "$INPUT_DIR")"
SESSION_NAME="$(basename "$PROJECT_DIR")"

# Sanitize session name (tmux doesn't allow dots or colons)
SESSION_NAME="${SESSION_NAME//./-}"
SESSION_NAME="${SESSION_NAME//:/-}"

# Build display name with timestamp
DISPLAY_NAME="${SESSION_NAME}-$(date +%Y%m%d-%H%M)"

# Find a unique tmux session name
TMUX_SESSION="$DISPLAY_NAME"
i=0
while tmux has-session -t "$TMUX_SESSION" 2>/dev/null; do
  i=$((i + 1))
  TMUX_SESSION="${DISPLAY_NAME}-${i}"
done

open -na Ghostty.app --args \
  --working-directory="$PROJECT_DIR" \
  --title="$TMUX_SESSION" \
  -e tmux new-session -s "$TMUX_SESSION" \
    "claude --remote-control --worktree '$TMUX_SESSION' --name '$TMUX_SESSION'"

{
  "tasks": {
    "version": "2.0.0",
    "tasks": [
      {
        "label": "Claude Code in Ghostty",
        "type": "shell",
        "command": "/path/to/ghostty-claude.sh",
        "args": ["${fileDirname}"],
        "presentation": {
          "reveal": "never"
        },
        "problemMatcher": []
      }
    ]
  }
}

{
  "key": "ctrl+shift+t",
  "command": "workbench.action.tasks.runTask",
  "args": "Claude Code in Ghostty"
}

#!/usr/bin/env bash
# ghostty-claude-resume.sh -- resume a worktree Claude Code session
# Usage: ghostty-claude-resume.sh [--in-place | --switch] [path]
#
# Modes:
#   (default)    Open a new Ghostty window attached to the session
#   --in-place   Attach in the current terminal
#   --switch     Switch current tmux client to the session (for tmux keybind)
#
# If a path inside a worktree is given, the session is detected automatically.
# Otherwise, an interactive picker is shown.

set -euo pipefail

MODE="ghostty"
PATH_ARG=""
for arg in "$@"; do
  case "$arg" in
    --in-place) MODE="in-place" ;;
    --switch)   MODE="switch" ;;
    *)          PATH_ARG="$arg" ;;
  esac
done

SELECTED=""
WORKTREE_DIR=""
CREATE_SESSION=false

# If a path is given, try to detect the session from the worktree root
if [[ -n "$PATH_ARG" ]]; then
  WORKTREE_ROOT=$(git -C "$PATH_ARG" rev-parse --show-toplevel 2>/dev/null || true)
  if [[ -n "$WORKTREE_ROOT" ]]; then
    CANDIDATE=$(basename "$WORKTREE_ROOT")
    if [[ "$CANDIDATE" =~ ^.+-[0-9]{8}-[0-9]{4} ]]; then
      SELECTED="$CANDIDATE"
      WORKTREE_DIR="$WORKTREE_ROOT"
      if ! tmux has-session -t "$CANDIDATE" 2>/dev/null; then
        CREATE_SESSION=true
      fi
    fi
  fi
fi

# If not resolved from path, show interactive picker
if [[ -z "$SELECTED" ]]; then
  # Collect live tmux sessions matching worktree naming pattern
  LIVE_SESSIONS=$(tmux list-sessions -F '#{session_name}' 2>/dev/null \
    | grep -E '^.+-[0-9]{8}-[0-9]{4}' || true)

  # Collect orphaned worktrees (on disk but no tmux session)
  ORPHANED=""
  for repo_dir in ~/Developer/repos/*/; do
    wt_base="${repo_dir}.claude/worktrees"
    [[ -d "$wt_base" ]] || continue
    for wt_dir in "$wt_base"/*/; do
      [[ -d "$wt_dir" ]] || continue
      wt_name=$(basename "$wt_dir")
      [[ "$wt_name" =~ ^.+-[0-9]{8}-[0-9]{4} ]] || continue
      if ! tmux has-session -t "$wt_name" 2>/dev/null; then
        ORPHANED="${ORPHANED}${wt_name} (no session - ${wt_dir})\n"
      fi
    done
  done

  # Build combined list with status indicators
  ENTRIES=""
  while IFS= read -r name; do
    [[ -z "$name" ]] && continue
    attached=$(tmux list-sessions -F '#{session_name} #{session_attached}' 2>/dev/null \
      | grep "^${name} " | awk '{print $2}')
    if [[ "$attached" -gt 0 ]]; then
      ENTRIES="${ENTRIES}${name} (attached)\n"
    else
      ENTRIES="${ENTRIES}${name} (detached)\n"
    fi
  done <<< "$LIVE_SESSIONS"

  if [[ -n "$ORPHANED" ]]; then
    ENTRIES="${ENTRIES}${ORPHANED}"
  fi

  # In --switch mode, exclude the current session
  if [[ "$MODE" == "switch" ]]; then
    CURRENT=$(tmux display-message -p '#{session_name}' 2>/dev/null || true)
    if [[ -n "$CURRENT" ]]; then
      ENTRIES=$(echo -e "$ENTRIES" | grep -v "^${CURRENT} " || true)
    fi
  fi

  ENTRIES=$(echo -e "$ENTRIES" | sed '/^$/d')

  if [[ -z "$ENTRIES" ]]; then
    echo "No worktree sessions found."
    exit 0
  fi

  # Use fzf if available, otherwise numbered menu
  ENTRY_COUNT=$(echo "$ENTRIES" | wc -l | tr -d ' ')
  if [[ "$ENTRY_COUNT" -eq 1 ]]; then
    CHOSEN="$ENTRIES"
  elif command -v fzf &>/dev/null; then
    CHOSEN=$(echo "$ENTRIES" | fzf --prompt="Resume session: " --height=~20 --reverse) || true
  else
    echo "Worktree sessions:"
    i=1
    while IFS= read -r line; do
      echo "  $i) $line"
      i=$((i + 1))
    done <<< "$ENTRIES"
    read -rp "Select [1-${ENTRY_COUNT}]: " choice
    CHOSEN=$(echo "$ENTRIES" | sed -n "${choice}p")
  fi

  SELECTED=$(echo "$CHOSEN" | awk '{print $1}')

  if echo "$CHOSEN" | grep -q "(no session"; then
    CREATE_SESSION=true
    WORKTREE_DIR=$(echo "$CHOSEN" | grep -o '/[^ )]*')
  fi
fi

# Attach to existing session or recreate for orphaned worktree
if $CREATE_SESSION; then
  # Recreate tmux session in the orphaned worktree with claude
  case "$MODE" in
    ghostty)
      open -na Ghostty.app --args \
        --working-directory="$WORKTREE_DIR" \
        --title="$SELECTED" \
        -e tmux new-session -s "$SELECTED" "claude"
      ;;
    in-place)
      cd "$WORKTREE_DIR"
      exec tmux new-session -s "$SELECTED" "claude"
      ;;
    switch)
      tmux new-session -d -s "$SELECTED" -c "$WORKTREE_DIR" "claude"
      tmux switch-client -t "$SELECTED"
      ;;
  esac
else
  case "$MODE" in
    ghostty)
      open -na Ghostty.app --args \
        --title="$SELECTED" \
        -e tmux attach-session -t "$SELECTED"
      ;;
    in-place)
      exec tmux attach-session -t "$SELECTED"
      ;;
    switch)
      tmux switch-client -t "$SELECTED"
      ;;
  esac
fi

Resume session:
  webclass-service-20260408-1430 (attached)
  pandb-aurora-20260408-1512 (detached)
  workspace-20260407-0930 (no session - /path/to/worktree)

# Keep sessions alive when terminal is closed (worktree sessions survive)
set -g destroy-unattached off

# Resume worktree session picker (prefix + R)
bind R display-popup -E -w 70 -h 15 \
  "~/path/to/ghostty-claude-resume.sh --switch"

{
  "label": "Resume Claude Worktree Session",
  "type": "shell",
  "command": "/path/to/ghostty-claude-resume.sh",
  "args": ["${fileDirname}"],
  "presentation": {
    "reveal": "never"
  },
  "problemMatcher": []
}

{
  "key": "ctrl+shift+r",
  "command": "workbench.action.tasks.runTask",
  "args": "Resume Claude Worktree Session"
}

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

{
  "teammateMode": "auto"
}

claude --teammate-mode tmux

## Agent Teams vs Subagents

There are **two different ways** to delegate work. Always pick the right one:

| Mechanism | Tools to use | When |
|-----------|-------------|------|
| **Agent Teams (teammates)** | `TeamCreate` first, then `Agent` with `team_name` param | Default for 2+ parallel workstreams |
| **Subagents** | `Agent` tool alone (no `team_name`) | Single focused task, result-only |

### Agent Teams -- the default for parallel work

When a task has 2+ independent workstreams (research, review, implementation, etc.),
**always create a team first with `TeamCreate`**, then spawn teammates via the `Agent`
tool with the `team_name` parameter. Never use bare `Agent` calls (subagents) for
parallel coordination -- that bypasses the team task list and coordination model.

**The lead agent must:**

- Create a team with `TeamCreate` before spawning any workers
- Break tasks into independent pieces and spawn a teammate for each
- Keep the lead session strictly for planning, coordination, and reviewing results
- Never do implementation, file editing, or research directly in the lead session
- Only perform trivially short actions in the lead session (e.g., a single quick git
  command, reading one file to answer a question)
- Wait for teammates to finish before proceeding with dependent work

### When the lead can act directly (exceptions)

- Answering a quick question by reading a single file
- Running a single git command (status, log, push)
- Creating/updating a task list
- Reviewing a teammate's output and providing feedback

### Subagents -- for single focused tasks only

Use the `Agent` tool **without** `team_name` only when:

- There is a single focused task where only the result matters and no human review is needed
- High-volume operations (isolate verbose output from the lead context)
- Sequential work with tight dependencies
- Same-file edits where coordination is trivial

**Common coordination patterns:**

- **Research + Implement**: One teammate researches, another implements based on findings
- **Implement + Review**: One teammate codes, another reviews for security/quality
- **Independent Workstreams**: Multiple teammates on different repos/modules in parallel
- **Worktree Parallel**: Multiple features in same repo using git worktrees
- **Multiple Perspectives**: Teammates explore same problem from different angles

**When to use agent teams:**

- Any task involving file edits, code changes, or research
- Multi-repo changes
- Large refactors across multiple files or services
- Documentation updates across multiple files
- Tasks that take more than a few seconds to complete