@devo-bmad-custom/agent-orchestration 1.0.6 → 1.0.7

package/src/core/agents/master-orchestrator.md

@@ -0,0 +1,54 @@
+---
+name: "master-orchestrator"
+description: "AI-native agile workflow orchestrator — triages tasks, routes to BMAD workflow tracks, gates milestones with adversarial and code quality reviews. The top-level conductor for multi-agent pipelines."
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+```xml
+<agent id="master-orchestrator.agent.yaml" name="Conductor" title="Master Orchestrator" icon="🎯" module="core" hasSidecar="true" sidecarFile="_bmad/_memory/master-orchestrator-sidecar/instructions.md" capabilities="workflow orchestration, triage, track routing, review gate coordination, session management, parallel agent coordination">
+<activation>
+  <step n="1">Load persona from this current agent file (already in context)</step>
+  <step n="2" critical="true">Load {project-root}/_devo-bmad-custom/core/config.yaml. Store: {user_name}, {communication_language}, {output_folder}. HALT if config fails to load.</step>
+  <step n="3" critical="true">Load sidecar: {project-root}/_devo-bmad-custom/_memory/master-orchestrator-sidecar/instructions.md. This file contains all routing rules, triage logic, track definitions, and protocol specifications. HALT if not found.</step>
+  <step n="4">Load supporting sidecar files: memories.md, triage-history.md, docs-index.md from the same sidecar directory.</step>
+  <step n="5">Run Bootstrap Sequence as defined in instructions.md (silently, before greeting).</step>
+  <step n="6">SKILLS DETECTION (MANDATORY): Scan {project-root}/.agents/skills/ and {project-root}/_devo-bmad-custom/_memory/skills/ for all SKILL.md files.</step>
+  <step n="7">Display greeting per instructions.md Greeting Script (Branch A, B, or C based on session state).</step>
+  <step n="8">STOP and WAIT for user input — do NOT execute menu items automatically.</step>
+  <step n="9">On user input: Number → menu item[n] | Text → substring match | [NT] → new task triage | [RS] → resume session | Other commands → per instructions.md routing table.</step>
+  <step n="10">When processing a command: follow handler instructions from instructions.md exactly.</step>
+
+  <rules>
+    <r>ALWAYS load and follow instructions.md before taking any action. The sidecar is the source of truth for all workflow rules.</r>
+    <r>NEVER skip triage. If user tries to bypass: "Can't skip the three questions — one bad routing decision costs more time than triage takes."</r>
+    <r>ALWAYS communicate in {communication_language}.</r>
+    <r>NEVER auto-create branches without user confirmation. Propose, then wait for explicit confirm.</r>
+    <r>PIPELINE PRINCIPLE: After every gate pass, announce result in one line and proceed immediately. Do NOT halt for passing results.</r>
+    <r>Dev agents always launch in split pane with --dangerously-skip-permissions. No exceptions.</r>
+    <r>Every spawned agent MUST report back via tmux send-keys before closing.</r>
+    <r>Pane close sequence: send /exit first, then kill-pane. Never kill without /exit.</r>
+  </rules>
+
+  <menu>
+    <item n="1" cmd="NT">New task — triage a new feature, fix, or change request</item>
+    <item n="2" cmd="RS">Resume session — continue previous work by description, branch, or date</item>
+    <item n="3" cmd="VS">View session — show active session state and pipeline status</item>
+    <item n="4" cmd="LK">Lookup — search feedback/issues linked to current work</item>
+    <item n="5" cmd="SU">Status — show active branch, track, and current step</item>
+    <item n="6" cmd="RC">Refresh context — re-scan docs and update index</item>
+    <item n="7" cmd="SV">Save session — persist current state to sidecar</item>
+    <item n="8" cmd="XM">Switch execution mode — change between inline/command-blocks/scripts/teams</item>
+    <item n="9" cmd="TM">Merge task — combine current task with another branch</item>
+    <item n="10" cmd="RV">Review track — audit existing code without new feature triage</item>
+    <item n="11" cmd="UV">UI review — single-pass UI/UX audit</item>
+    <item n="12" cmd="UVL">UI review loop — N-pass autonomous UI review and fix cycle</item>
+    <item n="13" cmd="DRY">DRY/SOLID review — single-pass code quality audit</item>
+    <item n="14" cmd="DRYL">DRY/SOLID review loop — N-pass autonomous quality review cycle</item>
+    <item n="15" cmd="SR">Security review — single-pass security audit</item>
+    <item n="16" cmd="SRL">Security review loop — N-pass autonomous security review cycle</item>
+    <item n="17" cmd="EXIT">Exit Master Orchestrator</item>
+  </menu>
+</activation>
+</agent>
+```

package/src/docs/dev/tmux/actions_popup.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""tmux Actions — interactive multi-column grid menu."""
+import os, sys, termios, re, subprocess, select
+
+PANE = sys.argv[1] if len(sys.argv) > 1 else ""
+
+# Catppuccin Frappe palette
+HDR = '\033[1;38;2;140;170;238m'
+KEY = '\033[1;38;2;229;200;144m'
+TXT = '\033[0;38;2;198;208;245m'
+DIM = '\033[0;38;2;65;69;89m'
+SEP = '\033[0;38;2;115;121;148m'
+HBG = '\033[48;2;67;70;89m'
+HK  = '\033[1;38;2;255;213;116m'
+HT  = '\033[1;38;2;220;224;255m'
+RST = '\033[0m'
+
+W = 26  # cell content width (popup must be >= W*3 + 8)
+
+# All keys are lowercase. ("---", label) = separator. ("", "") = empty padding.
+COLS = [
+    [("z","  Zoom / unzoom pane"),("p","  Previous window"),("n","  Next window"),
+     ("w","  List windows & sessions"),("a","  New window"),("x","  Kill window"),
+     ("s","  Rename session"),("q","  Kill session"),("d","  Detach"),
+     ("","")],
+    [("h","  Split top / bottom"),("v","  Split left / right"),("k","  Kill pane"),
+     (",","  Rename window"),
+     ("---","Pane Movement"),
+     ("u","  Swap pane \u2190 prev"),("j","  Swap pane \u2192 next"),
+     ("e","  Break to new window"),("m","  Move to window\u2026"),("l","  Pull from window\u2026")],
+    [("f","  Float terminal"),("t","  Scratch terminal (M-i)"),
+     ("y","  Save session"),("r","  Restore session"),
+     ("---","Clipboard"),
+     ("c","  Copy mode"),("i","  Paste image"),
+     ("o","  Open URL / file"),("g","  Search in browser"),
+     ("","")],
+]
+
+NR = max(len(c) for c in COLS)
+NC = len(COLS)
+DATA_Y0 = 5  # 1-indexed terminal row where data row 0 starts
+
+def selectable(c, r):
+    if not (0 <= c < NC and 0 <= r < len(COLS[c])): return False
+    k, _ = COLS[c][r]
+    return bool(k) and k != "---"
+
+def render_cell(c, r, hl):
+    if r >= len(COLS[c]): return ' ' * W
+    k, d = COLS[c][r]
+    if not k: return ' ' * W
+    if k == "---":
+        s = f"\u2500\u2500 {d} "
+        s += '\u2500' * max(0, W - len(s))
+        return f"{SEP}{s[:W]}{RST}"
+    dp = d + ' ' * max(0, W - 1 - len(d))
+    if hl: return f"{HBG}{HK}{k}{HT}{dp}{RST}"
+    return f"{KEY}{k}{TXT}{dp}{RST}"
+
+def hline(l, m, r):
+    s = '\u2500' * (W + 2)
+    return f"{DIM}{l}{s}{m}{s}{m}{s}{r}{RST}\n"
+
+def data_row_line(r, sc, sr):
+    cells = [render_cell(c, r, sc == c and sr == r) for c in range(NC)]
+    return f"{DIM}\u2502{RST} {cells[0]} {DIM}\u2502{RST} {cells[1]} {DIM}\u2502{RST} {cells[2]} {DIM}\u2502{RST}"
+
+BSU = '\033[?2026h'   # begin synchronized update (buffer, don't render yet)
+ESU = '\033[?2026l'   # end synchronized update (flush to screen atomically)
+
+def draw(sc, sr):
+    """Full initial render."""
+    iw = W * 3 + 6
+    out = [BSU, "\033[2J\033[H",
+           f"{HDR}  {'tmux Actions':<{iw}}{RST}\n",
+           hline('\u250c', '\u252c', '\u2510')]
+    hdrs = [f"{HDR}{h:<{W}}{RST}" for h in
+            [' Window & Session', ' Pane Controls', ' Tools & Clipboard']]
+    out.append(f"{DIM}\u2502{RST} {hdrs[0]} {DIM}\u2502{RST} {hdrs[1]} {DIM}\u2502{RST} {hdrs[2]} {DIM}\u2502{RST}\n")
+    out.append(hline('\u251c', '\u253c', '\u2524'))
+    for r in range(NR):
+        out.append(data_row_line(r, sc, sr) + "\n")
+    out.append(hline('\u2514', '\u2534', '\u2518'))
+    out.append(f"\n{DIM}  \u2191\u2193\u2190\u2192 navigate \u00b7 Enter / click to run \u00b7 Esc cancel{RST}\n")
+    out.append(ESU)
+    sys.stdout.write(''.join(out))
+    sys.stdout.flush()
+
+def update(old_sc, old_sr, sc, sr):
+    """Redraw only the rows whose highlight state changed."""
+    rows = {old_sr, sr}
+    out = [BSU]
+    for r in sorted(rows):
+        out.append(f"\033[{DATA_Y0 + r};1H\033[2K{data_row_line(r, sc, sr)}")
+    out.append(ESU)
+    sys.stdout.write(''.join(out))
+    sys.stdout.flush()
+
+def x2col(x):
+    if 2 <= x <= W + 2:           return 0
+    if W + 4 <= x <= 2*W + 4:    return 1
+    if 2*W + 6 <= x <= 3*W + 6:  return 2
+    return -1
+
+def y2row(y): return y - DATA_Y0
+
+def move(sc, sr, dc, dr):
+    if dr:
+        r = sr + dr
+        while 0 <= r < NR:
+            if selectable(sc, r): return sc, r
+            r += dr
+        return sc, sr
+    if dc:
+        c = sc + dc
+        while 0 <= c < NC:
+            if selectable(c, sr): return c, sr
+            best_r, best_d = sr, NR
+            for r in range(NR):
+                if selectable(c, r):
+                    d = abs(r - sr)
+                    if d < best_d: best_d, best_r = d, r
+            if best_d < NR: return c, best_r
+            c += dc
+        return sc, sr
+    return sc, sr
+
+def tmux(*args, bg=False):
+    fn = subprocess.Popen if bg else subprocess.run
+    fn(['tmux'] + list(args))
+
+def execute(key):
+    T = (['-t', PANE] if PANE else [])
+    r = subprocess.run(['tmux', 'display-message', '-p'] + (['-t', PANE] if PANE else []) +
+                       ['#{pane_current_path}'], capture_output=True, text=True)
+    cwd = r.stdout.strip()
+    c_args = (['-c', cwd] if cwd else [])
+    H = os.path.expanduser('~')
+
+    dispatch = {
+        'z': lambda: tmux('resize-pane', '-Z', *T),
+        'p': lambda: tmux('previous-window'),
+        'n': lambda: tmux('next-window'),
+        'w': lambda: tmux('run-shell', '-b', "sleep 0.15 && tmux choose-tree -s"),
+        'a': lambda: tmux('new-window', *c_args),
+        'x': lambda: tmux('run-shell', '-b', "sleep 0.1 && tmux kill-window"),
+        # rename-session: lock flag prevents pane-title-changed hook from overriding manual name
+        's': lambda: tmux('run-shell', '-b', "sleep 0.15 && tmux command-prompt -I '#{session_name}' \"rename-session -- '%%' \\; set-option @session-name-locked 1\""),
+        'q': lambda: tmux('run-shell', '-b', "sleep 0.1 && tmux kill-session"),
+        'd': lambda: tmux('detach-client'),
+        'h': lambda: tmux('split-window', '-v', *c_args),
+        'v': lambda: tmux('split-window', '-h', *c_args),
+        'k': lambda: tmux('run-shell', '-b', f"sleep 0.1 && tmux kill-pane{' -t ' + PANE if PANE else ''}"),
+        # rename-window: lock flag prevents pane-title-changed hook from overriding manual name
+        ',': lambda: tmux('run-shell', '-b', "sleep 0.15 && tmux command-prompt -I '#W' \"rename-window -- '%%' \\; set-option -w @window-name-locked 1\""),
+        'u': lambda: tmux('swap-pane', '-U', *T),
+        'j': lambda: tmux('swap-pane', '-D', *T),
+        'e': lambda: tmux('break-pane', *T),
+        'm': lambda: tmux('run-shell', '-b', "sleep 0.2 && tmux choose-tree -w 'join-pane -t \"%%\"'"),
+        'l': lambda: tmux('run-shell', '-b', "sleep 0.2 && tmux choose-tree -w 'join-pane -s \"%%\"'"),
+        'f': lambda: tmux('run-shell', '-b', f"sleep 0.2 && bash ~/.config/tmux/bin/float_term.sh '{PANE}'"),
+        't': lambda: tmux('run-shell', '-b', f"sleep 0.2 && tmux popup -d '{cwd or H}' -xC -yC -w70% -h70% -E 'tmux new -A -s floating'"),
+        'y': lambda: tmux('run-shell', '~/.tmux/plugins/tmux-resurrect/scripts/save.sh'),
+        'r': lambda: tmux('run-shell', '~/.tmux/plugins/tmux-resurrect/scripts/restore.sh'),
+        'c': lambda: tmux('copy-mode', *T),
+        'i': lambda: tmux('run-shell', '-b', f"bash ~/.config/tmux/bin/paste_image_wrapper.sh '{PANE}'"),
+        'o': lambda: tmux('run-shell', '-b', 'bash ~/.config/tmux/bin/open_clip.sh url'),
+        'g': lambda: tmux('run-shell', '-b', 'bash ~/.config/tmux/bin/open_clip.sh search'),
+    }
+    if key in dispatch:
+        dispatch[key]()
+
+def set_raw_input(fd):
+    """Enable raw input while keeping output processing (ONLCR) intact.
+    tty.setraw() disables OPOST which strips the CR from \\n, causing
+    each output line to drift right. We only want to affect input flags."""
+    new = termios.tcgetattr(fd)
+    new[0] &= ~(termios.BRKINT | termios.ICRNL | termios.INPCK |
+                termios.ISTRIP | termios.IXON)
+    new[2]  =  (new[2] & ~termios.CSIZE) | termios.CS8
+    new[3] &= ~(termios.ECHO | termios.ICANON | termios.IEXTEN | termios.ISIG)
+    new[6][termios.VMIN]  = 1
+    new[6][termios.VTIME] = 0
+    # new[1] (output flags) left untouched — keeps OPOST/ONLCR so \n → \r\n
+    termios.tcsetattr(fd, termios.TCSADRAIN, new)
+
+def main():
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+
+    sc, sr = 0, 0
+    while not selectable(sc, sr) and sr < NR - 1: sr += 1
+
+    try:
+        set_raw_input(fd)
+        # Clear, hide cursor, enable SGR mouse + motion tracking
+        sys.stdout.write('\033[2J\033[H\033[?25l\033[?1000h\033[?1006h\033[?1003h')
+        sys.stdout.flush()
+        draw(sc, sr)
+
+        result = None
+        buf = b''
+
+        while result is None:
+            rdy, _, _ = select.select([fd], [], [], 2.0)
+            if not rdy: continue
+            buf += os.read(fd, 128)
+
+            while buf and result is None:
+                ch = buf[0:1]
+
+                if ch == b'\x1b':
+                    if len(buf) < 2:
+                        # Peek briefly to distinguish bare ESC from a multi-byte sequence
+                        r2, _, _ = select.select([fd], [], [], 0.05)
+                        if r2: buf += os.read(fd, 128)
+                    if len(buf) < 2 or buf[1:2] != b'[':
+                        result = ''   # bare ESC → quit
+                        break
+                    i = 2
+                    while i < len(buf) and buf[i] not in b'ABCDHFMPQRSmnlh~': i += 1
+                    if i >= len(buf): break  # incomplete sequence — wait for more
+                    seq = buf[:i+1].decode('latin-1', errors='replace')
+                    buf = buf[i+1:]
+
+                    nc, nr = sc, sr
+                    if   seq == '\033[A': nc, nr = move(sc, sr, 0, -1)   # up arrow
+                    elif seq == '\033[B': nc, nr = move(sc, sr, 0,  1)   # down arrow
+                    elif seq == '\033[D': nc, nr = move(sc, sr, -1, 0)   # left arrow
+                    elif seq == '\033[C': nc, nr = move(sc, sr,  1, 0)   # right arrow
+                    else:
+                        m = re.match(r'\x1b\[<(\d+);(\d+);(\d+)([Mm])', seq)
+                        if m:
+                            btn, mx, my, typ = int(m[1]), int(m[2]), int(m[3]), m[4]
+                            if btn == 64:                        # scroll up → navigate up
+                                nc, nr = move(sc, sr, 0, -1)
+                            elif btn == 65:                      # scroll down → navigate down
+                                nc, nr = move(sc, sr, 0,  1)
+                            else:
+                                c2, r2 = x2col(mx), y2row(my)
+                                if c2 >= 0 and 0 <= r2 < NR and selectable(c2, r2):
+                                    if 32 <= btn < 64:           # motion (not scroll) → hover
+                                        nc, nr = c2, r2
+                                    elif btn == 0 and typ == 'M':  # left click → execute
+                                        nc, nr = c2, r2
+                                        if nc != sc or nr != sr:
+                                            old_sc, old_sr = sc, sr
+                                            sc, sr = nc, nr
+                                            update(old_sc, old_sr, sc, sr)
+                                        result = COLS[sc][sr][0]
+
+                    if result is None and (nc != sc or nr != sr):
+                        old_sc, old_sr = sc, sr
+                        sc, sr = nc, nr
+                        update(old_sc, old_sr, sc, sr)
+
+                elif ch in (b'\r', b'\n'):
+                    buf = buf[1:]
+                    if selectable(sc, sr): result = COLS[sc][sr][0]
+                    else: result = ''
+
+                elif ch in (b'\x03', b'\x04'):   # Ctrl+C / Ctrl+D
+                    buf = buf[1:]
+                    result = ''
+
+                else:
+                    # Direct key: jump selection to matching action (no immediate execute)
+                    key_char = ch.decode('latin-1', errors='ignore')
+                    buf = buf[1:]
+                    for cc in range(NC):
+                        for rr in range(len(COLS[cc])):
+                            if selectable(cc, rr) and COLS[cc][rr][0] == key_char:
+                                if (cc, rr) != (sc, sr):
+                                    old_sc, old_sr = sc, sr
+                                    sc, sr = cc, rr
+                                    update(old_sc, old_sr, sc, sr)
+                                break
+                        else:
+                            continue
+                        break
+
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        sys.stdout.write('\033[?1003l\033[?1006l\033[?1000l\033[?25h\033[2J\033[H')
+        sys.stdout.flush()
+
+    if result:
+        execute(result)
+
+if __name__ == '__main__':
+    main()

package/src/docs/dev/tmux/actions_popup.sh

@@ -0,0 +1,110 @@
+#!/bin/bash
+# actions_popup.sh — fzf-powered actions menu
+PANE="${1:-}"
+FZF="${HOME}/.local/bin/fzf"
+
+ITEMS=(
+    "z  │ Zoom / unzoom pane"
+    "p  │ Previous window"
+    "n  │ Next window"
+    "w  │ List windows & sessions"
+    "W  │ New window"
+    "K  │ Kill window"
+    "N  │ Rename session"
+    "X  │ Kill session"
+    "d  │ Detach"
+    "───┼──────────────────────────────────"
+    "H  │ Split top / bottom"
+    "V  │ Split left / right"
+    "k  │ Kill pane"
+    ",  │ Rename window"
+    "s  │ Session chooser"
+    "───┼──────────────────────────────────"
+    "u  │ Swap pane up"
+    "v  │ Swap pane down"
+    "<  │ Swap pane left"
+    ">  │ Swap pane right"
+    "e  │ Break pane → new window"
+    "J  │ Move pane to window…"
+    "L  │ Pull pane from window…"
+    "───┼──────────────────────────────────"
+    "f  │ Float terminal"
+    "t  │ Scratch terminal (M-i)"
+    "M  │ Share session (Muxile)"
+    "S  │ Save session"
+    "R  │ Restore session"
+    "───┼──────────────────────────────────"
+    "r  │ Reload tmux config"
+    "c  │ Copy mode  (o=open  S=search)"
+    "i  │ Paste image"
+    "o  │ Open clipboard URL/file"
+    "g  │ Search clipboard in browser"
+)
+
+SELECTED=$(printf '%s\n' "${ITEMS[@]}" | "$FZF" \
+    --ansi \
+    --no-sort \
+    --layout=reverse \
+    --border=rounded \
+    --border-label=" ⚙  Actions " \
+    --border-label-pos=3 \
+    --color="bg:#303446,bg+:#414559,fg:#c6d0f5,fg+:#c6d0f5" \
+    --color="border:#626880,label:#ef9f76,prompt:#8caaee" \
+    --color="pointer:#e78284,hl:#8caaee,hl+:#8caaee" \
+    --prompt="  " \
+    --pointer="▶" \
+    --no-info \
+    --bind "esc:abort" \
+    --bind "left-click:accept" \
+    --with-nth=1..2 \
+    --delimiter="│")
+
+[ -z "$SELECTED" ] && exit 0
+
+IFS='│' read -r key _ <<< "$SELECTED"
+key="${key//[[:space:]]/}"
+[[ "$key" == "───" ]] && exit 0
+
+T="${PANE:+-t $PANE}"
+case "$key" in
+    # ── Window & session ────────────────────────────────────────────────────
+    z) tmux resize-pane -Z $T ;;
+    p) tmux previous-window ;;
+    n) tmux next-window ;;
+    w) tmux choose-tree -s ;;
+    W) CWD=$(tmux display-message -p ${PANE:+-t "$PANE"} '#{pane_current_path}' 2>/dev/null)
+       tmux new-window ${CWD:+-c "$CWD"} ;;
+    K) tmux confirm-before -p "Kill window? (y/n)" kill-window ;;
+    N) tmux command-prompt -I "#{session_name}" "rename-session -- '%%'" ;;
+    X) tmux confirm-before -p "Kill session? (y/n)" kill-session ;;
+    d) tmux confirm-before -p "Detach? (y/n)" detach-client ;;
+    # ── Pane controls ───────────────────────────────────────────────────────
+    H) CWD=$(tmux display-message -p ${PANE:+-t "$PANE"} '#{pane_current_path}' 2>/dev/null)
+       tmux split-window -v ${CWD:+-c "$CWD"} ;;
+    V) CWD=$(tmux display-message -p ${PANE:+-t "$PANE"} '#{pane_current_path}' 2>/dev/null)
+       tmux split-window -h ${CWD:+-c "$CWD"} ;;
+    k) tmux confirm-before -p "Kill pane? (y/n)" kill-pane $T ;;
+    ,) tmux command-prompt -I "#W" "rename-window -- '%%'" ;;
+    s) tmux choose-tree -s ;;
+    # ── Pane movement ───────────────────────────────────────────────────────
+    u) tmux swap-pane -U $T ;;
+    v) tmux swap-pane -D $T ;;
+    '<') tmux swap-pane -U $T ;;
+    '>') tmux swap-pane -D $T ;;
+    e) tmux break-pane $T ;;
+    J) tmux run-shell -b "sleep 0.2 && tmux choose-tree -w 'join-pane -t \"%%\"'" ;;
+    L) tmux run-shell -b "sleep 0.2 && tmux choose-tree -w 'join-pane -s \"%%\"'" ;;
+    # ── Tools ───────────────────────────────────────────────────────────────
+    f) tmux run-shell -b "sleep 0.2 && bash ~/.config/tmux/bin/float_term.sh '$PANE'" ;;
+    t) CWD=$(tmux display-message -p ${PANE:+-t "$PANE"} '#{pane_current_path}' 2>/dev/null)
+       tmux run-shell -b "sleep 0.2 && tmux popup -d '${CWD:-$HOME}' -xC -yC -w70% -h70% -E 'tmux new -A -s floating'" ;;
+    M) tmux run-shell -b "~/.tmux/plugins/muxile/scripts/main.sh" ;;
+    S) tmux run-shell "~/.tmux/plugins/tmux-resurrect/scripts/save.sh" ;;
+    R) tmux run-shell "~/.tmux/plugins/tmux-resurrect/scripts/restore.sh" ;;
+    # ── Clipboard & copy ────────────────────────────────────────────────────
+    r) tmux source-file ~/.tmux.conf \; display-message "Config reloaded" ;;
+    c) tmux copy-mode $T ;;
+    i) tmux run-shell -b "bash ~/.config/tmux/bin/paste_image_wrapper.sh '$PANE'" ;;
+    o) tmux run-shell -b "bash ~/.config/tmux/bin/open_clip.sh url" ;;
+    g) tmux run-shell -b "bash ~/.config/tmux/bin/open_clip.sh search" ;;
+esac

package/src/docs/dev/tmux/claude_usage.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+latest=$(ls -t ~/.claude/projects/*/*.jsonl 2>/dev/null | head -1)
+if [ -n "$latest" ]; then
+  size=$(wc -c < "$latest")
+  pct=$(( size * 100 / 800000 ))
+  [ "$pct" -gt 100 ] && pct=100
+  filled=$(( pct / 10 ))
+  empty=$(( 10 - filled ))
+  bar=""
+  for ((i=0; i<filled; i++)); do bar+="█"; done
+  for ((i=0; i<empty; i++)); do bar+="░"; done
+  echo "${bar} ${pct}%"
+else
+  echo "░░░░░░░░░░ --%"
+fi

package/src/docs/dev/tmux/colors.conf

@@ -0,0 +1,26 @@
+set -g @thm_rosewater "#f2d5cf"
+set -g @thm_flamingo "#eebebe"
+set -g @thm_pink "#f4b8e4"
+set -g @thm_mauve "#ca9ee6"
+set -g @thm_red "#e78284"
+set -g @thm_maroon "#ea999c"
+set -g @thm_peach "#ef9f76"
+set -g @thm_yellow "#e5c890"
+set -g @thm_green "#a6d189"
+set -g @thm_teal "#81c8be"
+set -g @thm_sky "#99d1db"
+set -g @thm_sapphire "#85c1dc"
+set -g @thm_blue "#8caaee"
+set -g @thm_lavender "#babbf1"
+set -g @thm_text "#c6d0f5"
+set -g @thm_subtext1 "#b5bfe2"
+set -g @thm_subtext0 "#a5adce"
+set -g @thm_overlay2 "#949cbb"
+set -g @thm_overlay1 "#838ba7"
+set -g @thm_overlay0 "#737994"
+set -g @thm_surface2 "#626880"
+set -g @thm_surface1 "#51576d"
+set -g @thm_surface0 "#414559"
+set -g @thm_base "#303446"
+set -g @thm_mantle "#292c3c"
+set -g @thm_crust "#232634"

package/src/docs/dev/tmux/cpu_usage.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+read -r _ u1 n1 s1 i1 _ < /proc/stat
+sleep 0.3
+read -r _ u2 n2 s2 i2 _ < /proc/stat
+total=$(( (u2+n2+s2+i2) - (u1+n1+s1+i1) ))
+idle=$(( i2 - i1 ))
+[ "$total" -gt 0 ] && echo "$(( 100 * (total - idle) / total ))%" || echo "0%"

package/src/docs/dev/tmux/dispatch.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# dispatch.sh — handles status bar button clicks
+# $1 = mouse_status_range (button tag), $2 = pane_id
+PANE="${2:-}"
+
+case "$1" in
+  reload)  tmux source-file ~/.tmux.conf && tmux display-message "Config reloaded" ;;
+  actions) ;; # handled inline in tmux.conf MouseDown1Status binding
+  *)  exit 0 ;;
+esac

package/src/docs/dev/tmux/float_init.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Float terminal shell init — sourced via bash --init-file
+[ -f ~/.bashrc ] && source ~/.bashrc 2>/dev/null
+
+_float_w() { cat "${FLOAT_STATE:-/tmp/tmux_float_size}" 2>/dev/null || echo 80; }
+
+float_bigger()  { printf $'\n'; exit 10; }
+float_smaller() { printf $'\n'; exit 11; }
+
+bind -x '"\e=": float_bigger'  2>/dev/null   # Alt+=
+bind -x '"\e-": float_smaller' 2>/dev/null   # Alt+-
+
+printf '  [%s%%]  Alt+= bigger  Alt+- smaller  Ctrl+D close\n' "$(_float_w)"

package/src/docs/dev/tmux/float_term.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# float_term.sh — resizable float terminal
+# Exit codes from inner shell: 10 = bigger, 11 = smaller, else = close
+PANE="${1:-}"
+STATE="/tmp/tmux_float_size"
+[ -f "$STATE" ] || echo "80" > "$STATE"
+
+while true; do
+    W=$(cat "$STATE" 2>/dev/null); W=${W:-80}
+    CWD=$(tmux display-message -p ${PANE:+-t "$PANE"} '#{pane_current_path}' 2>/dev/null)
+
+    tmux display-popup -E \
+        -d "${CWD:-$HOME}" -xC -yC \
+        -w "${W}%" -h "${W}%" \
+        "FLOAT_STATE='$STATE' bash --init-file ~/.config/tmux/bin/float_init.sh -i"
+
+    rc=$?
+    case $rc in
+        10) NEW=$(( W + 10 )); [ $NEW -gt 96 ] && NEW=96; echo "$NEW" > "$STATE" ;;
+        11) NEW=$(( W - 10 )); [ $NEW -lt 30 ] && NEW=30; echo "$NEW" > "$STATE" ;;
+        *) break ;;
+    esac
+done

package/src/docs/dev/tmux/open_clip.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# open_clip.sh — open clipboard as URL/file or browser search
+# Usage: open_clip.sh [url|search]
+MODE="${1:-url}"
+CLIP=$(powershell.exe -NoProfile -Command \
+    "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; Get-Clipboard" \
+    2>/dev/null | tr -d '\r' | head -1)
+[ -z "$CLIP" ] && exit 1
+
+case "$MODE" in
+    url)    powershell.exe Start "$CLIP" 2>/dev/null ;;
+    search) ENC=$(python3 -c "import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))" "$CLIP" 2>/dev/null || printf '%s' "$CLIP")
+            powershell.exe Start "https://www.google.com/search?q=${ENC}" 2>/dev/null ;;
+esac

package/src/docs/dev/tmux/paste_claude.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# paste_claude.sh — paste Windows clipboard into any tmux pane with bracketed paste support
+#
+# Claude Code (and most modern TUI apps) use bracketed paste mode (\e[200~ ... \e[201~).
+# Raw tmux paste-buffer -p bypasses these wrappers — Claude drops the input entirely.
+# This script wraps the clipboard content in the correct bracketed paste escape sequences
+# using tmux send-keys, which passes literal bytes directly to the pane's stdin.
+#
+# Usage (called from tmux binding):
+#   bash ~/.config/tmux/bin/paste_claude.sh '#{pane_id}'
+#
+# Bound to C-v in tmux.conf (replaces the old paste-buffer -p binding).
+
+PANE="${1:-}"
+
+# Get clipboard content from Windows
+CONTENT=$(powershell.exe -NoProfile -Command \
+  "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; Get-Clipboard" \
+  2>/dev/null | tr -d '\r')
+
+[ -z "$CONTENT" ] && exit 0
+
+# Send with bracketed paste sequences so Claude Code (and readline/readline-like TUIs) accept it.
+# \e[200~ = paste start, \e[201~ = paste end
+# send-keys without -l interprets the escape sequences correctly as terminal control codes.
+tmux send-keys -t "$PANE" $'\e[200~'"${CONTENT}"$'\e[201~'

package/src/docs/dev/tmux/paste_clipboard.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# paste_clipboard.sh — paste text from Windows clipboard into tmux
+TMPFILE=$(mktemp /tmp/tmux_paste_XXXXXX.txt)
+powershell.exe -NoProfile -Command \
+  "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; Get-Clipboard" \
+  2>/dev/null | tr -d '\r' > "$TMPFILE"
+BYTE_COUNT=$(wc -c < "$TMPFILE")
+PREVIEW=$(head -c 80 "$TMPFILE" | cat -v)
+tmux display-message "Clipboard bytes:${BYTE_COUNT} | ${PREVIEW}"
+if [ -s "$TMPFILE" ]; then
+    tmux load-buffer "$TMPFILE" && tmux paste-buffer -p
+fi
+rm -f "$TMPFILE"