3.1c.

Do not write after the end of the array and overwrite the stack when
colon-separated SGR sequences contain empty arguments. Reported by Sergey Nizovtsev.
2026-09-17 10:34:46 +00:00 · 2020-10-30 12:11:02 +00:00 · 2020-10-30 12:09:52 +00:00
524 changed files with 18304 additions and 104141 deletions
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -29,7 +29,7 @@ uname -sp && tmux -V && echo $TERM

 Also include:

- Your platform (Linux, macOS, or whatever).
+- Your platform (Linux, OS X, or whatever).

 - A brief description of the problem with steps to reproduce.

@@ -37,8 +37,7 @@ Also include:

 - Your terminal, and `$TERM` inside and outside of tmux.

- Logs from tmux (see below). Please attach logs to the issue directly rather
-  than using a download site or pastebin. Put in a zip file if necessary.
+- Logs from tmux (see below).

 - At most one or two screenshots, if helpful.

@@ -63,7 +62,7 @@ tmux -vv -Ltest -f/dev/null new

 Or if you need your configuration:

-~~~bash
+~~~base
 tmux kill-server
 tmux -vv new
 ~~~
@@ -77,8 +76,3 @@ The log files are:
 - `tmux-out*.log`: output log file.

 Please attach the log files to your issue.
-
-## What does it mean if an issue is closed?
-
-All it means is that work on the issue is not planned for the near future. See
-the issue's comments to find out if contributions would be welcome.
--- a/.github/ISSUE_TEMPLATE/use-this-issue-template.md
+++ b/.github/ISSUE_TEMPLATE/use-this-issue-template.md
@@ -1,12 +1,3 @@
---
-name: Use this issue template
-about: Please read https://github.com/tmux/tmux/blob/master/.github/CONTRIBUTING.md
-title: ''
-labels: ''
-assignees: ''
-
---
-
 ### Issue description

 Please read https://github.com/tmux/tmux/blob/master/.github/CONTRIBUTING.md
@@ -23,11 +14,9 @@ built from the latest code in Git.

 ### Required information

-Please provide the following information. These are **required**. Note that bug reports without logs may be ignored or closed without comment.
+Please provide the following information:

 * tmux version (`tmux -V`).
 * Platform (`uname -sp`).
-* Terminal in use (xterm, rxvt, etc).
-* $TERM *inside* tmux (`echo $TERM`).
-* $TERM *outside* tmux (`echo $TERM`).
+* $TERM inside and outside of tmux (`echo $TERM`).
 * Logs from tmux (`tmux kill-server; tmux -vv new`).
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1 +0,0 @@
-blank_issues_enabled: false
--- a/.github/README.md
+++ b/.github/README.md
@@ -4,7 +4,7 @@ tmux is a terminal multiplexer: it enables a number of terminals to be created,
 accessed, and controlled from a single screen. tmux may be detached from a
 screen and continue running in the background, then later reattached.

-This release runs on OpenBSD, FreeBSD, NetBSD, Linux, macOS and Solaris.
+This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.

 ## Dependencies

@@ -14,17 +14,8 @@ page](https://github.com/libevent/libevent/releases/latest).
 It also depends on [ncurses](https://www.gnu.org/software/ncurses/), available
 from [this page](https://invisible-mirror.net/archives/ncurses/).

-To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
-suitable yacc (yacc or bison) are needed.
-
 ## Installation

-### Binary packages
-
-Some platforms provide binary packages for tmux, although these are sometimes
-out of date. Examples are listed on
-[this page](https://github.com/tmux/tmux/wiki/Installing).
-
 ### From release tarball

 To build and install tmux from a release tarball, use:
@@ -37,9 +28,6 @@ sudo make install
 tmux can use the utempter library to update utmp(5), if it is installed - run
 configure with `--enable-utempter` to enable this.

-For more detailed instructions on building and installing tmux, see
-[this page](https://github.com/tmux/tmux/wiki/Installing).
-
 ### From version control

 To get and build the latest from version control - note that this requires
@@ -79,9 +67,9 @@ A small example configuration is in `example_tmux.conf`.

 And a bash(1) completion file at:

-https://github.com/scop/bash-completion/blob/main/completions-core/tmux.bash
+https://github.com/imomaliev/tmux-bash-completion

-For debugging, run tmux with `-v` or `-vv` to generate server and client log
+For debugging, run tmux with `-v` or `-vv` to generate server and client log 
 files in the current directory.

 ## Support
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -1,11 +0,0 @@
-For pull request code reviews in this repository, do not leave any review comments under any circumstances.
-
-If asked to review a pull request, produce no comments.
-
-Do not comment on pull requests in this repository.
-
-For pull request code reviews in this repository, do not leave a pull request overview.
-
-Do not leave inline review comments.
-
-If asked to review a pull request, provide no summary, no overview, and no code comments.
--- a/.github/lock.yml
+++ b/.github/lock.yml
@@ -0,0 +1,10 @@
+daysUntilLock: 180
+skipCreatedBefore: false
+exemptLabels: []
+lockLabel: false
+lockComment: >
+  This thread has been automatically locked since there has not been
+  any recent activity after it was closed. Please open a new issue for
+  related bugs.
+setLockReason: false
+#only: issues
--- a/.github/travis/before-install.sh
+++ b/.github/travis/before-install.sh
@@ -1,24 +0,0 @@
-#!/bin/sh
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-	sudo apt-get update -qq
-	sudo apt-get -y install bison \
-				autotools-dev \
-				libncurses5-dev \
-				libevent-dev \
-				pkg-config \
-				libutempter-dev \
-				build-essential
-
-	if [ "$BUILD" = "musl" -o "$BUILD" = "musl-static" ]; then
-		sudo apt-get -y install musl-dev \
-					musl-tools
-	fi
-fi
-
-if [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
-	sudo pkg install -y \
-		automake \
-		libevent \
-		pkgconf
-fi
--- a/.github/travis/build-all.sh
+++ b/.github/travis/build-all.sh
@@ -1,38 +0,0 @@
-#!/bin/sh
-
-BUILD=$PWD/build
-
-LIBEVENT=https://github.com/libevent/libevent/releases/download/release-2.1.11-stable/libevent-2.1.11-stab\
-le.tar.gz
-NCURSES=https://ftp.gnu.org/gnu/ncurses/ncurses-6.2.tar.gz
-
-wget -4q $LIBEVENT || exit 1
-tar -zxf libevent-*.tar.gz || exit 1
-(cd libevent-*/ &&
-	 ./configure --prefix=$BUILD \
-		     --enable-shared \
-		     --disable-libevent-regress \
-		     --disable-samples &&
-	 make && make install) || exit 1
-
-wget -4q $NCURSES || exit 1
-tar -zxf ncurses-*.tar.gz || exit 1
-(cd ncurses-*/ &&
-	CPPFLAGS=-P ./configure --prefix=$BUILD \
-				--with-shared \
-				--with-termlib \
-				--without-ada \
-				--without-cxx \
-				--without-manpages \
-				--without-progs \
-				--without-tests \
-				--without-tack \
-				--disable-database \
-				--enable-termcap \
-				--enable-pc-files \
-				--with-pkg-config-libdir=$BUILD/lib/pkgconfig &&
-	 make && make install) || exit 1
-
-sh autogen.sh || exit 1
-PKG_CONFIG_PATH=$BUILD/lib/pkgconfig ./configure --prefix=$BUILD "$@"
-make && make install || (cat config.log; exit 1)
--- a/.github/travis/build.sh
+++ b/.github/travis/build.sh
@@ -1,25 +0,0 @@
-#!/bin/sh
-
-sh autogen.sh || exit 1
-case "$BUILD" in
-	static)
-		./configure --enable-static || exit 1
-		exec make
-		;;
-	all)
-		sh $(dirname $0)/build-all.sh
-		exec make
-		;;
-	musl)
-		CC=musl-gcc sh $(dirname $0)/build-all.sh
-		exec make
-		;;
-	musl-static)
-		CC=musl-gcc sh $(dirname $0)/build-all.sh --enable-static
-		exec make
-		;;
-	*)
-		./configure || exit 1
-		exec make
-		;;
-esac
--- a/.github/workflows/lock.yml
+++ b/.github/workflows/lock.yml
@@ -1,36 +0,0 @@
-name: 'Lock Threads'
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-  discussions: write
-
-concurrency:
-  group: lock-threads
-
-jobs:
-  action:
-    runs-on: ubuntu-latest
-    if: github.repository == 'tmux/tmux'
-    timeout-minutes: 10
-    steps:
-      - uses: dessant/lock-threads@89ae32b08ed1a541efecbab17912962a5e38981c # v6
-        with:
-          github-token: ${{ github.token }}
-          issue-inactive-days: '30'
-          issue-comment: >
-            This issue has been automatically locked since there
-            has not been any recent activity after it was closed.
-          pr-inactive-days: '60'
-          pr-comment: >
-            This pull request has been automatically locked since there
-            has not been any recent activity after it was closed.
-          discussion-inactive-days: '60'
-          discussion-comment: >
-            This discussion has been automatically locked since there
-            has not been any recent activity after it was closed.
--- a/.github/workflows/regress.yml
+++ b/.github/workflows/regress.yml
@@ -1,90 +0,0 @@
-name: 'Run Tests'
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '33 3 * * *'
-
-permissions:
-  contents: read
-
-concurrency:
-  group: tmux-tests
-  cancel-in-progress: true
-
-jobs:
-  regress:
-    name: ${{ matrix.name }}
-    runs-on: ${{ matrix.runner }}
-    if: github.repository == 'tmux/tmux'
-    timeout-minutes: 300
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: ubuntu-24.04-x64
-            runner: ubuntu-24.04
-            make: make
-            configure: --enable-utf8proc --enable-asan
-          #- name: ubuntu-24.04-arm64
-          #  runner: ubuntu-24.04-arm
-          #  make: make
-          #  configure: --enable-utf8proc --enable-asan
-          - name: macos-26-arm64
-            runner: macos-26
-            make: gmake
-            configure: --enable-utf8proc --enable-asan
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
-        with:
-          persist-credentials: false
-
-      - name: dependencies
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            autoconf \
-            automake \
-            bison \
-            build-essential \
-            libevent-dev \
-            libncurses-dev \
-            libutf8proc-dev \
-            pkg-config
-
-      - name: dependencies
-        if: runner.os == 'macOS'
-        run: |
-          brew install \
-            autoconf \
-            automake \
-            bison \
-            libevent \
-            jemalloc \
-            make \
-            ncurses \
-            utf8proc \
-            pkg-config
-
-      - name: build
-        run: |
-         sh autogen.sh
-          ./configure ${{ matrix.configure }}
-          ${{ matrix.make }} -j"$(getconf _NPROCESSORS_ONLN)"
-
-      - name: test
-        run: |
-          cd regress
-          ${{ matrix.make }}
-
-      - name: logs
-        if: failure()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: regress-logs-${{ matrix.name }}
-          path: regress/logs/*.log
-          if-no-files-found: ignore
--- a/.gitignore
+++ b/.gitignore
@@ -1,27 +1,21 @@
-*.core
-*.dSYM
-*.diff
 *.o
-*.patch
-*.swp
 *~
+*.diff
+*.patch
+*.core
+core
+tags
 .deps/
-.dirstamp
-.serena/
-AGENTS.md
-Makefile
-Makefile.in
+compat/.dirstamp
 aclocal.m4
 autom4te.cache/
-cmd-parse.c
-compat/.dirstamp
 config.log
 config.status
-configure
-core
 etc/
-fuzz/*-fuzzer
-regress/logs/
-tags
 tmux
+Makefile
+Makefile.in
+configure
 tmux.1.*
+*.dSYM
+cmd-parse.c
--- a/.mailmap
+++ b/.mailmap
@@ -29,7 +29,6 @@ Ted Unangst		<tedu@openbsd.org> tedu <tedu>
 Theo de Raadt		<deraadt@openbsd.org> Theo Deraadt <deraadt@openbsd.org>
 Theo de Raadt		<deraadt@openbsd.org> deraadt <deraadt>
 Thomas Adam		<thomas@xteddy.org> Thomas <thomas@xteddy.org>
-Thomas Adam		<thomas@xteddy.org> Thomas Adam <thomas.adam22@gmail.com>
 Thomas Adam		<thomas@xteddy.org> Thomas Adam <thomas.adam@smoothwall.net>
 Thomas Adam		<thomas@xteddy.org> n6tadam <n6tadam@xteddy.org>
 Tim van der Molen	<tim@openbsd.org> tim <tim>
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,88 +1,16 @@
 language: c

 os:
-  - linux
-  - freebsd
-  - osx
+    - linux
+    - osx

 compiler:
-  - gcc
-  - clang
-
-arch:
-  - amd64
-  - arm64
-
-env:
-  - BUILD=
-  - BUILD=static
-  - BUILD=all
-  - BUILD=musl
-  - BUILD=musl-static
-
-jobs:
-  exclude:
-    # Static builds are broken on OS X (by Apple)
-    - os: osx
-      compiler: gcc
-      env: BUILD=static
-    - os: osx
-      compiler: clang
-      env: BUILD=static
-    # No musl on FreeBSD
-    - os: freebsd
-      compiler: gcc
-      env: BUILD=musl
-    - os: freebsd
-      compiler: clang
-      env: BUILD=musl
-    - os: freebsd
-      compiler: gcc
-      env: BUILD=musl-static
-    - os: freebsd
-      compiler: clang
-      env: BUILD=musl-static
-    # No musl on OS X
-    - os: osx
-      compiler: gcc
-      env: BUILD=musl
-    - os: osx
-      compiler: clang
-      env: BUILD=musl
-    - os: osx
-      compiler: gcc
-      env: BUILD=musl-static
-    - os: osx
-      compiler: clang
-      env: BUILD=musl-static
-    # arm64 doesn't link ncurses
-    - os: linux
-      compiler: gcc
-      arch: arm64
-      env: BUILD=all
-    - os: linux
-      compiler: clang
-      arch: arm64
-      env: BUILD=all
-    - os: linux
-      compiler: gcc
-      arch: arm64
-      env: BUILD=musl
-    - os: linux
-      compiler: clang
-      arch: arm64
-      env: BUILD=musl
-    - os: linux
-      compiler: gcc
-      arch: arm64
-      env: BUILD=musl-static
-    - os: linux
-      compiler: clang
-      arch: arm64
-      env: BUILD=musl-static
+    - gcc
+    - clang

 before_install:
-  - sh .github/travis/before-install.sh
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get update -qq; fi
+    - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get -y install bison autotools-dev libncurses5-dev libevent-dev pkg-config libutempter-dev build-essential; fi

 script:
-  - sh .github/travis/build.sh
+    - ./autogen.sh && ./configure && make
--- a/1578
+++ b/1578
--- a/7
+++ b/7
@@ -1,4 +1,9 @@
-Copyright (c) Various Authors
+THIS IS FOR INFORMATION ONLY, CODE IS UNDER THE LICENCE AT THE TOP OF ITS FILE.
+
+The README, CHANGES, FAQ and TODO files are licensed under the ISC license. All
+other files have a license and copyright notice at their start, typically:
+
+Copyright (c) <author>

 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,52 +1,37 @@
+# Makefile.am
+
 # Obvious program stuff.
 bin_PROGRAMS = tmux
 CLEANFILES = tmux.1.mdoc tmux.1.man cmd-parse.c

 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES README COPYING example_tmux.conf \
+	CHANGES README README.ja COPYING example_tmux.conf \
 	osdep-*.c mdoc2man.awk tmux.1
 dist_EXTRA_tmux_SOURCES = compat/*.[ch]

 # Preprocessor flags.
 AM_CPPFLAGS += @XOPEN_DEFINES@ \
-	-DTMUX_VERSION='"@VERSION@"' \
-	-DTMUX_CONF='"$(sysconfdir)/tmux.conf:~/.tmux.conf:$$XDG_CONFIG_HOME/tmux/tmux.conf:~/.config/tmux/tmux.conf"' \
-	-DTMUX_LOCK_CMD='"@DEFAULT_LOCK_CMD@"' \
-	-DTMUX_TERM='"@DEFAULT_TERM@"' \
-	-DTMUX_MOUSE=1
+	-DTMUX_VERSION="\"@VERSION@\"" \
+	-DTMUX_CONF="\"$(sysconfdir)/tmux.conf:~/.tmux.conf:~/.config/tmux/tmux.conf\""

 # Additional object files.
 LDADD = $(LIBOBJS)

 # Set flags for gcc.
 if IS_GCC
-AM_CFLAGS += -std=gnu99
-if IS_OPTIMIZED
-AM_CFLAGS += -O2
-else
-AM_CFLAGS += -O0
-endif
+AM_CFLAGS += -std=gnu99 -O2
 if IS_DEBUG
-AM_CFLAGS += -g3 -ggdb
-AM_CFLAGS += -Wno-long-long -Wall -W -Wformat=2 -Wno-use-after-free
+AM_CFLAGS += -g
+AM_CFLAGS += -Wno-long-long -Wall -W -Wformat=2
 AM_CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
 AM_CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wno-cast-align
+AM_CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
 AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
-AM_CFLAGS += -Wno-unused-result -Wno-format-y2k -Wno-unknown-warning-option
-AM_CFLAGS += -Wno-maybe-uninitialized
-if IS_DARWIN
-AM_CFLAGS += -Wno-deprecated-declarations -Wno-macro-redefined
-endif
+AM_CFLAGS += -Wno-unused-result
 AM_CPPFLAGS += -DDEBUG
 endif
 AM_CPPFLAGS += -iquote.
-if IS_ASAN
-AM_CPPFLAGS += -DASAN
-AM_CFLAGS += -fsanitize=address -fno-omit-frame-pointer
-AM_LDFLAGS += -fsanitize=address
-endif
 endif

 # Set flags for Solaris.
@@ -73,16 +58,6 @@ if IS_NETBSD
 AM_CPPFLAGS += -D_OPENBSD_SOURCE
 endif

-# Set flags for Haiku.
-if IS_HAIKU
-AM_CPPFLAGS += -D_BSD_SOURCE
-endif
-
-# Set flags for Cygwin.
-if IS_CYGWIN
-AM_CPPFLAGS += -DTMUX_SOCK_PERM=0
-endif
-
 # List of sources.
 dist_tmux_SOURCES = \
 	alerts.c \
@@ -101,6 +76,7 @@ dist_tmux_SOURCES = \
 	cmd-detach-client.c \
 	cmd-display-menu.c \
 	cmd-display-message.c \
+	cmd-display-panes.c \
 	cmd-find-window.c \
 	cmd-find.c \
 	cmd-if-shell.c \
@@ -111,7 +87,6 @@ dist_tmux_SOURCES = \
 	cmd-kill-window.c \
 	cmd-list-buffers.c \
 	cmd-list-clients.c \
-	cmd-list-commands.c \
 	cmd-list-keys.c \
 	cmd-list-panes.c \
 	cmd-list-sessions.c \
@@ -139,14 +114,12 @@ dist_tmux_SOURCES = \
 	cmd-select-pane.c \
 	cmd-select-window.c \
 	cmd-send-keys.c \
-	cmd-server-access.c \
 	cmd-set-buffer.c \
 	cmd-set-environment.c \
 	cmd-set-option.c \
 	cmd-show-environment.c \
 	cmd-show-messages.c \
 	cmd-show-options.c \
-	cmd-show-prompt-history.c \
 	cmd-source-file.c \
 	cmd-split-window.c \
 	cmd-swap-pane.c \
@@ -160,21 +133,14 @@ dist_tmux_SOURCES = \
 	control-notify.c \
 	control.c \
 	environ.c \
-	events-payload.c \
-	events.c \
 	file.c \
-	format-draw.c \
 	format.c \
-	fuzzy.c \
-	grid-reader.c \
+	format-draw.c \
 	grid-view.c \
 	grid.c \
-	hooks.c \
-	hyperlinks.c \
 	input-keys.c \
 	input.c \
 	job.c \
-	json.c \
 	key-bindings.c \
 	key-string.c \
 	layout-custom.c \
@@ -183,53 +149,40 @@ dist_tmux_SOURCES = \
 	log.c \
 	menu.c \
 	mode-tree.c \
-	monitor.c \
 	names.c \
+	notify.c \
 	options-table.c \
 	options.c \
 	paste.c \
-	popup.c \
 	proc.c \
-	prompt-history.c \
-	prompt.c \
 	regsub.c \
 	resize.c \
 	screen-redraw.c \
 	screen-write.c \
 	screen.c \
-	server-acl.c \
 	server-client.c \
 	server-fn.c \
 	server.c \
 	session.c \
-	sort.c \
 	spawn.c \
 	status.c \
 	style.c \
-	tmux-protocol.h \
 	tmux.c \
 	tmux.h \
 	tty-acs.c \
-	tty-draw.c \
-	tty-features.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
-	utf8-combined.c \
 	utf8.c \
-	window-border.c \
 	window-buffer.c \
 	window-client.c \
 	window-clock.c \
 	window-copy.c \
-	window-customize.c \
-	window-panes.c \
-	window-switch.c \
 	window-tree.c \
-	window-visible.c \
 	window.c \
 	xmalloc.c \
-	xmalloc.h
+	xmalloc.h \
+	xterm-keys.c
 nodist_tmux_SOURCES = osdep-@PLATFORM@.c

 # Add compat file for forkpty.
@@ -237,38 +190,11 @@ if NEED_FORKPTY
 nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
 endif

-# Add compat file for systemd.
-if HAVE_SYSTEMD
-nodist_tmux_SOURCES += compat/systemd.c
-endif
-
 # Add compat file for utf8proc.
 if HAVE_UTF8PROC
 nodist_tmux_SOURCES += compat/utf8proc.c
 endif

-# Enable sixel support.
-if ENABLE_SIXEL
-dist_tmux_SOURCES += image.c image-sixel.c
-endif
-
-# Add bits for fuzzing if enabled.
-if NEED_FUZZING
-check_PROGRAMS = \
-	fuzz/input-fuzzer \
-	fuzz/cmd-parse-fuzzer \
-	fuzz/format-fuzzer \
-	fuzz/style-fuzzer
-fuzz_input_fuzzer_LDFLAGS = $(FUZZING_LIBS)
-fuzz_input_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
-fuzz_cmd_parse_fuzzer_LDFLAGS = $(FUZZING_LIBS)
-fuzz_cmd_parse_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
-fuzz_format_fuzzer_LDFLAGS = $(FUZZING_LIBS)
-fuzz_format_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
-fuzz_style_fuzzer_LDFLAGS = $(FUZZING_LIBS)
-fuzz_style_fuzzer_LDADD = $(LDADD) $(tmux_OBJECTS)
-endif
-
 # Install tmux.1 in the right format.
 install-exec-hook:
 	if test x@MANFORMAT@ = xmdoc; then \
@@ -281,7 +207,3 @@ install-exec-hook:
 	$(mkdir_p) $(DESTDIR)$(mandir)/man1
 	$(INSTALL_DATA) $(srcdir)/tmux.1.@MANFORMAT@ \
 		$(DESTDIR)$(mandir)/man1/tmux.1
-
-# And uninstall it.
-uninstall-hook:
-	rm -f $(DESTDIR)$(mandir)/man1/tmux.1
--- a/16
+++ b/16
@@ -4,7 +4,7 @@ tmux is a terminal multiplexer: it enables a number of terminals to be created,
 accessed, and controlled from a single screen. tmux may be detached from a
 screen and continue running in the background, then later reattached.

-This release runs on OpenBSD, FreeBSD, NetBSD, Linux, macOS and Solaris.
+This release runs on OpenBSD, FreeBSD, NetBSD, Linux, OS X and Solaris.

 * Dependencies

@@ -16,9 +16,6 @@ It also depends on ncurses, available from:

 	https://invisible-mirror.net/archives/ncurses/

-To build tmux, a C compiler (for example gcc or clang), make, pkg-config and a
-suitable yacc (yacc or bison) are needed.
-
 * Installation

 To build and install tmux from a release tarball, use:
@@ -36,7 +33,6 @@ autoconf, automake and pkg-config:
 	$ cd tmux
 	$ sh autogen.sh
 	$ ./configure && make
-	$ sudo make install

 * Contributing

@@ -56,17 +52,9 @@ source tree with:

 A small example configuration is in example_tmux.conf.

-Other documentation is available in the wiki:
-
-	https://github.com/tmux/tmux/wiki
-
-Also see the tmux FAQ at:
-
-	https://github.com/tmux/tmux/wiki/FAQ
-
 A bash(1) completion file is at:

-	https://github.com/scop/bash-completion/blob/main/completions/tmux
+	https://github.com/imomaliev/tmux-bash-completion

 For debugging, run tmux with -v and -vv to generate server and client log files
 in the current directory.
--- a/README.ja
+++ b/README.ja
@@ -0,0 +1,62 @@
+tmuxへようこそ!
+
+tmuxはターミナルマルチプレクサーです。複数のターミナルを一つのスクリーン内に作成し、操作することができます。
+バックグラウンドで処理を実行中に一度スクリーンから離れて後から復帰することも可能です。
+
+OpenBSD、FreeBSD、NetBSD、Linux、OS X、Solarisで実行できます。
+
+tmuxはlibevent 2.x.に依存します。 下記からダウンロードしてください。
+
+	http://libevent.org
+
+また、ncursesも必要です。こちらからどうぞ。
+
+	http://invisible-island.net/ncurses/
+
+tarballでのtmuxのビルドとインストール方法。
+
+	$ ./configure && make
+	$ sudo make install
+
+tmuxはutmp(5)をアップデートするためにutempterを使うことができます。もしインストール済みであればオプション「--enable-utempter」をつけて実行してください。
+
+リポジトリから最新バージョンを手に入れるためには下記を実行。
+
+	$ git clone https://github.com/tmux/tmux.git
+	$ cd tmux
+	$ sh autogen.sh
+	$ ./configure && make
+
+(ビルドのためにはlibevent、ncurses libraries、headersに加えて、C compiler、make、autoconf、automake、pkg-configが必要です。)
+
+詳しい情報はhttp://git-scm.comをご覧ください。修正はメール<tmux-users@googlegroups.com>宛、もしくはhttps://github.com/tmux/tmux/issuesにて受け付けています。
+
+tmuxのドキュメントについてはtmux.1マニュアルをご覧ください。こちらのコマンドで参照可能です。
+
+	$ nroff -mdoc tmux.1|less
+
+サンプル設定は本リポジトリのexample_tmux.confに
+また、bash-completionファイルは下記にあります。
+
+	https://github.com/imomaliev/tmux-bash-completion
+
+「-v」や「-vv」を指定することでデバッグモードでの起動が可能です。カレントディレクトリにサーバーやクライアントのログファイルが生成されます。
+
+議論やバグレポート用のメーリングリストにはこちらから参加可能です。
+
+	https://groups.google.com/forum/#!forum/tmux-users
+
+gitコミットについての連絡先
+
+	https://groups.google.com/forum/#!forum/tmux-git
+
+購読は<tmux-users+subscribe@googlegroups.com>までメールをお願いします。
+
+バグレポートや機能追加(特にコードへの貢献)は大歓迎です。こちらにご連絡ください。
+
+	tmux-users@googlegroups.com
+
+本ファイル、CHANGES、 FAQ、SYNCINGそしてTODOはISC licenseで保護されています。
+その他のファイルのライセンスや著作権については、ファイルの上部に明記されています。
+
+-- Nicholas Marriott <nicholas.marriott@gmail.com>
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1 +0,0 @@
-Please report security issues to nicholas.marriott@gmail.com.
--- a/173
+++ b/173
@@ -0,0 +1,173 @@
+Preamble
+========
+
+Tmux portable relies on  repositories "tmux" and "tmux-openbsd".
+Here's a description of them:
+
+* "tmux" is the portable version, the one which contains code for other
+  operating systems, and autotools, etc., which isn't found or needed in the
+  OpenBSD base system.
+
+* "tmux-openbsd" is the version of tmux in OpenBSD base system which provides
+  the basis of the portable tmux version.
+
+Note:  The "tmux-openbsd" repository is actually handled by "git cvsimport"
+running at 15 minute intervals, so a commit made to OpenBSD's tmux CVS
+repository will take at least that long to appear in this git repository.
+(It might take longer, depending on the CVS mirror used to import the
+OpenBSD code).
+
+If you've never used git before, git tracks meta-data about the committer
+and the author, as part of a commit, hence:
+
+% git config [--global] user.name "Your name"
+% git config [--global] user.email "you@yourdomain.com"
+
+Note that, if you already have this in the global ~/.gitconfig option, then
+this will be used.  Setting this per-repository would involve not using the
+"--global" flag above.   If you wish to use the same credentials always,
+pass the "--global" option, as shown.
+
+This is a one-off operation once the repository has been cloned, assuming
+this information has ever been set before.
+
+Cloning repositories
+====================
+
+This involves having both tmux and tmux-openbsd cloned, as in:
+
+% cd /some/where/useful
+% git clone https://github.com/tmux/tmux.git
+% git clone https://github.com/ThomasAdam/tmux-openbsd.git
+
+Note that you do not need additional checkouts to manage the sync -- an
+existing clone of either repositories will suffice.  So if you already have
+these checkouts existing, skip that.
+
+Adding in git-remotes
+=====================
+
+Because the portable "tmux" git repository and the "tmux-openbsd"
+repository do not inherently share any history between each other, the
+history has been faked between them.  This "faking of history" is something
+which has to be told to git for the purposes of comparing the "tmux" and
+"tmux-openbsd" repositories for syncing.  To do this, we must reference the
+clone of the "tmux-openbsd" repository from the "tmux" repository, as
+shown by the following command:
+
+% cd /path/to/tmux
+% git remote add obsd-tmux file:///path/to/tmux-openbsd
+
+So that now, the remote "obsd-tmux" can be used to reference branches and
+commits from the "tmux-openbsd" repository, but from the context of the
+portable "tmux" repository, which makes sense because it's the "tmux"
+repository which will have the updates applied to them.
+
+Fetching updates
+================
+
+To ensure the latest commits from "tmux-openbsd" can be found from within
+"tmux", we have to ensure the "master" branch from "tmux-openbsd" is
+up-to-date first, and then reference that update in "tmux", as in:
+
+% cd /path/to/tmux-openbsd
+% git checkout master
+% git pull
+
+Then back in "tmux":
+
+% cd /path/to/tmux
+% git fetch obsd-tmux
+
+Creating the necessary branches
+===============================
+
+Now that "tmux" can see commits and branches from "tmux-openbsd" by way
+of the remote name "obsd-tmux", we can now create the master branch from
+"tmux-openbsd" in the "tmux" repository:
+
+% git checkout -b obsd-master obsd-tmux/master
+
+Adding in the fake history points
+================================= 
+
+To tie both the "master" branch from "tmux" and the "obsd-master"
+branch from "tmux-openbsd" together, the fake history points added to the
+"tmux" repository need to be added.  To do this, we must add an
+additional refspec line, as in:
+
+% cd /path/to/tmux
+% git config --add remote.origin.fetch '+refs/replace/*:refs/replace/*'
+% git fetch origin
+
+Performing the Sync
+===================
+
+Make sure the "master" branch is checked out:
+
+% git checkout master
+
+The following will show commits on OpenBSD not yet synched with "tmux":
+
+% git log master..obsd-master
+
+From there, merge the result in, fixing up any conflicts which might arise.
+
+% git merge obsd-master
+
+Then ensure things look correct by BUILDING the result of that sync:
+
+% make clean && ./autogen.sh && ./configure && make
+
+Compare the git merge result with what's on origin/master -- that is, check
+which commits you're about to push:
+
+% git log origin/master..master
+
+And if happy:
+
+% git push origin master
+
+Keeping an eye on libutil in OpenBSD
+====================================
+
+A lot of the compat/ code in tmux comes from libutil, especially imsg.
+Sometimes the API can change, etc., which might cause interesting problems
+trying to run the portable version of tmux.  It's worth checking
+periodically for any changes to libutil in OpenBSD and syncing those files
+to compat/ as and when appropriate.
+
+Release tmux for next version
+=============================
+
+1. Update and commit README and CHANGES.  The former should be checked for
+   anything outdated and updated with a list of things that might break
+   upgrades and the latter should mention all the major changes since
+   the last version.
+
+2. Make sure configure.ac has the new version number.
+
+3. Tag with:
+
+   % git tag -a 2.X
+
+   Where "2.X" is the next version.
+
+   Push the tag out with:
+
+   % git push --tags
+
+4. Build the tarball with 'make dist'.
+
+5. Check the tarball.  If it's good, go here to select the tag just pushed:
+
+   https://github.com/tmux/tmux/tags
+
+   Click the "Add release notes", upload the tarball and add a link in the
+   description field to the CHANGES file.
+
+6. Clone the tmux.github.io repository, and change the RELEASE version in the
+   Makefile.  Commit it, and run 'make' to replace %%RELEASE%%.  Push the
+   result out.
+
+7. Change version back to master in configure.ac.
--- a/SYNCING.md
+++ b/SYNCING.md
@@ -1,234 +0,0 @@
-# Preamble
-
-tmux portable is maintained from two repositories:
-
-* `tmux` is the portable repository. It contains the portability layer,
-  autotools build files, regression tests, documentation, and code needed for
-  platforms outside OpenBSD.
-* `tmux-openbsd-cutover` is the OpenBSD tmux import repository. Its `master`
-  branch is the OpenBSD tmux history after the OpenBSD Git cutover. Portable
-  merges this branch when importing OpenBSD changes.
-
-To create the commits in the tmux-openbsd-cutover repo, the source repo is the
-Github mirror of OpenBSD's src repo:
-
-```text
-https://github.com/openbsd/src.git
-```
-
-The update automation filters the OpenBSD source tree to `usr.bin/tmux/`,
-publishes that filtered history as `openbsd-git` in the cutover repository,
-cherry-picks new filtered commits onto cutover `master`, then merges cutover
-`master` into portable `master`.
-
-If you've never used git before, configure your identity before committing:
-
-```sh
-git config [--global] user.name "Your name"
-git config [--global] user.email "you@yourdomain.com"
-```
-
-# Repository layout
-
-The usual local layout is:
-
-```sh
-cd /some/where/useful
-git clone https://github.com/tmux/tmux.git tmux-portable
-git clone https://github.com/ThomasAdam/tmux-obsd.git tmux-openbsd-cutover
-```
-
-The exact directory names do not matter, but the examples below use:
-
-```text
-/path/to/tmux-portable
-/path/to/tmux-openbsd-cutover
-```
-
-The cutover repository has three important branches:
-
-* `master` is the branch portable consumes. It should contain tmux source
-  only, not automation files.
-* `openbsd-git` is the raw filtered OpenBSD tmux branch generated from
-  OpenBSD src `master`.
-* `automation` is an orphan branch containing the GitHub Actions workflow. It
-  is separate so that workflow files are not merged into portable.
-
-# Adding the OpenBSD remote to portable
-
-In the portable repository, add the cutover repository as a remote:
-
-```sh
-cd /path/to/tmux-portable
-git remote add tmux-openbsd /path/to/tmux-openbsd-cutover
-git config remote.tmux-openbsd.tagOpt --no-tags
-```
-
-If the remote already exists, update it instead:
-
-```sh
-git remote set-url tmux-openbsd /path/to/tmux-openbsd-cutover
-git config remote.tmux-openbsd.tagOpt --no-tags
-```
-
-Fetch the cutover master branch explicitly:
-
-```sh
-git fetch --no-tags tmux-openbsd master:refs/remotes/tmux-openbsd/master
-```
-
-# Automated syncing
-
-The normal sync is performed by the GitHub Actions workflow in the
-`automation` branch of the cutover repository. That workflow:
-
-1. Fetches or clones OpenBSD src using a blobless clone.
-2. Filters `usr.bin/tmux/` into a local `tmux-openbsd` branch.
-3. Updates `tmux-openbsd-cutover/openbsd-git`.
-4. Cherry-picks new `openbsd-git` commits onto cutover `master`.
-5. Merges cutover `master` into portable `master`.
-6. Pushes the changed repositories.
-
-The workflow deliberately runs from the orphan `automation` branch but checks
-out cutover `master` as the branch to update. This keeps `.github/` out of
-cutover `master`, so portable does not import workflow files when it merges
-OpenBSD changes.
-
-# Manual portable merge
-
-If the workflow fails while merging into portable, do the merge locally and
-push the result.
-
-Start from an up-to-date portable master:
-
-```sh
-cd /path/to/tmux-portable
-git fetch origin
-git checkout master
-git pull --ff-only origin master
-```
-
-Fetch the cutover branch:
-
-```sh
-git remote add tmux-openbsd /path/to/tmux-openbsd-cutover 2>/dev/null || true
-git config remote.tmux-openbsd.tagOpt --no-tags
-git fetch --no-tags tmux-openbsd master:refs/remotes/tmux-openbsd/master
-```
-
-Merge it:
-
-```sh
-git merge --no-ff --log refs/remotes/tmux-openbsd/master
-```
-
-Resolve conflicts by deciding whether portable or OpenBSD owns the file.
-
-Useful commands:
-
-```sh
-git checkout --ours path/to/file
-git add path/to/file
-```
-
-This keeps the portable version of a conflicted file.
-
-```sh
-git checkout --theirs path/to/file
-git add path/to/file
-```
-
-This takes the OpenBSD/cutover version of a conflicted file.
-
-Before committing, inspect the result:
-
-```sh
-git status
-git diff --check
-git diff --cached --stat
-```
-
-Then finish and publish:
-
-```sh
-git commit
-git push origin master
-```
-
-If the merge attempt is wrong, abort it:
-
-```sh
-git merge --abort
-```
-
-After pushing a manually resolved merge, rerun the workflow. It should either
-no-op or continue from the now-merged portable state.
-
-# Manual cutover update
-
-Normally this is handled by the workflow. If it must be done manually, update
-`openbsd-git` in the cutover repository from a filtered OpenBSD src checkout,
-then cherry-pick the new filtered commits onto cutover `master`.
-
-The important range is:
-
-```text
-origin/openbsd-git..openbsd-git
-```
-
-where `origin/openbsd-git` is the previously published filtered OpenBSD tmux
-branch and `openbsd-git` is the newly generated filtered branch.
-
-In the cutover repository:
-
-```sh
-cd /path/to/tmux-openbsd-cutover
-git checkout master
-git cherry-pick origin/openbsd-git..openbsd-git
-git push origin master openbsd-git
-```
-
-Do not put workflow files on cutover `master`; keep them on the orphan
-`automation` branch.
-
-# Keeping an eye on libutil in OpenBSD
-
-A lot of the `compat/` code in tmux comes from OpenBSD libraries, especially
-imsg. Sometimes APIs change in OpenBSD in ways that require corresponding
-portable changes. It is worth checking periodically for relevant OpenBSD
-libutil changes and syncing those files into `compat/` as appropriate.
-
-# Release tmux for next version
-
-1. Update and commit README and CHANGES. The former should be checked for
-   anything outdated and updated with a list of things that might break
-   upgrades and the latter should mention all the major changes since the last
-   version.
-2. Make sure `configure.ac` has the new version number.
-3. Tag with:
-
-   ```sh
-   % git tag -a 2.X
-   ```
-
-   Where `2.X` is the next version.
-
-   Push the tag out with:
-
-   ```sh
-   % git push --tags
-   ```
-
-4. Build the tarball with `make dist`.
-5. Check the tarball. If it is good, go here to select the tag just pushed:
-
-   ```text
-   https://github.com/tmux/tmux/tags
-   ```
-
-   Click "Add release notes", upload the tarball and add a link in the
-   description field to the CHANGES file.
-6. Clone the tmux.github.io repository, and change the RELEASE version in the
-   Makefile. Commit it, and run `make` to replace `%%RELEASE%%`. Push the
-   result out.
-7. Change version back to master in `configure.ac`.
--- a/alerts.c
+++ b/alerts.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: alerts.c,v 1.35 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2015 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,6 +18,7 @@

 #include <sys/types.h>

+#include <event.h>
 #include <stdlib.h>

 #include "tmux.h"
@@ -199,13 +200,13 @@ alerts_check_bell(struct window *w)
 		 * not check WINLINK_BELL).
 		 */
 		s = wl->session;
-		if (s->curw != wl || s->attached == 0) {
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_BELL;
 			server_status_session(s);
 		}
 		if (!alerts_action_applies(wl, "bell-action"))
 			continue;
-		events_fire_winlink("alert-bell", wl);
+		notify_winlink("alert-bell", wl);

 		if (s->flags & SESSION_ALERTED)
 			continue;
@@ -235,13 +236,13 @@ alerts_check_activity(struct window *w)
 		if (wl->flags & WINLINK_ACTIVITY)
 			continue;
 		s = wl->session;
-		if (s->curw != wl || s->attached == 0) {
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_ACTIVITY;
 			server_status_session(s);
 		}
 		if (!alerts_action_applies(wl, "activity-action"))
 			continue;
-		events_fire_winlink("alert-activity", wl);
+		notify_winlink("alert-activity", wl);

 		if (s->flags & SESSION_ALERTED)
 			continue;
@@ -271,13 +272,13 @@ alerts_check_silence(struct window *w)
 		if (wl->flags & WINLINK_SILENCE)
 			continue;
 		s = wl->session;
-		if (s->curw != wl || s->attached == 0) {
+		if (s->curw != wl) {
 			wl->flags |= WINLINK_SILENCE;
 			server_status_session(s);
 		}
 		if (!alerts_action_applies(wl, "silence-action"))
 			continue;
-		events_fire_winlink("alert-silence", wl);
+		notify_winlink("alert-silence", wl);

 		if (s->flags & SESSION_ALERTED)
 			continue;
@@ -314,12 +315,9 @@ alerts_set_message(struct winlink *wl, const char *type, const char *option)
 			tty_putcode(&c->tty, TTYC_BEL);
 		if (visual == VISUAL_OFF)
 			continue;
-		if (c->session->curw == wl) {
-			status_message_set(c, -1, 1, 0, 0,
-			    "%s in current window", type);
-		} else {
-			status_message_set(c, -1, 1, 0, 0,
-			    "%s in window %d", type, wl->idx);
-		}
+		if (c->session->curw == wl)
+			status_message_set(c, "%s in current window", type);
+		else
+			status_message_set(c, "%s in window %d", type, wl->idx);
 	}
 }
--- a/arguments.c
+++ b/arguments.c
--- a/attributes.c
+++ b/attributes.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: attributes.c,v 1.13 2026/07/02 08:51:05 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Joshua Elsasser <josh@elsasser.org>
@@ -31,8 +31,7 @@ attributes_tostring(int attr)
 	if (attr == 0)
 		return ("none");

-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
-	    (attr & GRID_ATTR_CHARSET) ? "acs," : "",
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
 	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
 	    (attr & GRID_ATTR_DIM) ? "dim," : "",
 	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
@@ -45,8 +44,7 @@ attributes_tostring(int attr)
 	    (attr & GRID_ATTR_UNDERSCORE_3) ? "curly-underscore," : "",
 	    (attr & GRID_ATTR_UNDERSCORE_4) ? "dotted-underscore," : "",
 	    (attr & GRID_ATTR_UNDERSCORE_5) ? "dashed-underscore," : "",
-	    (attr & GRID_ATTR_OVERLINE) ? "overline," : "",
-	    (attr & GRID_ATTR_NOATTR) ? "noattr," : "");
+	    (attr & GRID_ATTR_OVERLINE) ? "overline," : "");
 	if (len > 0)
 		buf[len - 1] = '\0';

@@ -64,7 +62,6 @@ attributes_fromstring(const char *str)
 		const char	*name;
 		int		 attr;
 	} table[] = {
-		{ "acs", GRID_ATTR_CHARSET },
 		{ "bright", GRID_ATTR_BRIGHT },
 		{ "bold", GRID_ATTR_BRIGHT },
 		{ "dim", GRID_ATTR_DIM },
--- a/cfg.c
+++ b/cfg.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cfg.c,v 1.91 2026/08/03 13:38:42 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,15 +27,12 @@
 #include "tmux.h"

 struct client		 *cfg_client;
+static char		 *cfg_file;
 int			  cfg_finished;
 static char		**cfg_causes;
 static u_int		  cfg_ncauses;
 static struct cmdq_item	 *cfg_item;

-int                       cfg_quiet = 1;
-char                    **cfg_files;
-u_int                     cfg_nfiles;
-
 static enum cmd_retval
 cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
 {
@@ -51,22 +48,63 @@ cfg_done(__unused struct cmdq_item *item, __unused void *data)
 		return (CMD_RETURN_NORMAL);
 	cfg_finished = 1;

-	cfg_show_causes(NULL);
+	if (!RB_EMPTY(&sessions))
+		cfg_show_causes(RB_MIN(sessions, &sessions));

 	if (cfg_item != NULL)
 		cmdq_continue(cfg_item);

-	prompt_load_history();
+	status_prompt_load_history();

 	return (CMD_RETURN_NORMAL);
 }

+void
+set_cfg_file(const char *path)
+{
+	free(cfg_file);
+	cfg_file = xstrdup(path);
+}
+
+static char *
+expand_cfg_file(const char *path, const char *home)
+{
+	char			*expanded, *name;
+	const char		*end;
+	struct environ_entry	*value;
+
+	if (strncmp(path, "~/", 2) == 0) {
+		if (home == NULL)
+			return (NULL);
+		xasprintf(&expanded, "%s%s", home, path + 1);
+		return (expanded);
+	}
+
+	if (*path == '$') {
+		end = strchr(path, '/');
+		if (end == NULL)
+			name = xstrdup(path + 1);
+		else
+			name = xstrndup(path + 1, end - path - 1);
+		value = environ_find(global_environ, name);
+		free(name);
+		if (value == NULL)
+			return (NULL);
+		if (end == NULL)
+			end = "";
+		xasprintf(&expanded, "%s%s", value->value, end);
+		return (expanded);
+	}
+
+	return (xstrdup(path));
+}
+
 void
 start_cfg(void)
 {
-	struct client	 *c;
-	u_int		  i;
-	int		  flags = 0;
+	const char	*home = find_home();
+	struct client	*c;
+	char		*path, *copy, *next, *expanded;

 	/*
 	 * Configuration files are loaded without a client, so commands are run
@@ -84,23 +122,33 @@ start_cfg(void)
 		cmdq_append(c, cfg_item);
 	}

-	if (cfg_quiet)
-		flags = CMD_PARSE_QUIET;
-	for (i = 0; i < cfg_nfiles; i++)
-		load_cfg(cfg_files[i], c, NULL, NULL, flags, NULL);
+	if (cfg_file == NULL) {
+		path = copy = xstrdup(TMUX_CONF);
+		while ((next = strsep(&path, ":")) != NULL) {
+			expanded = expand_cfg_file(next, home);
+			if (expanded == NULL) {
+				log_debug("couldn't expand %s", next);
+				continue;
+			}
+			log_debug("expanded %s to %s", next, expanded);
+			load_cfg(expanded, c, NULL, CMD_PARSE_QUIET, NULL);
+			free(expanded);
+		}
+		free(copy);
+	} else
+		load_cfg(cfg_file, c, NULL, 0, NULL);

 	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }

 int
-load_cfg(const char *path, struct client *c, struct cmdq_item *item,
-    struct cmd_find_state *current, int flags, struct cmdq_item **new_item)
+load_cfg(const char *path, struct client *c, struct cmdq_item *item, int flags,
+    struct cmdq_item **new_item)
 {
 	FILE			*f;
 	struct cmd_parse_input	 pi;
 	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
-	struct cmdq_state	*state;

 	if (new_item != NULL)
 		*new_item = NULL;
@@ -122,6 +170,8 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item,

 	pr = cmd_parse_from_file(f, &pi);
 	fclose(f);
+	if (pr->status == CMD_PARSE_EMPTY)
+		return (0);
 	if (pr->status == CMD_PARSE_ERROR) {
 		cfg_add_cause("%s", pr->error);
 		free(pr->error);
@@ -132,19 +182,12 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item,
 		return (0);
 	}

-	if (item != NULL)
-		state = cmdq_copy_state(cmdq_get_state(item), current);
-	else
-		state = cmdq_new_state(NULL, NULL, 0);
-	cmdq_add_format(state, "current_file", "%s", pi.file);
-
-	new_item0 = cmdq_get_command(pr->cmdlist, state);
+	new_item0 = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
 	cmd_list_free(pr->cmdlist);
-	cmdq_free_state(state);

 	if (new_item != NULL)
 		*new_item = new_item0;
@@ -153,13 +196,12 @@ load_cfg(const char *path, struct client *c, struct cmdq_item *item,

 int
 load_cfg_from_buffer(const void *buf, size_t len, const char *path,
-    struct client *c, struct cmdq_item *item, struct cmd_find_state *current,
-    int flags, struct cmdq_item **new_item)
+    struct client *c, struct cmdq_item *item, int flags,
+    struct cmdq_item **new_item)
 {
 	struct cmd_parse_input	 pi;
 	struct cmd_parse_result	*pr;
 	struct cmdq_item	*new_item0;
-	struct cmdq_state	*state;

 	if (new_item != NULL)
 		*new_item = NULL;
@@ -174,6 +216,8 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 	pi.c = c;

 	pr = cmd_parse_from_buffer(buf, len, &pi);
+	if (pr->status == CMD_PARSE_EMPTY)
+		return (0);
 	if (pr->status == CMD_PARSE_ERROR) {
 		cfg_add_cause("%s", pr->error);
 		free(pr->error);
@@ -184,19 +228,12 @@ load_cfg_from_buffer(const void *buf, size_t len, const char *path,
 		return (0);
 	}

-	if (item != NULL)
-		state = cmdq_copy_state(cmdq_get_state(item), current);
-	else
-		state = cmdq_new_state(NULL, NULL, 0);
-	cmdq_add_format(state, "current_file", "%s", pi.file);
-
-	new_item0 = cmdq_get_command(pr->cmdlist, state);
+	new_item0 = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
 	if (item != NULL)
 		new_item0 = cmdq_insert_after(item, new_item0);
 	else
 		new_item0 = cmdq_append(NULL, new_item0);
 	cmd_list_free(pr->cmdlist);
-	cmdq_free_state(state);

 	if (new_item != NULL)
 		*new_item = new_item0;
@@ -221,17 +258,11 @@ cfg_add_cause(const char *fmt, ...)
 void
 cfg_print_causes(struct cmdq_item *item)
 {
-	struct client	*c = cmdq_get_client(item);
-	u_int		 i;
-	char		*cause;
+	u_int	 i;

 	for (i = 0; i < cfg_ncauses; i++) {
-		cause = cfg_causes[i];
-		if (c != NULL && (c->flags & CLIENT_CONTROL))
-			control_notify_write(c, "%%config-error %s", cause);
-		else
-			cmdq_print(item, "%s", cause);
-		free(cause);
+		cmdq_print(item, "%s", cfg_causes[i]);
+		free(cfg_causes[i]);
 	}

 	free(cfg_causes);
@@ -242,44 +273,22 @@ cfg_print_causes(struct cmdq_item *item)
 void
 cfg_show_causes(struct session *s)
 {
-	struct client			*c = TAILQ_FIRST(&clients);
 	struct window_pane		*wp;
 	struct window_mode_entry	*wme;
 	u_int				 i;
-	char				*cause;

-	if (cfg_ncauses == 0)
-		return;
-
-	if (c != NULL && (c->flags & CLIENT_CONTROL)) {
-		for (i = 0; i < cfg_ncauses; i++) {
-			cause = cfg_causes[i];
-			control_notify_write(c, "%%config-error %s", cause);
-			free(cause);
-		}
-		goto out;
-	}
-
-	if (s == NULL) {
-		if (c != NULL && c->session != NULL)
-			s = c->session;
-		else
-			s = RB_MIN(sessions, &sessions);
-	}
-	if (s == NULL || s->attached == 0) /* wait for an attached session */
+	if (s == NULL || cfg_ncauses == 0)
 		return;
 	wp = s->curw->window->active;

 	wme = TAILQ_FIRST(&wp->modes);
 	if (wme == NULL || wme->mode != &window_view_mode)
-		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL,
-		    NULL);
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
 	for (i = 0; i < cfg_ncauses; i++) {
-		window_copy_add(wp, 0, "%s", cfg_causes[i]);
+		window_copy_add(wp, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);
 	}

-out:
 	free(cfg_causes);
 	cfg_causes = NULL;
 	cfg_ncauses = 0;
--- a/client.c
+++ b/client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: client.c,v 1.168 2026/08/17 20:14:31 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,12 +18,12 @@

 #include <sys/types.h>
 #include <sys/socket.h>
-#include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <sys/file.h>

 #include <errno.h>
+#include <event.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
@@ -34,8 +34,7 @@

 static struct tmuxproc	*client_proc;
 static struct tmuxpeer	*client_peer;
-static uint64_t		 client_flags;
-static int		 client_suspended;
+static int		 client_flags;
 static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
@@ -45,13 +44,11 @@ static enum {
 	CLIENT_EXIT_LOST_SERVER,
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
-	CLIENT_EXIT_MESSAGE_PROVIDED
 } client_exitreason = CLIENT_EXIT_NONE;
 static int		 client_exitflag;
 static int		 client_exitval;
 static enum msgtype	 client_exittype;
 static const char	*client_exitsession;
-static char		*client_exitmessage;
 static const char	*client_execshell;
 static const char	*client_execcmd;
 static int		 client_attached;
@@ -59,10 +56,8 @@ static struct client_files client_files = RB_INITIALIZER(&client_files);

 static __dead void	 client_exec(const char *,const char *);
 static int		 client_get_lock(char *);
-static int		 client_connect(struct event_base *, const char *,
-			     uint64_t);
-static void		 client_send_identify(const char *, const char *,
-			     char **, u_int, const char *, int);
+static int		 client_connect(struct event_base *, const char *, int);
+static void		 client_send_identify(const char *, const char *);
 static void		 client_signal(int);
 static void		 client_dispatch(struct imsg *, void *);
 static void		 client_dispatch_attached(struct imsg *);
@@ -102,7 +97,7 @@ client_get_lock(char *lockfile)

 /* Connect client to server. */
 static int
-client_connect(struct event_base *base, const char *path, uint64_t flags)
+client_connect(struct event_base *base, const char *path, int start_server)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
@@ -127,9 +122,7 @@ retry:
 		log_debug("connect failed: %s", strerror(errno));
 		if (errno != ECONNREFUSED && errno != ENOENT)
 			goto failed;
-		if (flags & CLIENT_NOSTARTSERVER)
-			goto failed;
-		if (~flags & CLIENT_STARTSERVER)
+		if (!start_server)
 			goto failed;
 		close(fd);

@@ -161,7 +154,7 @@ retry:
 			close(lockfd);
 			return (-1);
 		}
-		fd = server_start(client_proc, flags, base, lockfd, lockfile);
+		fd = server_start(client_proc, base, lockfd, lockfile);
 	}

 	if (locked && lockfd >= 0) {
@@ -213,8 +206,6 @@ client_exit_message(void)
 		return ("exited");
 	case CLIENT_EXIT_SERVER_EXITED:
 		return ("server exited");
-	case CLIENT_EXIT_MESSAGE_PROVIDED:
-		return (client_exitmessage);
 	}
 	return ("unknown reason");
 }
@@ -223,70 +214,76 @@ client_exit_message(void)
 static void
 client_exit(void)
 {
-	if (!file_write_left(&client_files))
+	struct client_file	*cf;
+	size_t 			 left;
+	int			 waiting = 0;
+
+	RB_FOREACH (cf, client_files, &client_files) {
+		if (cf->event == NULL)
+			continue;
+		left = EVBUFFER_LENGTH(cf->event->output);
+		if (left != 0) {
+			waiting++;
+			log_debug("file %u %zu bytes left", cf->stream, left);
+		}
+	}
+	if (waiting == 0)
 		proc_exit(client_proc);
 }

 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
-    int feat)
+client_main(struct event_base *base, int argc, char **argv, int flags)
 {
 	struct cmd_parse_result	*pr;
+	struct cmd		*cmd;
 	struct msg_command	*data;
-	int			 fd, i;
-	const char		*ttynam, *termname, *cwd;
+	int			 cmdflags, fd, i;
+	const char		*ttynam, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
 	struct termios		 tio, saved_tio;
 	size_t			 size;
-	char			**caps = NULL, *cause;
-	u_int			 ncaps = 0;
-	struct args_value	*values;
+
+	/* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
+	signal(SIGCHLD, SIG_IGN);
+
+	/* Save the flags. */
+	client_flags = flags;

 	/* Set up the initial command. */
+	cmdflags = 0;
 	if (shell_command != NULL) {
 		msg = MSG_SHELL;
-		flags |= CLIENT_STARTSERVER;
+		cmdflags = CMD_STARTSERVER;
 	} else if (argc == 0) {
 		msg = MSG_COMMAND;
-		flags |= CLIENT_STARTSERVER;
+		cmdflags = CMD_STARTSERVER;
 	} else {
 		msg = MSG_COMMAND;

 		/*
-		 * It's annoying parsing the command string twice (in client
-		 * and later in server) but it is necessary to get the start
-		 * server flag.
+		 * It sucks parsing the command string twice (in client and
+		 * later in server) but it is necessary to get the start server
+		 * flag.
 		 */
-		values = args_from_vector(argc, argv);
-		pr = cmd_parse_from_arguments(values, argc, NULL);
+		pr = cmd_parse_from_arguments(argc, argv, NULL);
 		if (pr->status == CMD_PARSE_SUCCESS) {
-			if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
-				flags |= CLIENT_STARTSERVER;
+			TAILQ_FOREACH(cmd, &pr->cmdlist->list, qentry) {
+				if (cmd->entry->flags & CMD_STARTSERVER)
+					cmdflags |= CMD_STARTSERVER;
+			}
 			cmd_list_free(pr->cmdlist);
 		} else
 			free(pr->error);
-		args_free_values(values, argc);
-		free(values);
 	}

 	/* Create client process structure (starts logging). */
 	client_proc = proc_start("client");
 	proc_set_signals(client_proc, client_signal);

-	/* Save the flags. */
-	client_flags = flags|CLIENT_WRITE_ACK;
-	log_debug("flags are %#llx", (unsigned long long)client_flags);
-
 	/* Initialize the client socket and start the server. */
-#ifdef HAVE_SYSTEMD
-	if (systemd_activated()) {
-		/* socket-based activation, do not even try to be a client. */
-		fd = server_start(client_proc, flags, base, 0, NULL);
-	} else
-#endif
-	fd = client_connect(base, socket_path, client_flags);
+	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
 	if (fd == -1) {
 		if (errno == ECONNREFUSED) {
 			fprintf(stderr, "no server running on %s\n",
@@ -304,8 +301,6 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 		cwd = "/";
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";
-	if ((termname = getenv("TERM")) == NULL)
-		termname = "";

 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
@@ -321,16 +316,6 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 	    NULL) != 0)
 		fatal("pledge failed");

-	/* Load terminfo entry if any. */
-	if (isatty(STDIN_FILENO) &&
-	    *termname != '\0' &&
-	    tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,
-	    &cause) != 0) {
-		fprintf(stderr, "%s\n", cause);
-		free(cause);
-		return (1);
-	}
-
 	/* Free stuff that is not used in the client. */
 	if (ptm_fd != -1)
 		close(ptm_fd);
@@ -361,9 +346,7 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 	}

 	/* Send identify messages. */
-	client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);
-	tty_term_free_list(caps, ncaps);
-	proc_flush_peer(client_peer);
+	client_send_identify(ttynam, cwd);

 	/* Send first command. */
 	if (msg == MSG_COMMAND) {
@@ -414,65 +397,42 @@ client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 		ppid = getppid();
 		if (client_exittype == MSG_DETACHKILL && ppid > 1)
 			kill(ppid, SIGHUP);
-	} else if (client_flags & CLIENT_CONTROL) {
+	} else if (client_flags & CLIENT_CONTROLCONTROL) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
 			printf("%%exit %s\n", client_exit_message());
 		else
 			printf("%%exit\n");
-		fflush(stdout);
-		if (client_flags & CLIENT_CONTROL_WAITEXIT)
-			control_wait_exit(STDIN_FILENO);
-		if (client_flags & CLIENT_CONTROLCONTROL) {
-			printf("\033\\");
-			fflush(stdout);
-			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
-		}
+		printf("\033\\");
+		tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 	} else if (client_exitreason != CLIENT_EXIT_NONE)
 		fprintf(stderr, "%s\n", client_exit_message());
-
-	/* Restore the streams to blocking. */
 	setblocking(STDIN_FILENO, 1);
-	setblocking(STDOUT_FILENO, 1);
-	setblocking(STDERR_FILENO, 1);
-
 	return (client_exitval);
 }

 /* Send identify messages to server. */
 static void
-client_send_identify(const char *ttynam, const char *termname, char **caps,
-    u_int ncaps, const char *cwd, int feat)
+client_send_identify(const char *ttynam, const char *cwd)
 {
-	char	**ss;
-	size_t	  sslen;
-	int	  fd;
-	uint64_t  flags = client_flags;
-	pid_t	  pid;
-	u_int	  i;
+	const char	 *s;
+	char		**ss;
+	size_t		  sslen;
+	int		  fd, flags = client_flags;
+	pid_t		  pid;

-	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &flags, sizeof flags);
-	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
-	    sizeof client_flags);
+	proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);

-	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,
-	    strlen(termname) + 1);
-	proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);
+	if ((s = getenv("TERM")) == NULL)
+		s = "";
+	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);

 	proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
 	    strlen(ttynam) + 1);
 	proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);

-	for (i = 0; i < ncaps; i++) {
-		proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,
-		    caps[i], strlen(caps[i]) + 1);
-	}
-
 	if ((fd = dup(STDIN_FILENO)) == -1)
 		fatal("dup failed");
 	proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
-	if ((fd = dup(STDOUT_FILENO)) == -1)
-		fatal("dup failed");
-	proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);

 	pid = getpid();
 	proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
@@ -487,14 +447,275 @@ client_send_identify(const char *ttynam, const char *termname, char **caps,
 	proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
 }

+/* File write error callback. */
+static void
+client_write_error_callback(__unused struct bufferevent *bev,
+    __unused short what, void *arg)
+{
+	struct client_file	*cf = arg;
+
+	log_debug("write error file %d", cf->stream);
+
+	bufferevent_free(cf->event);
+	cf->event = NULL;
+
+	close(cf->fd);
+	cf->fd = -1;
+
+	if (client_exitflag)
+		client_exit();
+}
+
+/* File write callback. */
+static void
+client_write_callback(__unused struct bufferevent *bev, void *arg)
+{
+	struct client_file	*cf = arg;
+
+	if (cf->closed && EVBUFFER_LENGTH(cf->event->output) == 0) {
+		bufferevent_free(cf->event);
+		close(cf->fd);
+		RB_REMOVE(client_files, &client_files, cf);
+		file_free(cf);
+	}
+
+	if (client_exitflag)
+		client_exit();
+}
+
+/* Open write file. */
+static void
+client_write_open(void *data, size_t datalen)
+{
+	struct msg_write_open	*msg = data;
+	const char		*path;
+	struct msg_write_ready	 reply;
+	struct client_file	 find, *cf;
+	const int		 flags = O_NONBLOCK|O_WRONLY|O_CREAT;
+	int			 error = 0;
+
+	if (datalen < sizeof *msg)
+		fatalx("bad MSG_WRITE_OPEN size");
+	if (datalen == sizeof *msg)
+		path = "-";
+	else
+		path = (const char *)(msg + 1);
+	log_debug("open write file %d %s", msg->stream, path);
+
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL) {
+		cf = file_create(NULL, msg->stream, NULL, NULL);
+		RB_INSERT(client_files, &client_files, cf);
+	} else {
+		error = EBADF;
+		goto reply;
+	}
+	if (cf->closed) {
+		error = EBADF;
+		goto reply;
+	}
+
+	cf->fd = -1;
+	if (msg->fd == -1)
+		cf->fd = open(path, msg->flags|flags, 0644);
+	else {
+		if (msg->fd != STDOUT_FILENO && msg->fd != STDERR_FILENO)
+			errno = EBADF;
+		else {
+			cf->fd = dup(msg->fd);
+			if (~client_flags & CLIENT_CONTROL)
+				close(msg->fd); /* can only be used once */
+		}
+	}
+	if (cf->fd == -1) {
+		error = errno;
+		goto reply;
+	}
+
+	cf->event = bufferevent_new(cf->fd, NULL, client_write_callback,
+	    client_write_error_callback, cf);
+	bufferevent_enable(cf->event, EV_WRITE);
+	goto reply;
+
+reply:
+	reply.stream = msg->stream;
+	reply.error = error;
+	proc_send(client_peer, MSG_WRITE_READY, -1, &reply, sizeof reply);
+}
+
+/* Write to client file. */
+static void
+client_write_data(void *data, size_t datalen)
+{
+	struct msg_write_data	*msg = data;
+	struct client_file	 find, *cf;
+	size_t			 size = datalen - sizeof *msg;
+
+	if (datalen < sizeof *msg)
+		fatalx("bad MSG_WRITE size");
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL)
+		fatalx("unknown stream number");
+	log_debug("write %zu to file %d", size, cf->stream);
+
+	if (cf->event != NULL)
+		bufferevent_write(cf->event, msg + 1, size);
+}
+
+/* Close client file. */
+static void
+client_write_close(void *data, size_t datalen)
+{
+	struct msg_write_close	*msg = data;
+	struct client_file	 find, *cf;
+
+	if (datalen != sizeof *msg)
+		fatalx("bad MSG_WRITE_CLOSE size");
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL)
+		fatalx("unknown stream number");
+	log_debug("close file %d", cf->stream);
+
+	if (cf->event == NULL || EVBUFFER_LENGTH(cf->event->output) == 0) {
+		if (cf->event != NULL)
+			bufferevent_free(cf->event);
+		if (cf->fd != -1)
+			close(cf->fd);
+		RB_REMOVE(client_files, &client_files, cf);
+		file_free(cf);
+	}
+}
+
+/* File read callback. */
+static void
+client_read_callback(__unused struct bufferevent *bev, void *arg)
+{
+	struct client_file	*cf = arg;
+	void			*bdata;
+	size_t			 bsize;
+	struct msg_read_data	*msg;
+	size_t			 msglen;
+
+	msg = xmalloc(sizeof *msg);
+	for (;;) {
+		bdata = EVBUFFER_DATA(cf->event->input);
+		bsize = EVBUFFER_LENGTH(cf->event->input);
+
+		if (bsize == 0)
+			break;
+		if (bsize > MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg)
+			bsize = MAX_IMSGSIZE - IMSG_HEADER_SIZE - sizeof *msg;
+		log_debug("read %zu from file %d", bsize, cf->stream);
+
+		msglen = (sizeof *msg) + bsize;
+		msg = xrealloc(msg, msglen);
+		msg->stream = cf->stream;
+		memcpy(msg + 1, bdata, bsize);
+		proc_send(client_peer, MSG_READ, -1, msg, msglen);
+
+		evbuffer_drain(cf->event->input, bsize);
+	}
+	free(msg);
+}
+
+/* File read error callback. */
+static void
+client_read_error_callback(__unused struct bufferevent *bev,
+    __unused short what, void *arg)
+{
+	struct client_file	*cf = arg;
+	struct msg_read_done	 msg;
+
+	log_debug("read error file %d", cf->stream);
+
+	msg.stream = cf->stream;
+	msg.error = 0;
+	proc_send(client_peer, MSG_READ_DONE, -1, &msg, sizeof msg);
+
+	bufferevent_free(cf->event);
+	close(cf->fd);
+	RB_REMOVE(client_files, &client_files, cf);
+	file_free(cf);
+}
+
+/* Open read file. */
+static void
+client_read_open(void *data, size_t datalen)
+{
+	struct msg_read_open	*msg = data;
+	const char		*path;
+	struct msg_read_done	 reply;
+	struct client_file	 find, *cf;
+	const int		 flags = O_NONBLOCK|O_RDONLY;
+	int			 error = 0;
+
+	if (datalen < sizeof *msg)
+		fatalx("bad MSG_READ_OPEN size");
+	if (datalen == sizeof *msg)
+		path = "-";
+	else
+		path = (const char *)(msg + 1);
+	log_debug("open read file %d %s", msg->stream, path);
+
+	find.stream = msg->stream;
+	if ((cf = RB_FIND(client_files, &client_files, &find)) == NULL) {
+		cf = file_create(NULL, msg->stream, NULL, NULL);
+		RB_INSERT(client_files, &client_files, cf);
+	} else {
+		error = EBADF;
+		goto reply;
+	}
+	if (cf->closed) {
+		error = EBADF;
+		goto reply;
+	}
+
+	cf->fd = -1;
+	if (msg->fd == -1)
+		cf->fd = open(path, flags);
+	else {
+		if (msg->fd != STDIN_FILENO)
+			errno = EBADF;
+		else {
+			cf->fd = dup(msg->fd);
+			if (~client_flags & CLIENT_CONTROL)
+				close(msg->fd); /* can only be used once */
+		}
+	}
+	if (cf->fd == -1) {
+		error = errno;
+		goto reply;
+	}
+
+	cf->event = bufferevent_new(cf->fd, client_read_callback, NULL,
+	    client_read_error_callback, cf);
+	bufferevent_enable(cf->event, EV_READ);
+	return;
+
+reply:
+	reply.stream = msg->stream;
+	reply.error = error;
+	proc_send(client_peer, MSG_READ_DONE, -1, &reply, sizeof reply);
+}
+
 /* Run command in shell; used for -c. */
 static __dead void
 client_exec(const char *shell, const char *shellcmd)
 {
-	char	*argv0;
+	const char	*name, *ptr;
+	char		*argv0;

 	log_debug("shell %s, command %s", shell, shellcmd);
-	argv0 = shell_argv0(shell, !!(client_flags & CLIENT_LOGIN));
+
+	ptr = strrchr(shell, '/');
+	if (ptr != NULL && *(ptr + 1) != '\0')
+		name = ptr + 1;
+	else
+		name = shell;
+	if (client_flags & CLIENT_LOGIN)
+		xasprintf(&argv0, "-%s", name);
+	else
+		xasprintf(&argv0, "%s", name);
 	setenv("SHELL", shell, 1);

 	proc_clear_signals(client_proc, 1);
@@ -514,23 +735,11 @@ client_signal(int sig)
 {
 	struct sigaction sigact;
 	int		 status;
-	pid_t		 pid;

-	log_debug("%s: %s", __func__, strsignal(sig));
-	if (sig == SIGCHLD) {
-		for (;;) {
-			pid = waitpid(WAIT_ANY, &status, WNOHANG);
-			if (pid == 0)
-				break;
-			if (pid == -1) {
-				if (errno == ECHILD)
-					break;
-				log_debug("waitpid failed: %s",
-				    strerror(errno));
-			}
-		}
-	} else if (!client_attached) {
-		if (sig == SIGTERM || sig == SIGHUP)
+	if (sig == SIGCHLD)
+		waitpid(WAIT_ANY, &status, WNOHANG);
+	else if (!client_attached) {
+		if (sig == SIGTERM)
 			proc_exit(client_proc);
 	} else {
 		switch (sig) {
@@ -540,8 +749,7 @@ client_signal(int sig)
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
 		case SIGTERM:
-			if (!client_suspended)
-				client_exitreason = CLIENT_EXIT_TERMINATED;
+			client_exitreason = CLIENT_EXIT_TERMINATED;
 			client_exitval = 1;
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
@@ -556,31 +764,18 @@ client_signal(int sig)
 			if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 				fatal("sigaction failed");
 			proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
-			client_suspended = 0;
 			break;
 		}
 	}
 }

-/* Callback for file write error or close. */
-static void
-client_file_check_cb(__unused struct client *c, __unused const char *path,
-    __unused int error, __unused int closed, __unused struct evbuffer *buffer,
-    __unused void *data)
-{
-	if (client_exitflag)
-		client_exit();
-}
-
 /* Callback for client read events. */
 static void
 client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
-		if (!client_exitflag) {
-			client_exitreason = CLIENT_EXIT_LOST_SERVER;
-			client_exitval = 1;
-		}
+		client_exitreason = CLIENT_EXIT_LOST_SERVER;
+		client_exitval = 1;
 		proc_exit(client_proc);
 		return;
 	}
@@ -591,38 +786,13 @@ client_dispatch(struct imsg *imsg, __unused void *arg)
 		client_dispatch_wait(imsg);
 }

-/* Process an exit message. */
-static void
-client_dispatch_exit_message(char *data, size_t datalen)
-{
-	int	retval;
-
-	if (datalen < sizeof retval && datalen != 0)
-		fatalx("bad MSG_EXIT size");
-
-	if (datalen >= sizeof retval) {
-		memcpy(&retval, data, sizeof retval);
-		client_exitval = retval;
-	}
-
-	if (datalen > sizeof retval) {
-		datalen -= sizeof retval;
-		data += sizeof retval;
-
-		client_exitmessage = xmalloc(datalen);
-		memcpy(client_exitmessage, data, datalen);
-		client_exitmessage[datalen - 1] = '\0';
-
-		client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
-	}
-}
-
 /* Dispatch imsgs when in wait state (before MSG_READY). */
 static void
 client_dispatch_wait(struct imsg *imsg)
 {
 	char		*data;
 	ssize_t		 datalen;
+	int		 retval;
 	static int	 pledge_applied;

 	/*
@@ -645,7 +815,12 @@ client_dispatch_wait(struct imsg *imsg)
 	switch (imsg->hdr.type) {
 	case MSG_EXIT:
 	case MSG_SHUTDOWN:
-		client_dispatch_exit_message(data, datalen);
+		if (datalen != sizeof retval && datalen != 0)
+			fatalx("bad MSG_EXIT size");
+		if (datalen == sizeof retval) {
+			memcpy(&retval, data, sizeof retval);
+			client_exitval = retval;
+		}
 		client_exitflag = 1;
 		client_exit();
 		break;
@@ -666,14 +841,6 @@ client_dispatch_wait(struct imsg *imsg)
 		client_exitval = 1;
 		proc_exit(client_proc);
 		break;
-	case MSG_FLAGS:
-		if (datalen != sizeof client_flags)
-			fatalx("bad MSG_FLAGS string");
-
-		memcpy(&client_flags, data, sizeof client_flags);
-		log_debug("new flags are %#llx",
-		    (unsigned long long)client_flags);
-		break;
 	case MSG_SHELL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");
@@ -688,23 +855,16 @@ client_dispatch_wait(struct imsg *imsg)
 		proc_exit(client_proc);
 		break;
 	case MSG_READ_OPEN:
-		file_read_open(&client_files, client_peer, imsg, 1,
-		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
-		    NULL);
-		break;
-	case MSG_READ_CANCEL:
-		file_read_cancel(&client_files, imsg);
+		client_read_open(data, datalen);
 		break;
 	case MSG_WRITE_OPEN:
-		file_write_open(&client_files, client_peer, imsg, 1,
-		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
-		    NULL);
+		client_write_open(data, datalen);
 		break;
 	case MSG_WRITE:
-		file_write_data(&client_files, imsg);
+		client_write_data(data, datalen);
 		break;
 	case MSG_WRITE_CLOSE:
-		file_write_close(&client_files, imsg);
+		client_write_close(data, datalen);
 		break;
 	case MSG_OLDSTDERR:
 	case MSG_OLDSTDIN:
@@ -712,9 +872,6 @@ client_dispatch_wait(struct imsg *imsg)
 		fprintf(stderr, "server version is too old for client\n");
 		proc_exit(client_proc);
 		break;
-	default:
-		log_debug("unknown message type %u", imsg->hdr.type);
-		break;
 	}
 }

@@ -730,14 +887,6 @@ client_dispatch_attached(struct imsg *imsg)
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

 	switch (imsg->hdr.type) {
-	case MSG_FLAGS:
-		if (datalen != sizeof client_flags)
-			fatalx("bad MSG_FLAGS string");
-
-		memcpy(&client_flags, data, sizeof client_flags);
-		log_debug("new flags are %#llx",
-		    (unsigned long long)client_flags);
-		break;
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
@@ -762,10 +911,11 @@ client_dispatch_attached(struct imsg *imsg)
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXIT:
-		client_dispatch_exit_message(data, datalen);
-		if (client_exitreason == CLIENT_EXIT_NONE)
-			client_exitreason = CLIENT_EXIT_EXITED;
+		if (datalen != 0 && datalen != sizeof (int))
+			fatalx("bad MSG_EXIT size");
+
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
+		client_exitreason = CLIENT_EXIT_EXITED;
 		break;
 	case MSG_EXITED:
 		if (datalen != 0)
@@ -791,7 +941,6 @@ client_dispatch_attached(struct imsg *imsg)
 		sigact.sa_handler = SIG_DFL;
 		if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 			fatal("sigaction failed");
-		client_suspended = 1;
 		kill(getpid(), SIGTSTP);
 		break;
 	case MSG_LOCK:
@@ -801,8 +950,5 @@ client_dispatch_attached(struct imsg *imsg)
 		system(data);
 		proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);
 		break;
-	default:
-		log_debug("unknown message type %u", imsg->hdr.type);
-		break;
 	}
 }
--- a/cmd-attach-session.c
+++ b/cmd-attach-session.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-attach-session.c,v 1.91 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -37,31 +37,28 @@ const struct cmd_entry cmd_attach_session_entry = {
 	.name = "attach-session",
 	.alias = "attach",

-	.args = { "c:dEf:rt:x", 0, 0, NULL },
-	.usage = "[-dErx] [-c working-directory] [-f flags] "
-	         CMD_TARGET_SESSION_USAGE,
+	.args = { "c:dErt:x", 0, 0 },
+	.usage = "[-dErx] [-c working-directory] " CMD_TARGET_SESSION_USAGE,

 	/* -t is special */

-	.flags = CMD_STARTSERVER|CMD_READONLY,
+	.flags = CMD_STARTSERVER,
 	.exec = cmd_attach_session_exec
 };

 enum cmd_retval
 cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
-    int xflag, int rflag, const char *cflag, int Eflag, const char *fflag)
+    int xflag, int rflag, const char *cflag, int Eflag)
 {
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	 target;
+	struct cmd_find_state	*current = &item->shared->current;
 	enum cmd_find_type	 type;
 	int			 flags;
-	struct client		*c = cmdq_get_client(item), *c_loop;
+	struct client		*c = item->client, *c_loop;
 	struct session		*s;
 	struct winlink		*wl;
 	struct window_pane	*wp;
-	char			*cwd, *cause;
+	char			*cause;
 	enum msgtype		 msgtype;
-	uid_t			 uid;

 	if (RB_EMPTY(&sessions)) {
 		cmdq_error(item, "no sessions");
@@ -70,7 +67,6 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,

 	if (c == NULL)
 		return (CMD_RETURN_NORMAL);
-
 	if (server_client_check_nested(c)) {
 		cmdq_error(item, "sessions should be nested with care, "
 		    "unset $TMUX to force");
@@ -84,17 +80,15 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		type = CMD_FIND_SESSION;
 		flags = CMD_FIND_PREFER_UNATTACHED;
 	}
-	if (cmd_find_target(&target, item, tflag, type, flags) != 0)
+	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
 		return (CMD_RETURN_ERROR);
-	s = target.s;
-	wl = target.wl;
-	wp = target.wp;
+	s = item->target.s;
+	wl = item->target.wl;
+	wp = item->target.wp;

 	if (wl != NULL) {
-		if (wp != NULL) {
-			window_redraw_active_switch(wp->window, wp);
+		if (wp != NULL)
 			window_set_active_pane(wp->window, wp, 1);
-		}
 		session_set_current(s, wl);
 		if (wp != NULL)
 			cmd_find_from_winlink_pane(current, wl, wp, 0);
@@ -103,21 +97,8 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 	}

 	if (cflag != NULL) {
-		cwd = format_single(item, cflag, c, s, wl, wp);
 		free((void *)s->cwd);
-		s->cwd = cwd;
-	}
-	if (fflag)
-		server_client_set_flags(c, fflag);
-	if (rflag) {
-		if (c->flags & CLIENT_READONLY) {
-			uid = proc_get_peer_uid(c->peer);
-			if (uid != getuid()) {
-				cmdq_error(item, "client is read-only");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		c->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
+		s->cwd = format_single(item, cflag, c, s, wl, wp);
 	}

 	c->last_session = c->session;
@@ -136,15 +117,25 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		if (!Eflag)
 			environ_update(s->options, c->environ, s->environ);

-		server_client_set_session(c, s);
-		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
+		c->session = s;
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
 			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
+		status_timer_start(c);
+		notify_client("client-session-changed", c);
+		session_update_activity(s, NULL);
+		gettimeofday(&s->last_attached_time, NULL);
+		server_redraw_client(c);
+		s->curw->flags &= ~WINLINK_ALERTFLAGS;
+		s->curw->window->latest = c;
 	} else {
 		if (server_client_open(c, &cause) != 0) {
 			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
+		if (rflag)
+			c->flags |= CLIENT_READONLY;

 		if (dflag || xflag) {
 			if (xflag)
@@ -160,17 +151,25 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 		if (!Eflag)
 			environ_update(s->options, c->environ, s->environ);

-		server_client_set_session(c, s);
+		c->session = s;
 		server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
+		status_timer_start(c);
+		notify_client("client-session-changed", c);
+		session_update_activity(s, NULL);
+		gettimeofday(&s->last_attached_time, NULL);
+		server_redraw_client(c);
+		s->curw->flags &= ~WINLINK_ALERTFLAGS;
+		s->curw->window->latest = c;

 		if (~c->flags & CLIENT_CONTROL)
 			proc_send(c->peer, MSG_READY, -1, NULL, 0);
-		events_fire_client("client-attached", c);
+		notify_client("client-attached", c);
 		c->flags |= CLIENT_ATTACHED;
 	}
-
-	if (cfg_finished)
-		cfg_show_causes(s);
+	recalculate_sizes();
+	alerts_check_session(s);
+	server_update_socket();

 	return (CMD_RETURN_NORMAL);
 }
@@ -178,9 +177,9 @@ cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
 static enum cmd_retval
 cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = cmd_get_args(self);
+	struct args	*args = self->args;

 	return (cmd_attach_session(item, args_get(args, 't'),
 	    args_has(args, 'd'), args_has(args, 'x'), args_has(args, 'r'),
-	    args_get(args, 'c'), args_has(args, 'E'), args_get(args, 'f')));
+	    args_get(args, 'c'), args_has(args, 'E')));
 }
--- a/cmd-bind-key.c
+++ b/cmd-bind-key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-bind-key.c,v 1.47 2025/04/09 07:03:04 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,44 +27,33 @@
 * Bind a key to a command.
 */

-static enum args_parse_type	cmd_bind_key_args_parse(struct args *, u_int,
-				    char **);
-static enum cmd_retval		cmd_bind_key_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_bind_key_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_bind_key_entry = {
 	.name = "bind-key",
 	.alias = "bind",

-	.args = { "nrN:T:", 1, -1, cmd_bind_key_args_parse },
+	.args = { "nrN:T:", 2, -1 },
 	.usage = "[-nr] [-T key-table] [-N note] key "
-	         "[command [argument ...]]",
+	         "command [arguments]",

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_bind_key_exec
 };

-static enum args_parse_type
-cmd_bind_key_args_parse(__unused struct args *args, __unused u_int idx,
-    __unused char **cause)
-{
-	return (ARGS_PARSE_COMMANDS_OR_STRING);
-}
-
 static enum cmd_retval
 cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		 *args = cmd_get_args(self);
+	struct args		 *args = self->args;
 	key_code		  key;
-	const char		 *tablename, *note = args_get(args, 'N');
+	const char		 *tablename, *note;
 	struct cmd_parse_result	 *pr;
-	int			  repeat;
-	struct args_value	 *value;
-	u_int			  count = args_count(args);
+	char			**argv = args->argv;
+	int			  argc = args->argc, repeat;

-	key = key_string_lookup_string(args_string(args, 0));
+	key = key_string_lookup_string(argv[0]);
 	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-		cmdq_error(item, "unknown key: %s", args_string(args, 0));
+		cmdq_error(item, "unknown key: %s", argv[0]);
 		return (CMD_RETURN_ERROR);
 	}

@@ -76,25 +65,14 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 		tablename = "prefix";
 	repeat = args_has(args, 'r');

-	if (count == 1) {
-		key_bindings_add(tablename, key, note, repeat, NULL);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	value = args_value(args, 1);
-	if (count == 2 && value->type == ARGS_COMMANDS) {
-		key_bindings_add(tablename, key, note, repeat, value->cmdlist);
-		value->cmdlist->references++;
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (count == 2)
-		pr = cmd_parse_from_string(args_string(args, 1), NULL);
-	else {
-		pr = cmd_parse_from_arguments(args_values(args) + 1, count - 1,
-		    NULL);
-	}
+	if (argc == 2)
+		pr = cmd_parse_from_string(argv[1], NULL);
+	else
+		pr = cmd_parse_from_arguments(argc - 1, argv + 1, NULL);
 	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		cmdq_error(item, "empty command");
+		return (CMD_RETURN_ERROR);
 	case CMD_PARSE_ERROR:
 		cmdq_error(item, "%s", pr->error);
 		free(pr->error);
@@ -102,6 +80,7 @@ cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 	case CMD_PARSE_SUCCESS:
 		break;
 	}
+	note = args_get(args, 'N');
 	key_bindings_add(tablename, key, note, repeat, pr->cmdlist);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-break-pane.c
+++ b/cmd-break-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-break-pane.c,v 1.76 2026/08/17 07:04:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,10 +34,9 @@ const struct cmd_entry cmd_break_pane_entry = {
 	.name = "break-pane",
 	.alias = "breakp",

-	.args = { "abdPF:n:s:t:Wx:X:y:Y:", 0, 0, NULL },
-	.usage = "[-abdPW] [-F format] [-n window-name] [-s src-pane] "
-		 "[-t dst-window] [-x width] [-y height] [-X x-position] "
-		 "[-Y y-position]",
+	.args = { "dPF:n:s:t:", 0, 0 },
+	.usage = "[-dP] [-F format] [-n window-name] [-s src-pane] "
+		 "[-t dst-window]",

 	.source = { 's', CMD_FIND_PANE, 0 },
 	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },
@@ -46,146 +45,60 @@ const struct cmd_entry cmd_break_pane_entry = {
 	.exec = cmd_break_pane_exec
 };

-static enum cmd_retval
-cmd_break_pane_float(struct cmdq_item *item, struct args *args,
-    struct window *w, struct window_pane *wp)
-{
-	struct layout_cell	*lc = wp->layout_cell;
-	char			*cause = NULL;
-	enum pane_lines		 lines = window_get_pane_lines(w);
-	struct layout_geometry	*fg = &lc->fg;
-
-	if (window_pane_is_floating(wp)) {
-		cmdq_error(item, "pane is already floating");
-		return (CMD_RETURN_ERROR);
-	}
-	if (w->flags & WINDOW_ZOOMED) {
-		cmdq_error(item, "can't float a pane while window is zoomed");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (layout_floating_args_parse(item, args, lines, w, fg, &cause) != 0) {
-		cmdq_error(item, "failed to float pane: %s", cause);
-		free(cause);
-		return (CMD_RETURN_ERROR);
-	}
-	layout_remove_tile(w, lc);
-	layout_set_size(lc, fg->sx, fg->sy, fg->xoff, fg->yoff);
-
-	lc->flags |= LAYOUT_CELL_FLOATING;
-	TAILQ_REMOVE(&w->z_index, wp, zentry);
-	TAILQ_INSERT_HEAD(&w->z_index, wp, zentry);
-
-	if (!args_has(args, 'd'))
-		window_set_active_pane(w, wp, 1);
-	layout_fix_offsets(w);
-	layout_fix_panes(w, NULL);
-	events_fire_window("window-layout-changed", w);
-	server_redraw_window(w);
-
-	return (CMD_RETURN_NORMAL);
-}
-
 static enum cmd_retval
 cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct client		*tc = cmdq_get_target_client(item);
-	struct winlink		*wl = source->wl;
-	struct session		*src_s = source->s;
-	struct session		*dst_s = target->s;
-	struct window_pane	*wp = source->wp;
-	struct window		*w = wl->window, *old_w = w;
-	char			*cause, *cp;
-	int			 idx = target->idx, before, old_idx = wl->idx;
-	const char		*template, *name = args_get(args, 'n');
+	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct winlink		*wl = item->source.wl;
+	struct session		*src_s = item->source.s;
+	struct session		*dst_s = item->target.s;
+	struct window_pane	*wp = item->source.wp;
+	struct window		*w = wl->window;
+	char			*name, *cause;
+	int			 idx = item->target.idx;
+	const char		*template;
+	char			*cp;

-	if (wp == w->modal) {
-		cmdq_error(item, "pane is modal");
+	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
+		cmdq_error(item, "index %d already in use", idx);
 		return (CMD_RETURN_ERROR);
 	}

-	if (args_has(args, 'W'))
-		return (cmd_break_pane_float(item, args, w, wp));
-
-	if (name != NULL && !check_name(name)) {
-		cmdq_error(item, "invalid window name: %s", name);
+	if (window_count_panes(w) == 1) {
+		cmdq_error(item, "can't break with only one pane");
 		return (CMD_RETURN_ERROR);
 	}
-
-	before = args_has(args, 'b');
-	if (args_has(args, 'a') || before) {
-		if (target->wl != NULL)
-			idx = winlink_shuffle_up(dst_s, target->wl, before);
-		else
-			idx = winlink_shuffle_up(dst_s, dst_s->curw, before);
-		if (idx == -1)
-			return (CMD_RETURN_ERROR);
-	}
 	server_unzoom_window(w);

-	if (window_count_panes(w, 1) == 1) {
-		if (server_link_window(src_s, wl, dst_s, idx, 0,
-		    !args_has(args, 'd'), &cause) != 0) {
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		if (name != NULL) {
-			window_set_name(w, name, 0);
-			options_set_number(w->options, "automatic-rename", 0);
-		}
-		server_unlink_window(src_s, wl);
-		wl = winlink_find_by_window(&dst_s->windows, w);
-		if (wl == NULL)
-			return (CMD_RETURN_ERROR);
-		window_fire_pane_moved(wp, old_w, old_idx, w, wl->idx);
-		goto out;
-	}
-	if (idx != -1 && winlink_find_by_index(&dst_s->windows, idx) != NULL) {
-		cmdq_error(item, "index in use: %d", idx);
-		return (CMD_RETURN_ERROR);
-	}
-
 	TAILQ_REMOVE(&w->panes, wp, entry);
-	TAILQ_REMOVE(&w->z_index, wp, zentry);
-	server_client_remove_pane(wp);
 	window_lost_pane(w, wp);
 	layout_close_pane(wp);

 	w = wp->window = window_create(w->sx, w->sy, w->xpixel, w->ypixel);
-	window_add_ref(w, __func__);
 	options_set_parent(wp->options, w->options);
-	wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
+	wp->flags |= PANE_STYLECHANGED;
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
-	TAILQ_INSERT_HEAD(&w->z_index, wp, zentry);
 	w->active = wp;
-	w->latest = tc;
+	w->latest = c;

-	free(w->name);
-	if (name == NULL)
-		w->name = default_window_name(w);
-	else {
-		w->name = clean_name(name, 0);
+	if (!args_has(args, 'n')) {
+		name = default_window_name(w);
+		window_set_name(w, name);
+		free(name);
+	} else {
+		window_set_name(w, args_get(args, 'n'));
 		options_set_number(w->options, "automatic-rename", 0);
 	}
-	window_set_fill_cells(w);
+
+	layout_init(w, wp);
+	wp->flags |= PANE_CHANGED;

 	if (idx == -1)
 		idx = -1 - options_get_number(dst_s->options, "base-index");
 	wl = session_attach(dst_s, w, idx, &cause); /* can't fail */
-
-	layout_init(w, wp);
-	wp->flags |= PANE_CHANGED;
-	colour_palette_from_option(&wp->palette, wp->options);
-
-	window_remove_ref(w, __func__);
-	events_fire_window("window-created", w);
-	window_fire_pane_moved(wp, old_w, old_idx, w, wl->idx);
-	if (!args_has(args, 'd')) {
+	if (!args_has(self->args, 'd')) {
 		session_select(dst_s, wl->idx);
 		cmd_find_from_session(current, dst_s, 0);
 	}
@@ -197,11 +110,10 @@ cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 	if (src_s != dst_s)
 		server_status_session_group(dst_s);

-out:
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = BREAK_PANE_TEMPLATE;
-		cp = format_single(item, template, tc, dst_s, wl, wp);
+		cp = format_single(item, template, c, dst_s, wl, wp);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}
--- a/cmd-capture-pane.c
+++ b/cmd-capture-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-capture-pane.c,v 1.69 2026/09/08 07:31:59 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Jonathan Alvarado <radobobo@users.sourceforge.net>
@@ -29,21 +29,18 @@

 static enum cmd_retval	cmd_capture_pane_exec(struct cmd *, struct cmdq_item *);

-static char	*cmd_capture_pane_append(char *, size_t *, const char *,
-		     size_t);
+static char	*cmd_capture_pane_append(char *, size_t *, char *, size_t);
 static char	*cmd_capture_pane_pending(struct args *, struct window_pane *,
 		     size_t *);
 static char	*cmd_capture_pane_history(struct args *, struct cmdq_item *,
 		     struct window_pane *, size_t *);
-static char	*cmd_capture_pane_hyperlinks(struct grid *, struct screen *,
-		     u_int, u_int *, u_int *, size_t *);

 const struct cmd_entry cmd_capture_pane_entry = {
 	.name = "capture-pane",
 	.alias = "capturep",

-	.args = { "ab:CeE:FHIJLMNpPqRS:Tt:", 0, 0, NULL },
-	.usage = "[-aCeFHIJLMNpPqRT] " CMD_BUFFER_USAGE " [-E end-line] "
+	.args = { "ab:CeE:JNpPqS:t:", 0, 0 },
+	.usage = "[-aCeJNpPq] " CMD_BUFFER_USAGE " [-E end-line] "
 		 "[-S start-line] " CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -56,8 +53,8 @@ const struct cmd_entry cmd_clear_history_entry = {
 	.name = "clear-history",
 	.alias = "clearhist",

-	.args = { "Ht:", 0, 0, NULL },
-	.usage = "[-H] " CMD_TARGET_PANE_USAGE,
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -66,8 +63,7 @@ const struct cmd_entry cmd_clear_history_entry = {
 };

 static char *
-cmd_capture_pane_append(char *buf, size_t *len, const char *line,
-    size_t linelen)
+cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 {
 	buf = xrealloc(buf, *len + linelen + 1);
 	memcpy(buf + *len, line, linelen);
@@ -75,108 +71,6 @@ cmd_capture_pane_append(char *buf, size_t *len, const char *line,
 	return (buf);
 }

-static char *
-cmd_capture_pane_cell(struct screen *s, u_int xx, u_int yy)
-{
-	struct grid		*gd = s->grid;
-	struct hyperlinks	*hl = s->hyperlinks;
-	struct grid_cell	 gc;
-	char			*line, *data, *link, *linkid, *f, *b, *u;
-	char			 c[UTF8_SIZE + 1];
-	const char		*uri, *iid;
-	u_int			 flags;
-
-	grid_get_cell(gd, xx, yy, &gc);
-
-	memcpy(c, gc.data.data, gc.data.size);
-	c[gc.data.size] = '\0';
-	utf8_stravis(&data, c, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL);
-
-	if (gc.link != 0 && hyperlinks_get(hl, gc.link, &uri, &iid, NULL)) {
-		xasprintf(&link, "%s", uri);
-		if (iid != NULL && *iid != '\0')
-			xasprintf(&linkid, "%s", iid);
-		else
-			xasprintf(&linkid, "NONE");
-	} else {
-		xasprintf(&link, "NONE");
-		xasprintf(&linkid, "NONE");
-	}
-
-	flags = gc.flags;
-	if (gc.fg & COLOUR_FLAG_256)
-		flags |= GRID_FLAG_FG256;
-	if (gc.bg & COLOUR_FLAG_256)
-		flags |= GRID_FLAG_BG256;
-
-	xasprintf(&f, "%s[%x]", colour_tostring(gc.fg), gc.fg);
-	xasprintf(&b, "%s[%x]", colour_tostring(gc.bg), gc.bg);
-	xasprintf(&u, "%s[%x]", colour_tostring(gc.us), gc.us);
-
-	xasprintf(&line, "\t\tC %u,%u data=(%u,%u,%s) flags=%s[%x] "
-	    "attr=%s[%x] fg=%s bg=%s us=%s link=%s linkid=%s\n",
-	    yy, xx, gc.data.width, gc.data.size, data,
-	    grid_cell_flags_string(flags), flags,
-	    grid_cell_attr_string(gc.attr), gc.attr, f, b, u, link, linkid);
-
-	free(f);
-	free(b);
-	free(u);
-	free(link);
-	free(linkid);
-	free(data);
-	return (line);
-}
-
-static char *
-cmd_capture_pane_grid(struct window_pane *wp, size_t *len)
-{
-	struct screen		*s = &wp->base;
-	struct grid		*gd = s->grid;
-	struct grid_line	*gl;
-	struct osc133_data	*od;
-	char			*buf = xstrdup(""), *line;
-	char			 p[11];
-	u_int			 yy, xx, total = gd->hsize + gd->sy;
-
-	xasprintf(&line, "G %ux%u (%u/%u)\n", gd->sx, gd->sy, gd->hsize,
-	    gd->hlimit);
-	buf = cmd_capture_pane_append(buf, len, line, strlen(line));
-	free(line);
-
-	for (yy = 0; yy < total; yy++) {
-		gl = grid_get_line(gd, yy);
-		if (yy < gd->hsize)
-			snprintf(p, sizeof p, "-");
-		else
-			snprintf(p, sizeof p, "%u", yy - gd->hsize);
-		od = &gl->osc133_data;
-		if (gl->flags & GRID_LINE_OSC133_FLAGS) {
-			xasprintf(&line, "\tL %u (%s) flags=%s[%x] "
-			    "%u/%u osc133=%u,%u,%u,%u,%u\n", yy, p,
-			    grid_line_flags_string(gl->flags), gl->flags,
-			    gl->cellused, gl->cellsize, od->prompt_col,
-			    od->cmd_col, od->out_start_col,
-			    od->out_end_col, od->exit_status);
-		} else {
-			xasprintf(&line, "\tL %u (%s) flags=%s[%x] "
-			    "%u/%u\n", yy, p,
-			    grid_line_flags_string(gl->flags), gl->flags,
-			    gl->cellused, gl->cellsize);
-		}
-		buf = cmd_capture_pane_append(buf, len, line, strlen(line));
-		free(line);
-
-		for (xx = 0; xx < gd->sx; xx++) {
-			line = cmd_capture_pane_cell(s, xx, yy);
-			buf = cmd_capture_pane_append(buf, len, line,
-			    strlen(line));
-			free(line);
-		}
-	}
-	return (buf);
-}
-
 static char *
 cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
    size_t *len)
@@ -186,7 +80,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	size_t		 linelen;
 	u_int		 i;

-	pending = input_pending(wp->ictx);
+	pending = input_pending(wp);
 	if (pending == NULL)
 		return (xstrdup(""));

@@ -200,7 +94,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 				tmp[0] = line[i];
 				tmp[1] = '\0';
 			} else
-				snprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
+				xsnprintf(tmp, sizeof tmp, "\\%03hho", line[i]);
 			buf = cmd_capture_pane_append(buf, len, tmp,
 			    strlen(tmp));
 		}
@@ -209,66 +103,22 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	return (buf);
 }

-static char *
-cmd_capture_pane_hyperlinks(struct grid *gd, struct screen *s, u_int py,
-    u_int *links, u_int *nlinks, size_t *len)
-{
-	const struct grid_line	*gl = grid_peek_line(gd, py);
-	struct grid_cell	 gc;
-	const char		*uri;
-	char			*line = xstrdup("");
-	u_int			 i, j;
-
-	*len = 0;
-
-	if (s->hyperlinks == NULL || (~gl->flags & GRID_LINE_HYPERLINK))
-		return (line);
-
-	for (i = 0; i < gl->cellused; i++) {
-		grid_get_cell(gd, i, py, &gc);
-		if (gc.link == 0)
-			continue;
-		for (j = 0; j < *nlinks; j++) {
-			if (links[j] == gc.link)
-				break;
-		}
-		if (j != *nlinks)
-			continue;
-
-		if (!hyperlinks_get(s->hyperlinks, gc.link, &uri, NULL, NULL))
-			continue;
-
-		if (*nlinks == gd->sx)
-			break;
-		links[(*nlinks)++] = gc.link;
-
-		if (*len != 0)
-			line = cmd_capture_pane_append(line, len, " ", 1);
-		line = cmd_capture_pane_append(line, len, uri, strlen(uri));
-	}
-	return (line);
-}
-
 static char *
 cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
    struct window_pane *wp, size_t *len)
 {
-	struct grid			*gd;
-	const struct grid_line		*gl;
-	struct screen			*s;
-	struct grid_cell		*gc = NULL;
-	struct window_mode_entry	*wme;
-	int				 n, join_lines, number_lines, flags = 0;
-	int				 show_flags, show_time, hyperlinks;
-	u_int				*links = NULL, nlinks = 0;
-	u_int				 i, sx, top, bottom, tmp;
-	char				*cause, *buf = NULL, *line, b[64], *cp;
-	const char			*Sflag, *Eflag;
-	size_t				 linelen;
+	struct grid		*gd;
+	const struct grid_line	*gl;
+	struct grid_cell	*gc = NULL;
+	int			 n, with_codes, escape_c0, join_lines, no_trim;
+	u_int			 i, sx, top, bottom, tmp;
+	char			*cause, *buf, *line;
+	const char		*Sflag, *Eflag;
+	size_t			 linelen;

 	sx = screen_size_x(&wp->base);
 	if (args_has(args, 'a')) {
-		gd = wp->base.saved_grid;
+		gd = wp->saved_grid;
 		if (gd == NULL) {
 			if (!args_has(args, 'q')) {
 				cmdq_error(item, "no alternate screen");
@@ -276,31 +126,18 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 			}
 			return (xstrdup(""));
 		}
-		s = &wp->base;
-	} else if (args_has(args, 'M')) {
-		wme = TAILQ_FIRST(&wp->modes);
-		if (wme != NULL && wme->mode->get_screen != NULL) {
-			s = wme->mode->get_screen (wme);
-			gd = s->grid;
-		} else {
-			s = &wp->base;
-			gd = wp->base.grid;
-		}
-	} else {
-		s = &wp->base;
+	} else
 		gd = wp->base.grid;
-	}

 	Sflag = args_get(args, 'S');
 	if (Sflag != NULL && strcmp(Sflag, "-") == 0)
 		top = 0;
 	else {
-		n = args_strtonum_and_expand(args, 'S', INT_MIN, SHRT_MAX,
-			item, &cause);
+		n = args_strtonum(args, 'S', INT_MIN, SHRT_MAX, &cause);
 		if (cause != NULL) {
 			top = gd->hsize;
 			free(cause);
-		} else if (n < 0 && (u_int)-n > gd->hsize)
+		} else if (n < 0 && (u_int) -n > gd->hsize)
 			top = 0;
 		else
 			top = gd->hsize + n;
@@ -312,12 +149,11 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 	if (Eflag != NULL && strcmp(Eflag, "-") == 0)
 		bottom = gd->hsize + gd->sy - 1;
 	else {
-		n = args_strtonum_and_expand(args, 'E', INT_MIN, SHRT_MAX,
-			item, &cause);
+		n = args_strtonum(args, 'E', INT_MIN, SHRT_MAX, &cause);
 		if (cause != NULL) {
 			bottom = gd->hsize + gd->sy - 1;
 			free(cause);
-		} else if (n < 0 && (u_int)-n > gd->hsize)
+		} else if (n < 0 && (u_int) -n > gd->hsize)
 			bottom = 0;
 		else
 			bottom = gd->hsize + n;
@@ -331,109 +167,46 @@ cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
 		top = tmp;
 	}

+	with_codes = args_has(args, 'e');
+	escape_c0 = args_has(args, 'C');
 	join_lines = args_has(args, 'J');
-	if (args_has(args, 'e'))
-		flags |= GRID_STRING_WITH_SEQUENCES;
-	if (args_has(args, 'C'))
-		flags |= GRID_STRING_ESCAPE_SEQUENCES;
-	if (!join_lines && !args_has(args, 'T'))
-		flags |= GRID_STRING_EMPTY_CELLS;
-	if (!join_lines && !args_has(args, 'N'))
-		flags |= GRID_STRING_TRIM_SPACES;
-	number_lines = args_has(args, 'L');
-	show_flags = args_has(args, 'F');
-	show_time = args_has(args, 'I');
-	hyperlinks = args_has(args, 'H');
-	if (hyperlinks)
-		links = xreallocarray(NULL, gd->sx, sizeof *links);
+	no_trim = args_has(args, 'N');

+	buf = NULL;
 	for (i = top; i <= bottom; i++) {
-		if (hyperlinks) {
-			line = cmd_capture_pane_hyperlinks(gd, s, i, links,
-			    &nlinks, &linelen);
-		} else {
-			line = grid_string_cells(gd, 0, i, sx, &gc, flags, s);
-			linelen = strlen(line);
-		}
-		if (hyperlinks && linelen == 0) {
-			free(line);
-			continue;
-		}
-		gl = grid_peek_line(gd, i);
+		line = grid_string_cells(gd, 0, i, sx, &gc, with_codes,
+		    escape_c0, !join_lines && !no_trim);
+		linelen = strlen(line);

-		if (number_lines) {
-			if (i >= gd->hsize)
-				n = i - gd->hsize;
-			else
-				n = (int)i - (int)gd->hsize;
-			n = snprintf(b, sizeof b, "%d ", n);
-			if (n >= 0)
-				buf = cmd_capture_pane_append(buf, len, b, n);
-		}
-		if (show_time) {
-			n = snprintf(b, sizeof b, "%llu ",
-			    (unsigned long long)grid_line_time(gl));
-			if (n >= 0)
-				buf = cmd_capture_pane_append(buf, len, b, n);
-		}
-		if (show_flags) {
-			cp = b;
-			*cp = '\0';
-
-			if (gl->flags & GRID_LINE_DEAD)
-				*cp++ = 'D';
-			if (gl->flags & GRID_LINE_HYPERLINK)
-				*cp++ = 'H';
-			if (gl->flags & GRID_LINE_START_OUTPUT)
-				*cp++ = 'O';
-			if (gl->flags & GRID_LINE_START_PROMPT)
-				*cp++ = 'P';
-			if (gl->flags & GRID_LINE_WRAPPED)
-				*cp++ = 'W';
-			if (gl->flags & GRID_LINE_EXTENDED)
-				*cp++ = 'X';
-			if (b == cp)
-				*cp++ = '-';
-			*cp++ = ' ';
-			*cp = '\0';
-			buf = cmd_capture_pane_append(buf, len, b, strlen (b));
-		}
 		buf = cmd_capture_pane_append(buf, len, line, linelen);

+		gl = grid_peek_line(gd, i);
 		if (!join_lines || !(gl->flags & GRID_LINE_WRAPPED))
 			buf[(*len)++] = '\n';

 		free(line);
 	}
-	free(links);
-	if (buf == NULL)
-		buf = xstrdup("");
 	return (buf);
 }

 static enum cmd_retval
 cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmdq_get_client(item);
-	struct window_pane	*wp = cmdq_get_target(item)->wp;
+	struct args		*args = self->args;
+	struct client		*c = item->client;
+	struct window_pane	*wp = item->target.wp;
 	char			*buf, *cause;
 	const char		*bufname;
 	size_t			 len;

-	if (cmd_get_entry(self) == &cmd_clear_history_entry) {
+	if (self->entry == &cmd_clear_history_entry) {
 		window_pane_reset_mode_all(wp);
 		grid_clear_history(wp->base.grid);
-		if (args_has(args, 'H'))
-			screen_reset_hyperlinks(wp->screen);
-		server_redraw_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}

 	len = 0;
-	if (args_has(args, 'R'))
-		buf = cmd_capture_pane_grid(wp, &len);
-	else if (args_has(args, 'P') && !args_has(args, 'H'))
+	if (args_has(args, 'P'))
 		buf = cmd_capture_pane_pending(args, wp, &len);
 	else
 		buf = cmd_capture_pane_history(args, item, wp, &len);
@@ -441,19 +214,14 @@ cmd_capture_pane_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);

 	if (args_has(args, 'p')) {
-		if (len > 0 && buf[len - 1] == '\n')
-			len--;
-		if (c->flags & CLIENT_CONTROL)
-			control_write(c, "%.*s", (int)len, buf);
-		else {
-			if (!file_can_print(c)) {
-				cmdq_error(item, "can't write to client");
-				free(buf);
-				return (CMD_RETURN_ERROR);
-			}
-			file_print_buffer(c, buf, len);
-			file_print(c, "\n");
+		if (!file_can_print(c)) {
+			cmdq_error(item, "can't write output to client");
+			free(buf);
+			return (CMD_RETURN_ERROR);
 		}
+		file_print_buffer(c, buf, len);
+		if (args_has(args, 'P') && len > 0)
+			file_print(c, "\n");
 		free(buf);
 	} else {
 		bufname = NULL;
--- a/cmd-choose-tree.c
+++ b/cmd-choose-tree.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-choose-tree.c,v 1.58 2026/07/14 17:17:17 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2012 Thomas Adam <thomas@xteddy.org>
@@ -24,18 +24,15 @@
 * Enter a mode.
 */

-static enum args_parse_type	cmd_choose_tree_args_parse(struct args *args,
-				    u_int idx, char **cause);
-static enum cmd_retval		cmd_choose_tree_exec(struct cmd *,
-    				    struct cmdq_item *);
+static enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_choose_tree_entry = {
 	.name = "choose-tree",
 	.alias = NULL,

-	.args = { "F:f:GhK:kNO:rst:wyZ", 0, 1, cmd_choose_tree_args_parse },
-	.usage = "[-GhkNrswZ] [-F format] [-f filter] [-K key-format] "
-		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
+	.args = { "F:Gf:NO:rst:wZ", 0, 1 },
+	.usage = "[-GNrswZ] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -47,9 +44,9 @@ const struct cmd_entry cmd_choose_client_entry = {
 	.name = "choose-client",
 	.alias = NULL,

-	.args = { "F:f:hiK:kNO:rt:yZ", 0, 1, cmd_choose_tree_args_parse },
-	.usage = "[-hikNrZ] [-F format] [-f filter] [-K key-format] "
-		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
+	.args = { "F:f:NO:rt:Z", 0, 1 },
+	.usage = "[-NrZ] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -61,9 +58,9 @@ const struct cmd_entry cmd_choose_buffer_entry = {
 	.name = "choose-buffer",
 	.alias = NULL,

-	.args = { "F:f:K:kNO:rt:yZ", 0, 1, cmd_choose_tree_args_parse },
-	.usage = "[-kNrZ] [-F format] [-f filter] [-K key-format] "
-		 "[-O sort-order] " CMD_TARGET_PANE_USAGE " [template]",
+	.args = { "F:f:NO:rt:Z", 0, 1 },
+	.usage = "[-NrZ] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE " [template]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -71,86 +68,24 @@ const struct cmd_entry cmd_choose_buffer_entry = {
 	.exec = cmd_choose_tree_exec
 };

-const struct cmd_entry cmd_customize_mode_entry = {
-	.name = "customize-mode",
-	.alias = NULL,
-
-	.args = { "F:f:kNt:yZ", 0, 0, NULL },
-	.usage = "[-kNZ] [-F format] [-f filter] " CMD_TARGET_PANE_USAGE,
-
-	.target = { 't', CMD_FIND_PANE, 0 },
-
-	.flags = 0,
-	.exec = cmd_choose_tree_exec
-};
-
-const struct cmd_entry cmd_switch_mode_entry = {
-	.name = "switch-mode",
-	.alias = NULL,
-
-	.args = { "F:kst:wZ", 0, 1, cmd_choose_tree_args_parse },
-	.usage = "[-kswZ] [-F format] " CMD_TARGET_PANE_USAGE " [command]",
-
-	.target = { 't', CMD_FIND_PANE, 0 },
-
-	.flags = 0,
-	.exec = cmd_choose_tree_exec
-};
-
-const struct cmd_entry cmd_display_panes_entry = {
-	.name = "display-panes",
-	.alias = "displayp",
-
-	.args = { "d:kNs:t:Z", 0, 1, cmd_choose_tree_args_parse },
-	.usage = "[-kNZ] [-d duration] [-s source-window] "
-		 CMD_TARGET_PANE_USAGE " [template]",
-
-	.source = { 's', CMD_FIND_WINDOW, 0 },
-	.target = { 't', CMD_FIND_PANE, 0 },
-
-	.flags = CMD_AFTERHOOK,
-	.exec = cmd_choose_tree_exec
-};
-
-static enum args_parse_type
-cmd_choose_tree_args_parse(__unused struct args *args, __unused u_int idx,
-    __unused char **cause)
-{
-	return (ARGS_PARSE_COMMANDS_OR_STRING);
-}
-
 static enum cmd_retval
 cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct window_pane		*wp = target->wp;
+	struct args			*args = self->args;
+	struct window_pane		*wp = item->target.wp;
 	const struct window_mode	*mode;
-	enum sort_order			 order;

-	order = sort_order_from_string(args_get(args, 'O'));
-	if (order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (cmd_get_entry(self) == &cmd_choose_buffer_entry) {
-		if (paste_is_empty())
+	if (self->entry == &cmd_choose_buffer_entry) {
+		if (paste_get_top(NULL) == NULL)
 			return (CMD_RETURN_NORMAL);
 		mode = &window_buffer_mode;
-	} else if (cmd_get_entry(self) == &cmd_choose_client_entry) {
+	} else if (self->entry == &cmd_choose_client_entry) {
 		if (server_client_how_many() == 0)
 			return (CMD_RETURN_NORMAL);
 		mode = &window_client_mode;
-	} else if (cmd_get_entry(self) == &cmd_customize_mode_entry)
-		mode = &window_customize_mode;
-	else if (cmd_get_entry(self) == &cmd_switch_mode_entry)
-		mode = &window_switch_mode;
-	else if (cmd_get_entry(self) == &cmd_display_panes_entry)
-		mode = &window_panes_mode;
-	else
+	} else
 		mode = &window_tree_mode;

-	window_pane_set_mode(wp, NULL, mode, item, target, args);
+	window_pane_set_mode(wp, mode, &item->target, args);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-command-prompt.c
+++ b/cmd-command-prompt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-command-prompt.c,v 1.76 2026/08/25 06:04:33 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -29,140 +29,92 @@
 * Prompt for command in client.
 */

-static enum args_parse_type	cmd_command_prompt_args_parse(struct args *,
-				    u_int, char **);
-static enum cmd_retval		cmd_command_prompt_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_command_prompt_exec(struct cmd *,
+			    struct cmdq_item *);

-static enum prompt_result cmd_command_prompt_callback(struct client *, void *,
-		    const char *, enum prompt_key_result);
+static int	cmd_command_prompt_callback(struct client *, void *,
+		    const char *, int);
 static void	cmd_command_prompt_free(void *);

 const struct cmd_entry cmd_command_prompt_entry = {
 	.name = "command-prompt",
 	.alias = NULL,

-	.args = { "1CbeFiklI:NPp:t:T:", 0, 1, cmd_command_prompt_args_parse },
-	.usage = "[-1CbeFiklNP] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE
-		 " [-T prompt-type] [template]",
+	.args = { "1kiI:Np:t:", 0, 1 },
+	.usage = "[-1kiN] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
+		 "[template]",

-	.flags = CMD_CLIENT_TFLAG,
+	.flags = 0,
 	.exec = cmd_command_prompt_exec
 };

-struct cmd_command_prompt_prompt {
-	char	*input;
-	char	*prompt;
-};
-
 struct cmd_command_prompt_cdata {
-	struct cmdq_item		 *item;
-	struct args_command_state	 *state;
+	int	 flags;

-	int				  flags;
-	enum prompt_type		  prompt_type;
+	char	*inputs;
+	char	*next_input;

-	struct window_pane		 *wp;
+	char	*prompts;
+	char	*next_prompt;

-	struct cmd_command_prompt_prompt *prompts;
-	u_int				  count;
-	u_int				  current;
-
-	int				  argc;
-	char				**argv;
+	char	*template;
+	int	 idx;
 };

-static enum args_parse_type
-cmd_command_prompt_args_parse(__unused struct args *args, __unused u_int idx,
-    __unused char **cause)
-{
-	return (ARGS_PARSE_COMMANDS_OR_STRING);
-}
-
 static enum cmd_retval
 cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct client			*tc = cmdq_get_target_client(item);
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	const char			*type, *s, *input;
-	struct cmd_command_prompt_cdata *cdata;
-	char				*tmp, *prompts, *prompt, *next_prompt;
-	char				*inputs = NULL, *next_input;
-	struct window_pane		*wp = target->wp;
-	u_int				 count = args_count(args);
-	int				 wait = !args_has(args, 'b'), space = 1;
-	int				 pane = args_has(args, 'P');
+	struct args			*args = self->args;
+	const char			*inputs, *prompts;
+	struct cmd_command_prompt_cdata	*cdata;
+	struct client			*c;
+	char				*prompt, *ptr, *input = NULL;
+	size_t				 n;

-	if (pane) {
-		if (wp == NULL || window_pane_has_prompt(wp))
-			return (CMD_RETURN_NORMAL);
-	} else if (tc->prompt != NULL)
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	if (c->prompt_string != NULL)
 		return (CMD_RETURN_NORMAL);
-	if (args_has(args, 'i'))
-		wait = 0;

 	cdata = xcalloc(1, sizeof *cdata);
-	if (wait)
-		cdata->item = item;
-	if (pane)
-		cdata->wp = wp;
-	cdata->state = args_make_commands_prepare(self, item, 0, "%1", wait,
-	    args_has(args, 'F'));

-	if ((s = args_get(args, 'p')) == NULL) {
-		if (count != 0) {
-			tmp = args_make_commands_get_command(cdata->state);
-			xasprintf(&prompts, "(%s)", tmp);
-			free(tmp);
-		} else {
-			prompts = xstrdup(":");
-			space = 0;
-		}
-		next_prompt = prompts;
-	} else
-		next_prompt = prompts = xstrdup(s);
-	if ((s = args_get(args, 'I')) != NULL)
-		next_input = inputs = xstrdup(s);
+	cdata->inputs = NULL;
+	cdata->next_input = NULL;
+
+	cdata->prompts = NULL;
+	cdata->next_prompt = NULL;
+
+	cdata->template = NULL;
+	cdata->idx = 1;
+
+	if (args->argc != 0)
+		cdata->template = xstrdup(args->argv[0]);
 	else
-		next_input = NULL;
-	if (args_has(args, 'l')) {
-		cdata->prompts = xcalloc(1, sizeof *cdata->prompts);
-		cdata->prompts[0].prompt = prompts;
-		cdata->prompts[0].input = inputs;
-		cdata->count = 1;
-	} else {
-		while ((prompt = strsep(&next_prompt, ",")) != NULL) {
-			cdata->prompts = xreallocarray(cdata->prompts,
-			    cdata->count + 1, sizeof *cdata->prompts);
-			if (!space)
-				tmp = xstrdup(prompt);
-			else
-				xasprintf(&tmp, "%s ", prompt);
-			cdata->prompts[cdata->count].prompt = tmp;
+		cdata->template = xstrdup("%1");

-			if (next_input != NULL) {
-				input = strsep(&next_input, ",");
-				if (input == NULL)
-					input = "";
-			} else
-				input = "";
-			cdata->prompts[cdata->count].input = xstrdup(input);
-			cdata->count++;
-		}
-		free(inputs);
-		free(prompts);
-	}
-
-	if ((type = args_get(args, 'T')) != NULL) {
-		cdata->prompt_type = prompt_type(type);
-		if (cdata->prompt_type == PROMPT_TYPE_INVALID) {
-			cmdq_error(item, "unknown type: %s", type);
-			cmd_command_prompt_free(cdata);
-			return (CMD_RETURN_ERROR);
-		}
+	if ((prompts = args_get(args, 'p')) != NULL)
+		cdata->prompts = xstrdup(prompts);
+	else if (args->argc != 0) {
+		n = strcspn(cdata->template, " ,");
+		xasprintf(&cdata->prompts, "(%.*s) ", (int) n, cdata->template);
 	} else
-		cdata->prompt_type = PROMPT_TYPE_COMMAND;
+		cdata->prompts = xstrdup(":");
+
+	/* Get first prompt. */
+	cdata->next_prompt = cdata->prompts;
+	ptr = strsep(&cdata->next_prompt, ",");
+	if (prompts == NULL)
+		prompt = xstrdup(ptr);
+	else
+		xasprintf(&prompt, "%s ", ptr);
+
+	/* Get initial prompt input. */
+	if ((inputs = args_get(args, 'I')) != NULL) {
+		cdata->inputs = xstrdup(inputs);
+		cdata->next_input = cdata->inputs;
+		input = strsep(&cdata->next_input, ",");
+	}

 	if (args_has(args, '1'))
 		cdata->flags |= PROMPT_SINGLE;
@@ -172,117 +124,79 @@ cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 		cdata->flags |= PROMPT_INCREMENTAL;
 	else if (args_has(args, 'k'))
 		cdata->flags |= PROMPT_KEY;
-	else if (args_has(args, 'e'))
-		cdata->flags |= PROMPT_BSPACE_EXIT;
-	if (args_has(args, 'C'))
-		cdata->flags |= PROMPT_NOFREEZE;
-	if (pane) {
-		cdata->flags |= PROMPT_ISPANE;
-		window_pane_set_prompt(wp, tc, target, cdata->prompts[0].prompt,
-		    cdata->prompts[0].input, cmd_command_prompt_callback,
-		    cmd_command_prompt_free, cdata, cdata->flags,
-		    cdata->prompt_type);
-	} else {
-		status_prompt_set(tc, target, cdata->prompts[0].prompt,
-		    cdata->prompts[0].input, cmd_command_prompt_callback,
-		    cmd_command_prompt_free, cdata, cdata->flags,
-		    cdata->prompt_type);
-	}
+	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
+	    cmd_command_prompt_free, cdata, cdata->flags);
+	free(prompt);

-	if (!wait)
-		return (CMD_RETURN_NORMAL);
-	return (CMD_RETURN_WAIT);
+	return (CMD_RETURN_NORMAL);
 }

-static enum prompt_result
+static int
 cmd_command_prompt_callback(struct client *c, void *data, const char *s,
-    enum prompt_key_result key)
+    int done)
 {
-	struct cmd_command_prompt_cdata		 *cdata = data;
-	char					 *error;
-	struct cmdq_item			 *item = cdata->item, *new_item;
-	struct cmd_list				 *cmdlist;
-	struct cmd_command_prompt_prompt	 *prompt;
-	int					  argc = 0;
-	char					**argv = NULL;
+	struct cmd_command_prompt_cdata	*cdata = data;
+	struct cmdq_item		*new_item;
+	char				*new_template, *prompt, *ptr;
+	char				*input = NULL;
+	struct cmd_parse_result		*pr;

-	if (s == NULL || key == PROMPT_KEY_MOVE)
-		goto out;
+	if (s == NULL)
+		return (0);
+	if (done && (cdata->flags & PROMPT_INCREMENTAL))
+		return (0);

-	if (key == PROMPT_KEY_CLOSE) {
-		if (cdata->flags & PROMPT_INCREMENTAL)
-			goto out;
-		cmd_append_argv(&cdata->argc, &cdata->argv, s);
-		if (++cdata->current != cdata->count) {
-			prompt = &cdata->prompts[cdata->current];
-			if (cdata->wp != NULL) {
-				window_pane_update_prompt(cdata->wp,
-				    prompt->prompt, prompt->input);
-			} else
-				status_prompt_update(c, prompt->prompt,
-				    prompt->input);
-			return (PROMPT_CONTINUE);
-		}
+	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
+	if (done) {
+		free(cdata->template);
+		cdata->template = new_template;
 	}

-	argc = cdata->argc;
-	argv = cmd_copy_argv(cdata->argc, cdata->argv);
-	if (key != PROMPT_KEY_CLOSE)
-		cmd_append_argv(&argc, &argv, s);
-	else {
-		cmd_free_argv(cdata->argc, cdata->argv);
-		cdata->argc = argc;
-		cdata->argv = cmd_copy_argv(argc, argv);
-	}
-
-	cmdlist = args_make_commands(cdata->state, argc, argv, &error);
-	if (cmdlist == NULL) {
-		cmdq_append(c, cmdq_get_error(error));
-		free(error);
-	} else if (item == NULL) {
-		new_item = cmdq_get_command(cmdlist, NULL);
-		cmdq_append(c, new_item);
-		cmd_list_free(cmdlist);
-	} else {
-		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
-		cmdq_insert_after(item, new_item);
-		cmd_list_free(cmdlist);
-	}
-	cmd_free_argv(argc, argv);
-
 	/*
-	 * An incremental prompt fires its callback on every edit but must stay
-	 * open for further typing; only an explicit close (handled above) ends
-	 * it.
+	 * Check if there are more prompts; if so, get its respective input
+	 * and update the prompt data.
 	 */
-	if (cdata->flags & PROMPT_INCREMENTAL)
-		return (PROMPT_CONTINUE);
+	if (done && (ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
+		xasprintf(&prompt, "%s ", ptr);
+		input = strsep(&cdata->next_input, ",");
+		status_prompt_update(c, prompt, input);

-out:
-	if (item != NULL) {
-		cdata->item = NULL;
-		cmdq_continue(item);
+		free(prompt);
+		cdata->idx++;
+		return (1);
 	}
-	return (PROMPT_CLOSE);
+
+	pr = cmd_parse_from_string(new_template, NULL);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		new_item = NULL;
+		break;
+	case CMD_PARSE_ERROR:
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
+		cmdq_append(c, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
+	}
+
+	if (!done)
+		free(new_template);
+	if (c->prompt_inputcb != cmd_command_prompt_callback)
+		return (1);
+	return (0);
 }

 static void
 cmd_command_prompt_free(void *data)
 {
-	struct cmd_command_prompt_cdata *cdata = data;
-	u_int				 i;
+	struct cmd_command_prompt_cdata	*cdata = data;

-	if (cdata->item != NULL) {
-		cmdq_continue(cdata->item);
-		cdata->item = NULL;
-	}
-
-	for (i = 0; i < cdata->count; i++) {
-		free(cdata->prompts[i].prompt);
-		free(cdata->prompts[i].input);
-	}
+	free(cdata->inputs);
 	free(cdata->prompts);
-	cmd_free_argv(cdata->argc, cdata->argv);
-	args_make_commands_free(cdata->state);
+	free(cdata->template);
 	free(cdata);
 }
--- a/cmd-confirm-before.c
+++ b/cmd-confirm-before.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-confirm-before.c,v 1.61 2026/06/24 10:55:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -28,130 +28,94 @@
 * Asks for confirmation before executing a command.
 */

-static enum args_parse_type	cmd_confirm_before_args_parse(struct args *,
-				    u_int, char **);
-static enum cmd_retval		cmd_confirm_before_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_confirm_before_exec(struct cmd *,
+			    struct cmdq_item *);

-static enum prompt_result cmd_confirm_before_callback(struct client *, void *,
-		    const char *, enum prompt_key_result);
+static int	cmd_confirm_before_callback(struct client *, void *,
+		    const char *, int);
 static void	cmd_confirm_before_free(void *);

 const struct cmd_entry cmd_confirm_before_entry = {
 	.name = "confirm-before",
 	.alias = "confirm",

-	.args = { "bc:p:t:y", 1, 1, cmd_confirm_before_args_parse },
-	.usage = "[-by] [-c confirm-key] [-p prompt] " CMD_TARGET_CLIENT_USAGE
-		 " command",
+	.args = { "p:t:", 1, 1 },
+	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",

-	.flags = CMD_CLIENT_TFLAG,
+	.flags = 0,
 	.exec = cmd_confirm_before_exec
 };

 struct cmd_confirm_before_data {
-	struct cmdq_item	*item;
-	struct cmd_list		*cmdlist;
-	u_char			 confirm_key;
-	int			 default_yes;
+	char	*cmd;
 };

-static enum args_parse_type
-cmd_confirm_before_args_parse(__unused struct args *args, __unused u_int idx,
-    __unused char **cause)
-{
-	return (ARGS_PARSE_COMMANDS_OR_STRING);
-}
-
 static enum cmd_retval
 cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
+	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
-	struct client			*tc = cmdq_get_target_client(item);
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	char				*new_prompt;
-	const char			*confirm_key, *prompt, *cmd;
-	int				 wait = !args_has(args, 'b');
+	struct client			*c;
+	char				*cmd, *copy, *new_prompt, *ptr;
+	const char			*prompt;

-	cdata = xcalloc(1, sizeof *cdata);
-	cdata->cmdlist = args_make_commands_now(self, item, 0, 1);
-	if (cdata->cmdlist == NULL) {
-		free(cdata);
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
 		return (CMD_RETURN_ERROR);
-	}
-
-	if (wait)
-		cdata->item = item;
-
-	cdata->default_yes = args_has(args, 'y');
-	if ((confirm_key = args_get(args, 'c')) != NULL) {
-		if (confirm_key[1] == '\0' &&
-		    confirm_key[0] > 31 &&
-		    confirm_key[0] < 127)
-			cdata->confirm_key = confirm_key[0];
-		else {
-			cmdq_error(item, "invalid confirm key");
-			cmd_list_free(cdata->cmdlist);
-			free(cdata);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-	else
-		cdata->confirm_key = 'y';

 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
-		cmd = cmd_get_entry(cmd_list_first(cdata->cmdlist))->name;
-		xasprintf(&new_prompt, "Confirm '%s'? (%c/n) ", cmd,
-		    cdata->confirm_key);
+		ptr = copy = xstrdup(args->argv[0]);
+		cmd = strsep(&ptr, " \t");
+		xasprintf(&new_prompt, "Confirm '%s'? (y/n) ", cmd);
+		free(copy);
 	}

-	status_prompt_set(tc, target, new_prompt, NULL,
-	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
-	    PROMPT_SINGLE, PROMPT_TYPE_COMMAND);
-	free(new_prompt);
+	cdata = xmalloc(sizeof *cdata);
+	cdata->cmd = xstrdup(args->argv[0]);

-	if (!wait)
-		return (CMD_RETURN_NORMAL);
-	return (CMD_RETURN_WAIT);
+	status_prompt_set(c, new_prompt, NULL,
+	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
+	    PROMPT_SINGLE);
+
+	free(new_prompt);
+	return (CMD_RETURN_NORMAL);
 }

-static enum prompt_result
+static int
 cmd_confirm_before_callback(struct client *c, void *data, const char *s,
-    __unused enum prompt_key_result key)
+    __unused int done)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct cmdq_item		*item = cdata->item, *new_item;
-	int				 retcode = 1;
+	struct cmdq_item		*new_item;
+	struct cmd_parse_result		*pr;

 	if (c->flags & CLIENT_DEAD)
-		goto out;
+		return (0);

-	if (s == NULL)
-		goto out;
-	if (s[0] != cdata->confirm_key && (s[0] != '\r' || !cdata->default_yes))
-		goto out;
-	retcode = 0;
+	if (s == NULL || *s == '\0')
+		return (0);
+	if (tolower((u_char)s[0]) != 'y' || s[1] != '\0')
+		return (0);

-	if (item == NULL) {
-		new_item = cmdq_get_command(cdata->cmdlist, NULL);
+	pr = cmd_parse_from_string(cdata->cmd, NULL);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		new_item = NULL;
+		break;
+	case CMD_PARSE_ERROR:
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
 		cmdq_append(c, new_item);
-	} else {
-		new_item = cmdq_get_command(cdata->cmdlist,
-		    cmdq_get_state(item));
-		cmdq_insert_after(item, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
 	}

-out:
-	if (item != NULL) {
-		if (cmdq_get_client(item) != NULL &&
-		    cmdq_get_client(item)->session == NULL)
-			cmdq_get_client(item)->retval = retcode;
-		cmdq_continue(item);
-	}
-	return (PROMPT_CLOSE);
+	return (0);
 }

 static void
@@ -159,6 +123,6 @@ cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;

-	cmd_list_free(cdata->cmdlist);
+	free(cdata->cmd);
 	free(cdata);
 }
--- a/cmd-copy-mode.c
+++ b/cmd-copy-mode.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-copy-mode.c,v 1.54 2026/07/14 17:17:17 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -30,13 +30,12 @@ const struct cmd_entry cmd_copy_mode_entry = {
 	.name = "copy-mode",
 	.alias = NULL,

-	.args = { "dekHMqSs:t:u", 0, 0, NULL },
-	.usage = "[-dekHMqSu] [-s src-pane] " CMD_TARGET_PANE_USAGE,
+	.args = { "eHMt:uq", 0, 0 },
+	.usage = "[-eHMuq] " CMD_TARGET_PANE_USAGE,

-	.source =  { 's', CMD_FIND_PANE, 0 },
 	.target = { 't', CMD_FIND_PANE, 0 },

-	.flags = CMD_AFTERHOOK|CMD_READONLY,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };

@@ -44,7 +43,7 @@ const struct cmd_entry cmd_clock_mode_entry = {
 	.name = "clock-mode",
 	.alias = NULL,

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -56,15 +55,11 @@ const struct cmd_entry cmd_clock_mode_entry = {
 static enum cmd_retval
 cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct key_event	*event = cmdq_get_event(item);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*c = cmdq_get_client(item);
+	struct args		*args = self->args;
+	struct cmdq_shared	*shared = item->shared;
+	struct client		*c = item->client;
 	struct session		*s;
-	struct window_pane	*wp = target->wp, *swp;
-	u_int			 tty_ox, tty_oy, tty_sx, tty_sy;
-	int			 line_numbers;
+	struct window_pane	*wp = item->target.wp;

 	if (args_has(args, 'q')) {
 		window_pane_reset_mode_all(wp);
@@ -72,42 +67,23 @@ cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	if (args_has(args, 'M')) {
-		if ((wp = cmd_mouse_pane(&event->m, &s, NULL)) == NULL)
+		if ((wp = cmd_mouse_pane(&shared->mouse, &s, NULL)) == NULL)
 			return (CMD_RETURN_NORMAL);
 		if (c == NULL || c->session != s)
 			return (CMD_RETURN_NORMAL);
 	}

-	if (cmd_get_entry(self) == &cmd_clock_mode_entry) {
-		window_pane_set_mode(wp, NULL, &window_clock_mode, item, NULL,
-		    NULL);
+	if (self->entry == &cmd_clock_mode_entry) {
+		window_pane_set_mode(wp, &window_clock_mode, NULL, NULL);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 's'))
-		swp = source->wp;
-	else
-		swp = wp;
-	line_numbers = 1;
-	if (event != NULL && KEYC_IS_MOUSE(event->key))
-		line_numbers = 0;
-	if (!window_pane_set_mode(wp, swp, &window_copy_mode, item, NULL,
-	    args)) {
-		window_copy_set_line_numbers(wp, line_numbers);
+	if (!window_pane_set_mode(wp, &window_copy_mode, NULL, args)) {
 		if (args_has(args, 'M'))
-			window_copy_start_drag(c, &event->m);
-	} else
-		window_copy_set_line_numbers(wp, line_numbers);
-	if (args_has(args, 'u'))
-		window_copy_pageup(wp, 0);
-	if (args_has(args, 'd'))
-		window_copy_pagedown(wp, 0, args_has(args, 'e'));
-	if (args_has(args, 'S')) {
-		tty_window_offset(&c->tty, &tty_ox, &tty_oy, &tty_sx, &tty_sy);
-		window_copy_scroll(wp, c->tty.mouse_slider_mpos, event->m.y,
-		    tty_oy, args_has(args, 'e'));
-		return (CMD_RETURN_NORMAL);
+			window_copy_start_drag(c, &shared->mouse);
 	}
+	if (args_has(self->args, 'u'))
+		window_copy_pageup(wp, 0);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-detach-client.c
+++ b/cmd-detach-client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-detach-client.c,v 1.39 2026/05/22 15:22:43 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,13 +33,13 @@ const struct cmd_entry cmd_detach_client_entry = {
 	.name = "detach-client",
 	.alias = "detach",

-	.args = { "aE:s:t:P", 0, 0, NULL },
+	.args = { "aE:s:t:P", 0, 0 },
 	.usage = "[-aP] [-E shell-command] "
 	         "[-s target-session] " CMD_TARGET_CLIENT_USAGE,

 	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

-	.flags = CMD_READONLY|CMD_CLIENT_TFLAG,
+	.flags = CMD_READONLY,
 	.exec = cmd_detach_client_exec
 };

@@ -47,71 +47,65 @@ const struct cmd_entry cmd_suspend_client_entry = {
 	.name = "suspend-client",
 	.alias = "suspendc",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,

-	.flags = CMD_CLIENT_TFLAG,
+	.flags = 0,
 	.exec = cmd_detach_client_exec
 };

 static enum cmd_retval
 cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct client		*c = cmdq_get_client(item);
-	struct client		*tc = cmdq_get_target_client(item), *loop;
-	struct session		*s;
-	enum msgtype		 msgtype;
-	const char		*cmd = args_get(args, 'E');
+	struct args	*args = self->args;
+	struct client	*c, *cloop;
+	struct session	*s;
+	enum msgtype	 msgtype;
+	const char	*cmd = args_get(args, 'E');

-	if (cmd_get_entry(self) == &cmd_suspend_client_entry) {
-		server_client_suspend(tc);
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	if (self->entry == &cmd_suspend_client_entry) {
+		server_client_suspend(c);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (c->flags & CLIENT_READONLY) {
-		if (args_has(args, 's') || args_has(args, 'a') || c != tc) {
-			cmdq_error(item, "client is read-only");
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
 	if (args_has(args, 'P'))
 		msgtype = MSG_DETACHKILL;
 	else
 		msgtype = MSG_DETACH;

 	if (args_has(args, 's')) {
-		s = source->s;
+		s = item->source.s;
 		if (s == NULL)
 			return (CMD_RETURN_NORMAL);
-		TAILQ_FOREACH(loop, &clients, entry) {
-			if (loop->session == s) {
+		TAILQ_FOREACH(cloop, &clients, entry) {
+			if (cloop->session == s) {
 				if (cmd != NULL)
-					server_client_exec(loop, cmd);
+					server_client_exec(cloop, cmd);
 				else
-					server_client_detach(loop, msgtype);
+					server_client_detach(cloop, msgtype);
 			}
 		}
 		return (CMD_RETURN_STOP);
 	}

 	if (args_has(args, 'a')) {
-		TAILQ_FOREACH(loop, &clients, entry) {
-			if (loop->session != NULL && loop != tc) {
+		TAILQ_FOREACH(cloop, &clients, entry) {
+			if (cloop->session != NULL && cloop != c) {
 				if (cmd != NULL)
-					server_client_exec(loop, cmd);
+					server_client_exec(cloop, cmd);
 				else
-					server_client_detach(loop, msgtype);
+					server_client_detach(cloop, msgtype);
 			}
 		}
 		return (CMD_RETURN_NORMAL);
 	}

 	if (cmd != NULL)
-		server_client_exec(tc, cmd);
+		server_client_exec(c, cmd);
 	else
-		server_client_detach(tc, msgtype);
+		server_client_detach(c, msgtype);
 	return (CMD_RETURN_STOP);
 }
--- a/cmd-display-menu.c
+++ b/cmd-display-menu.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-display-menu.c,v 1.53 2026/08/31 07:46:55 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,693 +27,152 @@
 * Display a menu on a client.
 */

-static enum args_parse_type	cmd_display_menu_args_parse(struct args *,
-				    u_int, char **);
-static enum cmd_retval		cmd_display_menu_exec(struct cmd *,
-				    struct cmdq_item *);
-static enum cmd_retval		cmd_display_popup_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_display_menu_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_display_menu_entry = {
 	.name = "display-menu",
 	.alias = "menu",

-	.args = { "b:c:C:H:s:S:MOt:T:x:y:", 1, -1, cmd_display_menu_args_parse },
-	.usage = "[-MO] [-b border-lines] [-c target-client] "
-		 "[-C starting-choice] [-H selected-style] [-s style] "
-		 "[-S border-style] " CMD_TARGET_PANE_USAGE " [-T title] "
-		 "[-x position] [-y position] name [key] [command] ...",
+	.args = { "c:t:T:x:y:", 1, -1 },
+	.usage = "[-c target-client] " CMD_TARGET_PANE_USAGE " [-T title] "
+		 "[-x position] [-y position] name key command ...",

 	.target = { 't', CMD_FIND_PANE, 0 },

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_menu_exec
 };

-const struct cmd_entry cmd_display_popup_entry = {
-	.name = "display-popup",
-	.alias = "popup",
-
-	.args = { "Bb:Cc:d:e:Eh:kNs:S:t:T:w:x:y:", 0, -1, NULL },
-	.usage = "[-BCEkN] [-b border-lines] [-c target-client] "
-		 "[-d start-directory] [-e environment] [-h height] "
-		 "[-s style] [-S border-style] " CMD_TARGET_PANE_USAGE
-		 " [-T title] [-w width] [-x position] [-y position] "
-		 "[shell-command [argument ...]]",
-
-	.target = { 't', CMD_FIND_PANE, 0 },
-
-	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG,
-	.exec = cmd_display_popup_exec
-};
-
-static enum args_parse_type
-cmd_display_menu_args_parse(struct args *args, u_int idx, __unused char **cause)
-{
-	u_int			 i = 0;
-	enum args_parse_type	 type = ARGS_PARSE_STRING;
-
-	for (;;) {
-		type = ARGS_PARSE_STRING;
-		if (i == idx)
-			break;
-		if (*args_string(args, i++) == '\0')
-			continue;
-
-		type = ARGS_PARSE_STRING;
-		if (i++ == idx)
-			break;
-
-		type = ARGS_PARSE_COMMANDS_OR_STRING;
-		if (i++ == idx)
-			break;
-	}
-	return (type);
-}
-
-static int
-cmd_display_menu_get_popup_pos(struct client *tc, struct cmdq_item *item,
-    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
-{
-	struct tty		*tty = &tc->tty;
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct key_event	*event = cmdq_get_event(item);
-	struct session		*s = tc->session;
-	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = target->wp;
-	struct style_ranges	*ranges = NULL;
-	struct style_range	*sr = NULL;
-	const char		*xp, *yp;
-	char			*p;
-	int			 top;
-	u_int			 line, ox, oy, sx, sy, lines, position;
-	long			 n;
-	struct format_tree	*ft;
-
-	/*
-	 * Work out the position from the -x and -y arguments. This is the
-	 * bottom-left position.
-	 */
-
-	/* If the popup is too big, stop now. */
-	if (w > tty->sx || h > tty->sy)
-		return (0);
-
-	/* Create format with mouse position if any. */
-	ft = format_create_from_target(item);
-	if (event->m.valid) {
-		format_add(ft, "popup_mouse_x", "%u", event->m.x);
-		format_add(ft, "popup_mouse_y", "%u", event->m.y);
-	}
-
-	/* Position of the previous menu, for -x/-y L. */
-	format_add(ft, "popup_last_x", "%u", target->w->menu_last_px);
-	format_add(ft, "popup_last_y", "%u", target->w->menu_last_py + h);
-
-	/*
-	 * If there are any status lines, add this window position and the
-	 * status line position.
-	 */
-	top = status_at_line(tc);
-	if (top != -1) {
-		lines = status_line_size(tc);
-		if (top == 0)
-			top = lines;
-		else
-			top = 0;
-		position = options_get_number(s->options, "status-position");
-
-		for (line = 0; line < lines; line++) {
-			ranges = &tc->status.entries[line].ranges;
-			TAILQ_FOREACH(sr, ranges, entry) {
-				if (sr->type != STYLE_RANGE_WINDOW)
-					continue;
-				if (sr->argument == (u_int)wl->idx)
-					break;
-			}
-			if (sr != NULL)
-				break;
-		}
-
-		if (sr != NULL) {
-			format_add(ft, "popup_window_status_line_x", "%u",
-			    sr->start);
-			if (position == 0) {
-				format_add(ft, "popup_window_status_line_y",
-				    "%u", line + 1 + h);
-			} else {
-				format_add(ft, "popup_window_status_line_y",
-				    "%u", tty->sy - lines + line);
-			}
-		}
-
-		if (position == 0)
-			format_add(ft, "popup_status_line_y", "%u", lines + h);
-		else {
-			format_add(ft, "popup_status_line_y", "%u",
-			    tty->sy - lines);
-		}
-	} else
-		top = 0;
-
-	/* Popup width and height. */
-	format_add(ft, "popup_width", "%u", w);
-	format_add(ft, "popup_height", "%u", h);
-
-	/* Position so popup is in the centre. */
-	n = (long)(tty->sx - 1) / 2 - w / 2;
-	if (n < 0)
-		format_add(ft, "popup_centre_x", "%u", 0);
-	else
-		format_add(ft, "popup_centre_x", "%ld", n);
-	n = (tty->sy - 1) / 2 + h / 2;
-	if (n >= tty->sy)
-		format_add(ft, "popup_centre_y", "%u", tty->sy - h);
-	else
-		format_add(ft, "popup_centre_y", "%ld", n);
-
-	/* Position of popup relative to mouse. */
-	if (event->m.valid) {
-		n = (long)event->m.x - w / 2;
-		if (n < 0)
-			format_add(ft, "popup_mouse_centre_x", "%u", 0);
-		else
-			format_add(ft, "popup_mouse_centre_x", "%ld", n);
-		n = event->m.y - h / 2;
-		if (n + h >= tty->sy) {
-			format_add(ft, "popup_mouse_centre_y", "%u",
-			    tty->sy - h);
-		} else
-			format_add(ft, "popup_mouse_centre_y", "%ld", n);
-		n = (long)event->m.y + h;
-		if (n >= tty->sy)
-			format_add(ft, "popup_mouse_top", "%u", tty->sy - 1);
-		else
-			format_add(ft, "popup_mouse_top", "%ld", n);
-		n = event->m.y - h;
-		if (n < 0)
-			format_add(ft, "popup_mouse_bottom", "%u", 0);
-		else
-			format_add(ft, "popup_mouse_bottom", "%ld", n);
-	}
-
-	/* Position in pane. */
-	tty_window_offset(&tc->tty, &ox, &oy, &sx, &sy);
-	n = top + wp->yoff - oy + h;
-	if (n >= tty->sy)
-		format_add(ft, "popup_pane_top", "%u", tty->sy - h);
-	else
-		format_add(ft, "popup_pane_top", "%ld", n);
-	format_add(ft, "popup_pane_bottom", "%u", top + wp->yoff + wp->sy - oy);
-	format_add(ft, "popup_pane_left", "%u", wp->xoff - ox);
-	n = (long)wp->xoff + wp->sx - ox - w;
-	if (n < 0)
-		format_add(ft, "popup_pane_right", "%u", 0);
-	else
-		format_add(ft, "popup_pane_right", "%ld", n);
-
-	/* Expand horizontal position. */
-	xp = args_get(args, 'x');
-	if (xp == NULL || strcmp(xp, "C") == 0)
-		xp = "#{popup_centre_x}";
-	else if (strcmp(xp, "R") == 0)
-		xp = "#{popup_pane_right}";
-	else if (strcmp(xp, "P") == 0)
-		xp = "#{popup_pane_left}";
-	else if (strcmp(xp, "M") == 0)
-		xp = "#{popup_mouse_centre_x}";
-	else if (strcmp(xp, "L") == 0)
-		xp = "#{popup_last_x}";
-	else if (strcmp(xp, "W") == 0)
-		xp = "#{popup_window_status_line_x}";
-	p = format_expand(ft, xp);
-	n = strtol(p, NULL, 10);
-	if (n + w >= tty->sx)
-		n = tty->sx - w;
-	else if (n < 0)
-		n = 0;
-	*px = n;
-	log_debug("%s: -x: %s = %s = %u (-w %u)", __func__, xp, p, *px, w);
-	free(p);
-
-	/* Expand vertical position  */
-	yp = args_get(args, 'y');
-	if (yp == NULL || strcmp(yp, "C") == 0)
-		yp = "#{popup_centre_y}";
-	else if (strcmp(yp, "P") == 0)
-		yp = "#{popup_pane_bottom}";
-	else if (strcmp(yp, "M") == 0)
-		yp = "#{popup_mouse_top}";
-	else if (strcmp(yp, "L") == 0)
-		yp = "#{popup_last_y}";
-	else if (strcmp(yp, "S") == 0)
-		yp = "#{popup_status_line_y}";
-	else if (strcmp(yp, "W") == 0)
-		yp = "#{popup_window_status_line_y}";
-	p = format_expand(ft, yp);
-	n = strtol(p, NULL, 10);
-	if (n < h)
-		n = 0;
-	else
-		n -= h;
-	if (n + h >= tty->sy)
-		n = tty->sy - h;
-	else if (n < 0)
-		n = 0;
-	*py = n;
-	log_debug("%s: -y: %s = %s = %u (-h %u)", __func__, yp, p, *py, h);
-	free(p);
-
-	format_free(ft);
-	return (1);
-}
-
-static int
-cmd_display_menu_get_menu_pos(struct client *tc, struct cmdq_item *item,
-    struct args *args, u_int *px, u_int *py, u_int w, u_int h)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct key_event	*event = cmdq_get_event(item);
-	struct session		*s = tc->session;
-	struct winlink		*wl = target->wl;
-	struct window		*window = target->w;
-	struct window_pane	*wp = target->wp;
-	struct style_ranges	*ranges = NULL;
-	struct style_range	*sr = NULL;
-	const char		*xp, *yp;
-	char			*p;
-	u_int			 line, ox, oy, sx, sy, lines, position;
-	long			 n, max_x, max_y, mouse_x = 0, mouse_y = 0;
-	struct format_tree	*ft;
-
-	max_x = window->sx > w ? window->sx - w : 0;
-	max_y = window->sy > h ? window->sy - h : 0;
-
-	tty_window_offset(&tc->tty, &ox, &oy, &sx, &sy);
-
-	ft = format_create_from_target(item);
-	if (event->m.valid) {
-		mouse_x = event->m.x + ox;
-		if (event->m.statusat == 0) {
-			if (event->m.y >= event->m.statuslines)
-				mouse_y = event->m.y - event->m.statuslines + oy;
-			else
-				mouse_y = oy;
-		} else if (event->m.statusat > 0 &&
-		    event->m.y >= (u_int)event->m.statusat) {
-			mouse_y = oy + sy - 1;
-		} else
-			mouse_y = event->m.y + oy;
-		format_add(ft, "popup_mouse_x", "%ld", mouse_x);
-		format_add(ft, "popup_mouse_y", "%ld", mouse_y);
-	}
-
-	format_add(ft, "popup_last_x", "%u", window->menu_last_px);
-	format_add(ft, "popup_last_y", "%u", window->menu_last_py + h);
-
-	lines = status_line_size(tc);
-	position = options_get_number(s->options, "status-position");
-	if (status_at_line(tc) != -1 && lines != 0) {
-		for (line = 0; line < lines; line++) {
-			ranges = &tc->status.entries[line].ranges;
-			TAILQ_FOREACH(sr, ranges, entry) {
-				if (sr->type != STYLE_RANGE_WINDOW)
-					continue;
-				if (sr->argument == (u_int)wl->idx)
-					break;
-			}
-			if (sr != NULL)
-				break;
-		}
-		if (sr != NULL) {
-			format_add(ft, "popup_window_status_line_x", "%u",
-			    sr->start + ox);
-			if (position == 0) {
-				format_add(ft, "popup_window_status_line_y",
-				    "%u", h);
-			} else {
-				format_add(ft, "popup_window_status_line_y",
-				    "%u", window->sy);
-			}
-		}
-		if (position == 0)
-			format_add(ft, "popup_status_line_y", "%u", h);
-		else
-			format_add(ft, "popup_status_line_y", "%u", window->sy);
-	}
-
-	format_add(ft, "popup_width", "%u", w);
-	format_add(ft, "popup_height", "%u", h);
-
-	n = ((long)window->sx - 1) / 2 - w / 2;
-	if (n < 0)
-		format_add(ft, "popup_centre_x", "%u", 0);
-	else
-		format_add(ft, "popup_centre_x", "%ld", n);
-	n = ((long)window->sy - 1) / 2 + h / 2;
-	if (n >= window->sy)
-		format_add(ft, "popup_centre_y", "%ld", max_y);
-	else
-		format_add(ft, "popup_centre_y", "%ld", n);
-
-	if (event->m.valid) {
-		n = mouse_x - w / 2;
-		if (n < 0)
-			format_add(ft, "popup_mouse_centre_x", "%u", 0);
-		else
-			format_add(ft, "popup_mouse_centre_x", "%ld", n);
-		n = mouse_y - h / 2;
-		if (n + h >= window->sy)
-			format_add(ft, "popup_mouse_centre_y", "%ld", max_y);
-		else
-			format_add(ft, "popup_mouse_centre_y", "%ld", n);
-		n = mouse_y + h;
-		if (n >= window->sy)
-			format_add(ft, "popup_mouse_top", "%u", window->sy - 1);
-		else
-			format_add(ft, "popup_mouse_top", "%ld", n);
-		n = mouse_y - h;
-		if (n < 0)
-			format_add(ft, "popup_mouse_bottom", "%u", 0);
-		else
-			format_add(ft, "popup_mouse_bottom", "%ld", n);
-	}
-
-	n = wp->yoff + h;
-	if (n >= window->sy)
-		format_add(ft, "popup_pane_top", "%ld", max_y);
-	else
-		format_add(ft, "popup_pane_top", "%ld", n);
-	format_add(ft, "popup_pane_bottom", "%u", wp->yoff + wp->sy);
-	format_add(ft, "popup_pane_left", "%u", wp->xoff);
-	n = (long)wp->xoff + wp->sx - w;
-	if (n < 0)
-		format_add(ft, "popup_pane_right", "%u", 0);
-	else
-		format_add(ft, "popup_pane_right", "%ld", n);
-
-	xp = args_get(args, 'x');
-	if (xp == NULL || strcmp(xp, "C") == 0)
-		xp = "#{popup_centre_x}";
-	else if (strcmp(xp, "R") == 0)
-		xp = "#{popup_pane_right}";
-	else if (strcmp(xp, "P") == 0)
-		xp = "#{popup_pane_left}";
-	else if (strcmp(xp, "M") == 0)
-		xp = "#{popup_mouse_centre_x}";
-	else if (strcmp(xp, "L") == 0)
-		xp = "#{popup_last_x}";
-	else if (strcmp(xp, "W") == 0)
-		xp = "#{popup_window_status_line_x}";
-	p = format_expand(ft, xp);
-	n = strtol(p, NULL, 10);
-	if (n < 0)
-		n = 0;
-	if (n > max_x)
-		n = max_x;
-	*px = n;
-	log_debug("%s: -x: %s = %s = %u (-w %u)", __func__, xp, p, *px, w);
-	free(p);
-
-	yp = args_get(args, 'y');
-	if (yp == NULL || strcmp(yp, "C") == 0)
-		yp = "#{popup_centre_y}";
-	else if (strcmp(yp, "P") == 0)
-		yp = "#{popup_pane_bottom}";
-	else if (strcmp(yp, "M") == 0)
-		yp = "#{popup_mouse_top}";
-	else if (strcmp(yp, "L") == 0)
-		yp = "#{popup_last_y}";
-	else if (strcmp(yp, "S") == 0)
-		yp = "#{popup_status_line_y}";
-	else if (strcmp(yp, "W") == 0)
-		yp = "#{popup_window_status_line_y}";
-	p = format_expand(ft, yp);
-	n = strtol(p, NULL, 10);
-	if (n < h)
-		n = 0;
-	else
-		n -= h;
-	if (n < 0)
-		n = 0;
-	if (n > max_y)
-		n = max_y;
-	*py = n;
-	log_debug("%s: -y: %s = %s = %u (-h %u)", __func__, yp, p, *py, h);
-	free(p);
-
-	format_free(ft);
-	return (1);
-}
-
 static enum cmd_retval
 cmd_display_menu_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct key_event	*event = cmdq_get_event(item);
-	struct client		*tc = cmdq_get_target_client(item);
+	struct args		*args = self->args;
+	struct client		*c;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
+	struct cmd_find_state	*fs = &item->target;
 	struct menu		*menu = NULL;
+	struct style_range	*sr;
 	struct menu_item	 menu_item;
-	const char		*key, *name, *value;
-	const char		*style = args_get(args, 's');
-	const char		*border_style = args_get(args, 'S');
-	const char		*selected_style = args_get(args, 'H');
-	enum box_lines		 lines = BOX_LINES_DEFAULT;
-	char			*title, *cause = NULL;
-	int			 flags = 0, starting_choice = 0;
-	u_int			 px, py, i, count = args_count(args);
-	struct options		*o = target->s->curw->window->options;
-	struct options_entry	*oe;
+	const char		*xp, *yp, *key;
+	char			*title, *name;
+	int			 at, flags, i;
+	u_int			 px, py, ox, oy, sx, sy;

-	if (args_has(args, 'C')) {
-		if (strcmp(args_get(args, 'C'), "-") == 0)
-			starting_choice = -1;
-		else {
-			starting_choice = args_strtonum(args, 'C', 0, UINT_MAX,
-			    &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "starting choice %s", cause);
-				goto fail;
-			}
-		}
-	}
+	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+	if (c->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+	at = status_at_line(c);

 	if (args_has(args, 'T'))
-		title = format_single_from_target(item, args_get(args, 'T'));
+		title = format_single(NULL, args_get(args, 'T'), c, s, wl, wp);
 	else
 		title = xstrdup("");
-	menu = menu_create(title);
-	free(title);

-	for (i = 0; i != count; /* nothing */) {
-		name = args_string(args, i++);
+	menu = menu_create(title);
+
+	for (i = 0; i != args->argc; /* nothing */) {
+		name = args->argv[i++];
 		if (*name == '\0') {
-			menu_add_item(menu, NULL, item, tc, target);
+			menu_add_item(menu, NULL, item, c, fs);
 			continue;
 		}

-		if (count - i < 2) {
+		if (args->argc - i < 2) {
 			cmdq_error(item, "not enough arguments");
-			goto fail;
+			free(title);
+			menu_free(menu);
+			return (CMD_RETURN_ERROR);
 		}
-		key = args_string(args, i++);
+		key = args->argv[i++];

 		menu_item.name = name;
 		menu_item.key = key_string_lookup_string(key);
-		menu_item.command = args_string(args, i++);
+		menu_item.command = args->argv[i++];

-		menu_add_item(menu, &menu_item, item, tc, target);
+		menu_add_item(menu, &menu_item, item, c, fs);
 	}
+	free(title);
 	if (menu == NULL) {
 		cmdq_error(item, "invalid menu arguments");
-		goto fail;
+		return (CMD_RETURN_ERROR);
 	}
-	if (menu->count == 0)
-		goto out;
-	if (!cmd_display_menu_get_menu_pos(tc, item, args, &px, &py,
-	    menu->width + 4, menu->count + 2))
-		goto out;
-
-	value = args_get(args, 'b');
-	if (value != NULL) {
-		oe = options_get(o, "menu-border-lines");
-		lines = options_find_choice(options_table_entry(oe), value,
-		    &cause);
-		if (lines == -1) {
-			cmdq_error(item, "menu-border-lines %s", cause);
-			goto fail;
-		}
-	}
-
-	if (args_has(args, 'O'))
-		flags |= MENU_STAYOPEN;
-	if (!event->m.valid && !args_has(args, 'M'))
-		flags |= MENU_NOMOUSE;
-	if (menu_display(menu, flags, starting_choice, item, px, py, tc, lines,
-	    style, selected_style, border_style, target, NULL, NULL) != 0)
-		goto out;
-	return (CMD_RETURN_NORMAL);
-
-out:
-	menu_free(menu);
-	return (CMD_RETURN_NORMAL);
-
-fail:
-	free(cause);
-	menu_free(menu);
-	return (CMD_RETURN_ERROR);
-}
-
-static enum cmd_retval
-cmd_display_popup_exec(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s;
-	struct client		*tc = cmdq_get_target_client(item);
-	struct tty		*tty = &tc->tty;
-	const char		*value, *shell, *shellcmd = NULL;
-	const char		*style = args_get(args, 's');
-	const char		*border_style = args_get(args, 'S');
-	char			*cwd = NULL, *cause = NULL, **argv = NULL;
-	char			*title = NULL;
-	int			 modify = popup_present(tc);
-	int			 flags = -1, argc = 0;
-	enum box_lines		 lines = BOX_LINES_DEFAULT;
-	u_int			 px, py, w, h, count = args_count(args);
-	struct args_value	*av;
-	struct environ		*env = NULL;
-	struct options		*o = s->curw->window->options;
-	struct options_entry	*oe;
-
-	if (args_has(args, 'C')) {
-		server_client_clear_overlay(tc);
+	if (menu->count == 0) {
+		menu_free(menu);
 		return (CMD_RETURN_NORMAL);
 	}
-	if (tc->flags & CLIENT_CONTROL)
-		return (CMD_RETURN_NORMAL);
-	if (!modify && tc->overlay_draw != NULL)
-		return (CMD_RETURN_NORMAL);

-	if (!modify) {
-		h = tty->sy / 2;
-		if (args_has(args, 'h')) {
-			h = args_percentage(args, 'h', 1, tty->sy, tty->sy,
-			    &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "height %s", cause);
-				goto fail;
-			}
-		}
-
-		w = tty->sx / 2;
-		if (args_has(args, 'w')) {
-			w = args_percentage(args, 'w', 1, tty->sx, tty->sx,
-			    &cause);
-			if (cause != NULL) {
-				cmdq_error(item, "width %s", cause);
-				goto fail;
-			}
-		}
-
-		if (w > tty->sx)
-			w = tty->sx;
-		if (h > tty->sy)
-			h = tty->sy;
-		if (!cmd_display_menu_get_popup_pos(tc, item, args, &px, &py,
-		    w, h))
-			goto out;
-
-		value = args_get(args, 'd');
-		if (value != NULL)
-			cwd = format_single_from_target(item, value);
+	xp = args_get(args, 'x');
+	if (xp == NULL)
+		px = 0;
+	else if (strcmp(xp, "R") == 0)
+		px = c->tty.sx - 1;
+	else if (strcmp(xp, "P") == 0) {
+		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
+		if (wp->xoff >= ox)
+			px = wp->xoff - ox;
 		else
-			cwd = xstrdup(server_client_get_cwd(tc, s));
-		if (count == 0) {
-			shellcmd = options_get_string(s->options,
-			    "default-command");
-		} else if (count == 1)
-			shellcmd = args_string(args, 0);
-		if (count <= 1 && (shellcmd == NULL || *shellcmd == '\0')) {
-			shellcmd = NULL;
-			shell = options_get_string(s->options, "default-shell");
-			if (!checkshell(shell))
-				shell = _PATH_BSHELL;
-			cmd_append_argv(&argc, &argv, shell);
-		} else
-			args_to_vector(args, &argc, &argv);
-
-		if (args_has(args, 'e') >= 1) {
-			env = environ_create();
-			av = args_first_value(args, 'e');
-			while (av != NULL) {
-				environ_put(env, av->string, 0);
-				av = args_next_value(av);
+			px = 0;
+	} else if (strcmp(xp, "M") == 0 && item->shared->mouse.valid) {
+		if (item->shared->mouse.x > (menu->width + 4) / 2)
+			px = item->shared->mouse.x - (menu->width + 4) / 2;
+		else
+			px = 0;
+	}
+	else if (strcmp(xp, "W") == 0) {
+		if (at == -1)
+			px = 0;
+		else {
+			TAILQ_FOREACH(sr, &c->status.entries[0].ranges, entry) {
+				if (sr->type != STYLE_RANGE_WINDOW)
+					continue;
+				if (sr->argument == (u_int)wl->idx)
+					break;
 			}
+			if (sr != NULL)
+				px = sr->start;
+			else
+				px = 0;
 		}
-	}
+	} else
+		px = strtoul(xp, NULL, 10);
+	if (px + menu->width + 4 >= c->tty.sx)
+		px = c->tty.sx - menu->width - 4;

-	value = args_get(args, 'b');
-	if (args_has(args, 'B'))
-		lines = BOX_LINES_NONE;
-	else if (value != NULL) {
-		oe = options_get(o, "popup-border-lines");
-		lines = options_find_choice(options_table_entry(oe), value,
-		    &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "popup-border-lines %s", cause);
-			goto fail;
-		}
-	}
-
-	if (args_has(args, 'T'))
-		title = format_single_from_target(item, args_get(args, 'T'));
+	yp = args_get(args, 'y');
+	if (yp == NULL)
+		py = 0;
+	else if (strcmp(yp, "P") == 0) {
+		tty_window_offset(&c->tty, &ox, &oy, &sx, &sy);
+		if (wp->yoff + wp->sy >= oy)
+			py = wp->yoff + wp->sy - oy;
+		else
+			py = 0;
+	} else if (strcmp(yp, "M") == 0 && item->shared->mouse.valid)
+		py = item->shared->mouse.y + menu->count + 2;
+	else if (strcmp(yp, "S") == 0) {
+		if (at == -1)
+			py = c->tty.sy;
+		else if (at == 0)
+			py = status_line_size(c) + menu->count + 2;
+		else
+			py = at;
+	} else
+		py = strtoul(yp, NULL, 10);
+	if (py < menu->count + 2)
+		py = 0;
 	else
-		title = xstrdup("");
+		py -= menu->count + 2;
+	if (py + menu->count + 2 >= c->tty.sy)
+		py = c->tty.sy - menu->count - 2;

-	if (args_has(args, 'N') || !modify)
-		flags = 0;
-	if (args_has(args, 'E') > 1) {
-		if (flags == -1)
-			flags = 0;
-		flags |= POPUP_CLOSEEXITZERO;
-	} else if (args_has(args, 'E')) {
-		if (flags == -1)
-			flags = 0;
-		flags |= POPUP_CLOSEEXIT;
-	}
-	if (args_has(args, 'k')) {
-		if (flags == -1)
-			flags = 0;
-		flags |= POPUP_CLOSEANYKEY;
-	}
-
-	if (modify) {
-		popup_modify(tc, title, style, border_style, lines, flags);
-		goto out;
-	}
-	if (popup_display(flags, lines, item, px, py, w, h, env, shellcmd, argc,
-	    argv, cwd, title, tc, s, style, border_style, NULL, NULL) != 0)
-		goto out;
-	environ_free(env);
-	free(cwd);
-	free(title);
-	cmd_free_argv(argc, argv);
+	flags = 0;
+	if (!item->shared->mouse.valid)
+		flags |= MENU_NOMOUSE;
+	if (menu_display(menu, flags, item, px, py, c, fs, NULL, NULL) != 0)
+		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
-
-out:
-	cmd_free_argv(argc, argv);
-	environ_free(env);
-	free(cwd);
-	free(title);
-	return (CMD_RETURN_NORMAL);
-
-fail:
-	free(cause);
-	cmd_free_argv(argc, argv);
-	environ_free(env);
-	free(cwd);
-	free(title);
-	return (CMD_RETURN_ERROR);
 }
--- a/cmd-display-message.c
+++ b/cmd-display-message.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-display-message.c,v 1.66 2026/09/08 08:33:10 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -39,13 +39,13 @@ const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
 	.alias = "display",

-	.args = { "aCc:d:jlINpt:F:v", 0, 1, NULL },
-	.usage = "[-aCIjlNpv] [-c target-client] [-d delay] [-F format] "
+	.args = { "ac:Ipt:F:v", 0, 1 },
+	.usage = "[-aIpv] [-c target-client] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",

-	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+	.target = { 't', CMD_FIND_PANE, 0 },

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG|CMD_CLIENT_CANFAIL,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_message_exec
 };

@@ -60,57 +60,34 @@ cmd_display_message_each(const char *key, const char *value, void *arg)
 static enum cmd_retval
 cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*tc = cmdq_get_target_client(item), *c;
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = target->wp;
+	struct args		*args = self->args;
+	struct client		*c, *target_c;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	const char		*template;
-	char			*msg, *cause = NULL;
-	int			 delay = -1, flags, Nflag = args_has(args, 'N');
-	int			 Cflag = args_has(args, 'C');
+	char			*msg, *cause;
 	struct format_tree	*ft;
-	u_int			 count = args_count(args);
-	struct evbuffer		*evb;
-	struct json_node	*jn;
+	int			 flags;

-	if (args_has(args, 'I') && !args_has(args, 'j')) {
-		if (wp == NULL)
-			return (CMD_RETURN_NORMAL);
-		switch (window_pane_start_input(wp, item, &cause)) {
-		case -1:
+	if (args_has(args, 'I')) {
+		if (window_pane_start_input(wp, item, &cause) != 0) {
 			cmdq_error(item, "%s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
-		case 1:
-			return (CMD_RETURN_NORMAL);
-		case 0:
-			return (CMD_RETURN_WAIT);
 		}
+		return (CMD_RETURN_WAIT);
 	}

-	if (args_has(args, 'F') && count != 0) {
+	if (args_has(args, 'F') && args->argc != 0) {
 		cmdq_error(item, "only one of -F or argument must be given");
 		return (CMD_RETURN_ERROR);
 	}

-	if (args_has(args, 'd')) {
-		delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "delay %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	if (count != 0)
-		template = args_string(args, 0);
-	else
-		template = args_get(args, 'F');
-	if (args_has(args, 'j') && template == NULL)
-		template = "";
-	else if (template == NULL)
+	template = args_get(args, 'F');
+	if (args->argc != 0)
+		template = args->argv[0];
+	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;

 	/*
@@ -119,58 +96,31 @@ cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 	 * formats too, assuming it matches the session. If it doesn't, use the
 	 * best client for the session.
 	 */
-	if (tc != NULL && tc->session == s)
-		c = tc;
-	else if (s != NULL)
-		c = cmd_find_best_client(s);
+	c = cmd_find_client(item, args_get(args, 'c'), 1);
+	if (c != NULL && c->session == s)
+		target_c = c;
 	else
-		c = NULL;
-	if (args_has(args, 'v'))
+		target_c = cmd_find_best_client(s);
+	if (args_has(self->args, 'v'))
 		flags = FORMAT_VERBOSE;
 	else
 		flags = 0;
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, flags);
-	format_defaults(ft, c, s, wl, wp);
+	ft = format_create(item->client, item, FORMAT_NONE, flags);
+	format_defaults(ft, target_c, s, wl, wp);

-	if (args_has(args, 'a') && !args_has(args, 'j')) {
+	if (args_has(args, 'a')) {
 		format_each(ft, cmd_display_message_each, item);
-		format_free(ft);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'l'))
-		msg = xstrdup(template);
-	else
-		msg = format_expand_time(ft, template);
-	if (args_has(args, 'j')) {
-		jn = json_parse(msg, &cause);
-		if (jn == NULL) {
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			free(msg);
-			format_free(ft);
-			return (CMD_RETURN_ERROR);
-		}
-		free(msg);
-		msg = json_to_string(jn);
-		json_destroy_node(jn);
-	}
-
-	if (cmdq_get_client(item) == NULL)
-		cmdq_error(item, "%s", msg);
-	else if (args_has(args, 'p'))
+	msg = format_expand_time(ft, template);
+	if (args_has(self->args, 'p'))
 		cmdq_print(item, "%s", msg);
-	else if (tc != NULL && (tc->flags & CLIENT_CONTROL)) {
-		evb = evbuffer_new();
-		if (evb == NULL)
-			fatalx("out of memory");
-		evbuffer_add_printf(evb, "%%message %s", msg);
-		server_client_print(tc, 0, evb);
-		evbuffer_free(evb);
-	} else if (tc != NULL)
-		status_message_set(tc, delay, 0, Nflag, Cflag, "%s", msg);
+	else if (c != NULL)
+		status_message_set(c, "%s", msg);
 	free(msg);

 	format_free(ft);
+
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-display-panes.c
+++ b/cmd-display-panes.c
@@ -0,0 +1,282 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "tmux.h"
+
+/*
+ * Display panes on a client.
+ */
+
+static enum cmd_retval	cmd_display_panes_exec(struct cmd *,
+			    struct cmdq_item *);
+
+const struct cmd_entry cmd_display_panes_entry = {
+	.name = "display-panes",
+	.alias = "displayp",
+
+	.args = { "bd:t:", 0, 1 },
+	.usage = "[-b] [-d duration] " CMD_TARGET_CLIENT_USAGE " [template]",
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_display_panes_exec
+};
+
+struct cmd_display_panes_data {
+	struct cmdq_item	*item;
+	char			*command;
+};
+
+static void
+cmd_display_panes_draw_pane(struct screen_redraw_ctx *ctx,
+    struct window_pane *wp)
+{
+	struct client		*c = ctx->c;
+	struct tty		*tty = &c->tty;
+	struct session		*s = c->session;
+	struct options		*oo = s->options;
+	struct window		*w = wp->window;
+	struct grid_cell	 gc;
+	u_int			 idx, px, py, i, j, xoff, yoff, sx, sy;
+	int			 colour, active_colour;
+	char			 buf[16], *ptr;
+	size_t			 len;
+
+	if (wp->xoff + wp->sx <= ctx->ox ||
+	    wp->xoff >= ctx->ox + ctx->sx ||
+	    wp->yoff + wp->sy <= ctx->oy ||
+	    wp->yoff >= ctx->oy + ctx->sy)
+		return;
+
+	if (wp->xoff >= ctx->ox && wp->xoff + wp->sx <= ctx->ox + ctx->sx) {
+		/* All visible. */
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx;
+	} else if (wp->xoff < ctx->ox &&
+	    wp->xoff + wp->sx > ctx->ox + ctx->sx) {
+		/* Both left and right not visible. */
+		xoff = 0;
+		sx = ctx->sx;
+	} else if (wp->xoff < ctx->ox) {
+		/* Left not visible. */
+		xoff = 0;
+		sx = wp->sx - (ctx->ox - wp->xoff);
+	} else {
+		/* Right not visible. */
+		xoff = wp->xoff - ctx->ox;
+		sx = wp->sx - xoff;
+	}
+	if (wp->yoff >= ctx->oy && wp->yoff + wp->sy <= ctx->oy + ctx->sy) {
+		/* All visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy;
+	} else if (wp->yoff < ctx->oy &&
+	    wp->yoff + wp->sy > ctx->oy + ctx->sy) {
+		/* Both top and bottom not visible. */
+		yoff = 0;
+		sy = ctx->sy;
+	} else if (wp->yoff < ctx->oy) {
+		/* Top not visible. */
+		yoff = 0;
+		sy = wp->sy - (ctx->oy - wp->yoff);
+	} else {
+		/* Bottom not visible. */
+		yoff = wp->yoff - ctx->oy;
+		sy = wp->sy - yoff;
+	}
+
+	if (ctx->statustop)
+		yoff += ctx->statuslines;
+	px = sx / 2;
+	py = sy / 2;
+
+	if (window_pane_index(wp, &idx) != 0)
+		fatalx("index not found");
+	len = xsnprintf(buf, sizeof buf, "%u", idx);
+
+	if (sx < len)
+		return;
+	colour = options_get_number(oo, "display-panes-colour");
+	active_colour = options_get_number(oo, "display-panes-active-colour");
+
+	if (sx < len * 6 || sy < 5) {
+		tty_cursor(tty, xoff + px - len / 2, yoff + py);
+		goto draw_text;
+	}
+
+	px -= len * 3;
+	py -= 2;
+
+	memcpy(&gc, &grid_default_cell, sizeof gc);
+	if (w->active == wp)
+		gc.bg = active_colour;
+	else
+		gc.bg = colour;
+	gc.flags |= GRID_FLAG_NOPALETTE;
+
+	tty_attributes(tty, &gc, wp);
+	for (ptr = buf; *ptr != '\0'; ptr++) {
+		if (*ptr < '0' || *ptr > '9')
+			continue;
+		idx = *ptr - '0';
+
+		for (j = 0; j < 5; j++) {
+			for (i = px; i < px + 5; i++) {
+				tty_cursor(tty, xoff + i, yoff + py + j);
+				if (window_clock_table[idx][j][i - px])
+					tty_putc(tty, ' ');
+			}
+		}
+		px += 6;
+	}
+
+	len = xsnprintf(buf, sizeof buf, "%ux%u", wp->sx, wp->sy);
+	if (sx < len || sy < 6)
+		return;
+	tty_cursor(tty, xoff + sx - len, yoff);
+
+draw_text:
+	memcpy(&gc, &grid_default_cell, sizeof gc);
+	if (w->active == wp)
+		gc.fg = active_colour;
+	else
+		gc.fg = colour;
+	gc.flags |= GRID_FLAG_NOPALETTE;
+
+	tty_attributes(tty, &gc, wp);
+	tty_puts(tty, buf);
+
+	tty_cursor(tty, 0, 0);
+}
+
+static void
+cmd_display_panes_draw(struct client *c, struct screen_redraw_ctx *ctx)
+{
+	struct window		*w = c->session->curw->window;
+	struct window_pane	*wp;
+
+	log_debug("%s: %s @%u", __func__, c->name, w->id);
+
+	TAILQ_FOREACH(wp, &w->panes, entry) {
+		if (window_pane_visible(wp))
+			cmd_display_panes_draw_pane(ctx, wp);
+	}
+}
+
+static void
+cmd_display_panes_free(struct client *c)
+{
+	struct cmd_display_panes_data	*cdata = c->overlay_data;
+
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
+	free(cdata->command);
+	free(cdata);
+}
+
+static int
+cmd_display_panes_key(struct client *c, struct key_event *event)
+{
+	struct cmd_display_panes_data	*cdata = c->overlay_data;
+	struct cmdq_item		*new_item;
+	char				*cmd, *expanded;
+	struct window			*w = c->session->curw->window;
+	struct window_pane		*wp;
+	struct cmd_parse_result		*pr;
+
+	if (event->key < '0' || event->key > '9')
+		return (-1);
+
+	wp = window_pane_at_index(w, event->key - '0');
+	if (wp == NULL)
+		return (1);
+	window_unzoom(w);
+
+	xasprintf(&expanded, "%%%u", wp->id);
+	cmd = cmd_template_replace(cdata->command, expanded, 1);
+
+	pr = cmd_parse_from_string(cmd, NULL);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		new_item = NULL;
+		break;
+	case CMD_PARSE_ERROR:
+		new_item = cmdq_get_error(pr->error);
+		free(pr->error);
+		cmdq_append(c, new_item);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, NULL, 0);
+		cmd_list_free(pr->cmdlist);
+		cmdq_append(c, new_item);
+		break;
+	}
+
+	free(cmd);
+	free(expanded);
+	return (1);
+}
+
+static enum cmd_retval
+cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
+{
+	struct args			*args = self->args;
+	struct client			*c;
+	struct session			*s;
+	u_int		 		 delay;
+	char				*cause;
+	struct cmd_display_panes_data	*cdata;
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+	s = c->session;
+
+	if (c->overlay_draw != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	if (args_has(args, 'd')) {
+		delay = args_strtonum(args, 'd', 0, UINT_MAX, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "delay %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+	} else
+		delay = options_get_number(s->options, "display-panes-time");
+
+	cdata = xmalloc(sizeof *cdata);
+	if (args->argc != 0)
+		cdata->command = xstrdup(args->argv[0]);
+	else
+		cdata->command = xstrdup("select-pane -t '%%'");
+	if (args_has(args, 'b'))
+		cdata->item = NULL;
+	else
+		cdata->item = item;
+
+	server_client_set_overlay(c, delay, cmd_display_panes_draw,
+	    cmd_display_panes_key, cmd_display_panes_free, cdata);
+
+	if (args_has(args, 'b'))
+		return (CMD_RETURN_NORMAL);
+	return (CMD_RETURN_WAIT);
+}
--- a/cmd-find-window.c
+++ b/cmd-find-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-find-window.c,v 1.57 2026/07/14 17:17:17 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -32,8 +32,8 @@ const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",

-	.args = { "CiNrt:TZ", 1, 1, NULL },
-	.usage = "[-CiNrTZ] " CMD_TARGET_PANE_USAGE " match-string",
+	.args = { "CNrt:TZ", 1, 1 },
+	.usage = "[-CNrTZ] " CMD_TARGET_PANE_USAGE " match-string",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -44,74 +44,82 @@ const struct cmd_entry cmd_find_window_entry = {
 static enum cmd_retval
 cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self), *new_args;
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct window_pane	*wp = target->wp;
-	const char		*s = args_string(args, 0), *suffix = "";
-	const char		*star = "*";
-	struct args_value	*filter;
+	struct args		*args = self->args, *new_args;
+	struct window_pane	*wp = item->target.wp;
+	const char		*s = args->argv[0];
+	char			*filter, *argv = { NULL };
 	int			 C, N, T;

 	C = args_has(args, 'C');
 	N = args_has(args, 'N');
 	T = args_has(args, 'T');

-	if (args_has(args, 'r'))
-		star = "";
-	if (args_has(args, 'r') && args_has(args, 'i'))
-		suffix = "/ri";
-	else if (args_has(args, 'r'))
-		suffix = "/r";
-	else if (args_has(args, 'i'))
-		suffix = "/i";
-
 	if (!C && !N && !T)
 		C = N = T = 1;

-	filter = xcalloc(1, sizeof *filter);
-	filter->type = ARGS_STRING;
-
-	if (C && N && T) {
-		xasprintf(&filter->string,
-		    "#{||:"
-		    "#{C%s:%s},#{||:#{m%s:%s%s%s,#{window_name}},"
-		    "#{m%s:%s%s%s,#{pane_title}}}}",
-		    suffix, s, suffix, star, s, star, suffix, star, s, star);
-	} else if (C && N) {
-		xasprintf(&filter->string,
-		    "#{||:#{C%s:%s},#{m%s:%s%s%s,#{window_name}}}",
-		    suffix, s, suffix, star, s, star);
-	} else if (C && T) {
-		xasprintf(&filter->string,
-		    "#{||:#{C%s:%s},#{m%s:%s%s%s,#{pane_title}}}",
-		    suffix, s, suffix, star, s, star);
-	} else if (N && T) {
-		xasprintf(&filter->string,
-		    "#{||:#{m%s:%s%s%s,#{window_name}},"
-		    "#{m%s:%s%s%s,#{pane_title}}}",
-		    suffix, star, s, star, suffix, star, s, star);
-	} else if (C) {
-		xasprintf(&filter->string,
-		    "#{C%s:%s}",
-		    suffix, s);
-	} else if (N) {
-		xasprintf(&filter->string,
-		    "#{m%s:%s%s%s,#{window_name}}",
-		    suffix, star, s, star);
+	if (!args_has(args, 'r')) {
+		if (C && N && T) {
+			xasprintf(&filter,
+			    "#{||:"
+			    "#{C:%s},#{||:#{m:*%s*,#{window_name}},"
+			    "#{m:*%s*,#{pane_title}}}}",
+			    s, s, s);
+		} else if (C && N) {
+			xasprintf(&filter,
+			    "#{||:#{C:%s},#{m:*%s*,#{window_name}}}",
+			    s, s);
+		} else if (C && T) {
+			xasprintf(&filter,
+			    "#{||:#{C:%s},#{m:*%s*,#{pane_title}}}",
+			    s, s);
+		} else if (N && T) {
+			xasprintf(&filter,
+			    "#{||:#{m:*%s*,#{window_name}},"
+			    "#{m:*%s*,#{pane_title}}}",
+			    s, s);
+		} else if (C)
+			xasprintf(&filter, "#{C:%s}", s);
+		else if (N)
+			xasprintf(&filter, "#{m:*%s*,#{window_name}}", s);
+		else
+			xasprintf(&filter, "#{m:*%s*,#{pane_title}}", s);
 	} else {
-		xasprintf(&filter->string,
-		    "#{m%s:%s%s%s,#{pane_title}}",
-		    suffix, star, s, star);
+		if (C && N && T) {
+			xasprintf(&filter,
+			    "#{||:"
+			    "#{C/r:%s},#{||:#{m/r:%s,#{window_name}},"
+			    "#{m/r:%s,#{pane_title}}}}",
+			    s, s, s);
+		} else if (C && N) {
+			xasprintf(&filter,
+			    "#{||:#{C/r:%s},#{m/r:%s,#{window_name}}}",
+			    s, s);
+		} else if (C && T) {
+			xasprintf(&filter,
+			    "#{||:#{C/r:%s},#{m/r:%s,#{pane_title}}}",
+			    s, s);
+		} else if (N && T) {
+			xasprintf(&filter,
+			    "#{||:#{m/r:%s,#{window_name}},"
+			    "#{m/r:%s,#{pane_title}}}",
+			    s, s);
+		} else if (C)
+			xasprintf(&filter, "#{C/r:%s}", s);
+		else if (N)
+			xasprintf(&filter, "#{m/r:%s,#{window_name}}", s);
+		else
+			xasprintf(&filter, "#{m/r:%s,#{pane_title}}", s);
 	}

-	new_args = args_create();
+	new_args = args_parse("", 1, &argv);
 	if (args_has(args, 'Z'))
-		args_set(new_args, 'Z', NULL, 0);
-	args_set(new_args, 'f', filter, 0);
+		args_set(new_args, 'Z', NULL);
+	args_set(new_args, 'f', filter);
+
+	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);

-	window_pane_set_mode(wp, NULL, &window_tree_mode, item, target,
-	    new_args);
 	args_free(new_args);
+	free(filter);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-find.c
+++ b/cmd-find.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-find.c,v 1.88 2026/09/07 12:05:12 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2015 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -147,18 +147,6 @@ cmd_find_session_better(struct session *s, struct session *than, int flags)
 	return (timercmp(&s->activity_time, &than->activity_time, >));
 }

-/* Can this session be usefully targeted? */
-static int
-cmd_find_session_valid(struct session *s)
-{
-	if (!session_alive(s) ||
-	    s->curw == NULL ||
-	    s->curw->window == NULL ||
-	    s->curw->window->active == NULL)
-		return (0);
-	return (1);
-}
-
 /* Find best session from a list, or all if list is NULL. */
 static struct session *
 cmd_find_best_session(struct session **slist, u_int ssize, int flags)
@@ -171,15 +159,11 @@ cmd_find_best_session(struct session **slist, u_int ssize, int flags)
 	s = NULL;
 	if (slist != NULL) {
 		for (i = 0; i < ssize; i++) {
-			if (!cmd_find_session_valid(slist[i]))
-				continue;
 			if (cmd_find_session_better(slist[i], s, flags))
 				s = slist[i];
 		}
 	} else {
 		RB_FOREACH(s_loop, sessions, &sessions) {
-			if (!cmd_find_session_valid(s_loop))
-				continue;
 			if (cmd_find_session_better(s_loop, s, flags))
 				s = s_loop;
 		}
@@ -388,11 +372,9 @@ cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)

 	/* Try as an offset. */
 	if (!exact && (window[0] == '+' || window[0] == '-')) {
-		if (window[1] != '\0') {
-			n = strtonum(window + 1, 1, INT_MAX, &errstr);
-			if (errstr != NULL)
-				return (-1);
-		} else
+		if (window[1] != '\0')
+			n = strtonum(window + 1, 1, INT_MAX, NULL);
+		else
 			n = 1;
 		s = fs->s;
 		if (fs->flags & CMD_FIND_WINDOW_INDEX) {
@@ -600,7 +582,7 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)

 	/* Try special characters. */
 	if (strcmp(pane, "!") == 0) {
-		fs->wp = TAILQ_FIRST(&fs->w->last_panes);
+		fs->wp = fs->w->last;
 		if (fs->wp == NULL)
 			return (-1);
 		return (0);
@@ -628,11 +610,9 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)

 	/* Try as an offset. */
 	if (pane[0] == '+' || pane[0] == '-') {
-		if (pane[1] != '\0') {
-			n = strtonum(pane + 1, 1, INT_MAX, &errstr);
-			if (errstr != NULL)
-				return (-1);
-		} else
+		if (pane[1] != '\0')
+			n = strtonum(pane + 1, 1, INT_MAX, NULL);
+		else
 			n = 1;
 		wp = fs->w->active;
 		if (pane[0] == '+')
@@ -886,18 +866,7 @@ cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)

 	/* If this is an attached client, all done. */
 	if (c->session != NULL) {
-		cmd_find_clear_state(fs, flags);
-
-		fs->wp = c->session->curw->window->active;
-		if (fs->wp == NULL) {
-			cmd_find_from_session(fs, c->session, flags);
-			return (0);
-		}
-		fs->s = c->session;
-		fs->wl = fs->s->curw;
-		fs->w = fs->wl->window;
-
-		cmd_find_log_state(__func__, fs);
+		cmd_find_from_session(fs, c->session, flags);
 		return (0);
 	}
 	cmd_find_clear_state(fs, flags);
@@ -944,7 +913,6 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
    const char *target, enum cmd_find_type type, int flags)
 {
 	struct mouse_event	*m;
-	struct client		*c;
 	struct cmd_find_state	 current;
 	char			*colon, *period, *copy = NULL, tmp[256];
 	const char		*session, *window, *pane, *s;
@@ -992,11 +960,10 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 	if (server_check_marked() && (flags & CMD_FIND_DEFAULT_MARKED)) {
 		fs->current = &marked_pane;
 		log_debug("%s: current is marked pane", __func__);
-	} else if (cmd_find_valid_state(cmdq_get_current(item))) {
-		fs->current = cmdq_get_current(item);
+	} else if (cmd_find_valid_state(&item->shared->current)) {
+		fs->current = &item->shared->current;
 		log_debug("%s: current is from queue", __func__);
-	} else if (cmd_find_from_client(&current, cmdq_get_client(item),
-	    flags) == 0) {
+	} else if (cmd_find_from_client(&current, item->client, flags) == 0) {
 		fs->current = &current;
 		log_debug("%s: current is from client", __func__);
 	} else {
@@ -1011,23 +978,9 @@ cmd_find_target(struct cmd_find_state *fs, struct cmdq_item *item,
 	if (target == NULL || *target == '\0')
 		goto current;

-	if (strcmp(target, "@") == 0 ||
-	    strcmp(target, "{active}") == 0 ||
-	    strcmp(target, "{current}") == 0) {
-		c = cmdq_get_client(item);
-		if (c == NULL || c->session == NULL) {
-			cmdq_error(item, "no current client");
-			goto error;
-		}
-		fs->wl = c->session->curw;
-		fs->wp = c->session->curw->window->active;
-		fs->w = c->session->curw->window;
-		goto found;
-	}
-
 	/* Mouse target is a plain = or {mouse}. */
 	if (strcmp(target, "=") == 0 || strcmp(target, "{mouse}") == 0) {
-		m = &cmdq_get_event(item)->m;
+		m = &item->shared->mouse;
 		switch (type) {
 		case CMD_FIND_PANE:
 			fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);
@@ -1277,31 +1230,29 @@ no_pane:
 static struct client *
 cmd_find_current_client(struct cmdq_item *item, int quiet)
 {
-	struct client		*c = NULL, *found;
+	struct client		*c;
 	struct session		*s;
 	struct window_pane	*wp;
 	struct cmd_find_state	 fs;

-	if (item != NULL)
-		c = cmdq_get_client(item);
-	if (c != NULL && c->session != NULL)
-		return (c);
+	if (item->client != NULL && item->client->session != NULL)
+		return (item->client);

-	found = NULL;
-	if (c != NULL && (wp = cmd_find_inside_pane(c)) != NULL) {
+	c = NULL;
+	if ((wp = cmd_find_inside_pane(item->client)) != NULL) {
 		cmd_find_clear_state(&fs, CMD_FIND_QUIET);
 		fs.w = wp->window;
 		if (cmd_find_best_session_with_window(&fs) == 0)
-			found = cmd_find_best_client(fs.s);
+			c = cmd_find_best_client(fs.s);
 	} else {
 		s = cmd_find_best_session(NULL, 0, CMD_FIND_QUIET);
 		if (s != NULL)
-			found = cmd_find_best_client(s);
+			c = cmd_find_best_client(s);
 	}
-	if (found == NULL && item != NULL && !quiet)
+	if (c == NULL && !quiet)
 		cmdq_error(item, "no current client");
-	log_debug("%s: no target, return %p", __func__, found);
-	return (found);
+	log_debug("%s: no target, return %p", __func__, c);
+	return (c);
 }

 /* Find the target client or report an error and return NULL. */
--- a/cmd-if-shell.c
+++ b/cmd-if-shell.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-if-shell.c,v 1.87 2026/08/25 06:04:33 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -20,7 +20,6 @@
 #include <sys/types.h>
 #include <sys/wait.h>

-#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>

@@ -30,19 +29,16 @@
 * Executes a tmux command if a shell command returns true or false.
 */

-static enum args_parse_type	cmd_if_shell_args_parse(struct args *, u_int,
-				    char **);
-static enum cmd_retval		cmd_if_shell_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_if_shell_exec(struct cmd *, struct cmdq_item *);

-static void	cmd_if_shell_callback(struct job *);
-static void	cmd_if_shell_free(void *);
+static void		cmd_if_shell_callback(struct job *);
+static void		cmd_if_shell_free(void *);

 const struct cmd_entry cmd_if_shell_entry = {
 	.name = "if-shell",
 	.alias = "if",

-	.args = { "bFt:", 2, 3, cmd_if_shell_args_parse },
+	.args = { "bFt:", 2, 3 },
 	.usage = "[-bF] " CMD_TARGET_PANE_USAGE " shell-command command "
 		 "[command]",

@@ -53,84 +49,110 @@ const struct cmd_entry cmd_if_shell_entry = {
 };

 struct cmd_if_shell_data {
-	struct args_command_state	*cmd_if;
-	struct args_command_state	*cmd_else;
+	struct cmd_parse_input	 input;

-	struct client			*client;
-	struct cmdq_item		*item;
+	char			*cmd_if;
+	char			*cmd_else;
+
+	struct client		*client;
+	struct cmdq_item	*item;
+	struct mouse_event	 mouse;
 };

-static enum args_parse_type
-cmd_if_shell_args_parse(__unused struct args *args, u_int idx,
-    __unused char **cause)
-{
-	if (idx == 1 || idx == 2)
-		return (ARGS_PARSE_COMMANDS_OR_STRING);
-	return (ARGS_PARSE_STRING);
-}
-
 static enum cmd_retval
 cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct args			*args = self->args;
+	struct mouse_event		*m = &item->shared->mouse;
 	struct cmd_if_shell_data	*cdata;
+	char				*shellcmd, *cmd;
 	struct cmdq_item		*new_item;
-	char				*shellcmd;
-	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s = target->s;
-	struct cmd_list			*cmdlist;
-	u_int				 count = args_count(args);
-	int				 wait = !args_has(args, 'b');
+	struct cmd_find_state		*fs = &item->target;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = fs->s;
+	struct winlink			*wl = fs->wl;
+	struct window_pane		*wp = fs->wp;
+	struct cmd_parse_input		 pi;
+	struct cmd_parse_result		*pr;

-	shellcmd = format_single_from_target(item, args_string(args, 0));
+	shellcmd = format_single(item, args->argv[0], c, s, wl, wp);
 	if (args_has(args, 'F')) {
 		if (*shellcmd != '0' && *shellcmd != '\0')
-			cmdlist = args_make_commands_now(self, item, 1, 0);
-		else if (count == 3)
-			cmdlist = args_make_commands_now(self, item, 2, 0);
-		else {
-			free(shellcmd);
-			return (CMD_RETURN_NORMAL);
-		}
+			cmd = args->argv[1];
+		else if (args->argc == 3)
+			cmd = args->argv[2];
+		else
+			cmd = NULL;
 		free(shellcmd);
-		if (cmdlist == NULL)
+		if (cmd == NULL)
+			return (CMD_RETURN_NORMAL);
+
+		memset(&pi, 0, sizeof pi);
+		if (self->file != NULL)
+			pi.file = self->file;
+		pi.line = self->line;
+		pi.item = item;
+		pi.c = c;
+		cmd_find_copy_state(&pi.fs, fs);
+
+		pr = cmd_parse_from_string(cmd, &pi);
+		switch (pr->status) {
+		case CMD_PARSE_EMPTY:
+			break;
+		case CMD_PARSE_ERROR:
+			cmdq_error(item, "%s", pr->error);
+			free(pr->error);
 			return (CMD_RETURN_ERROR);
-		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
-		cmdq_insert_after(item, new_item);
-		cmd_list_free(cmdlist);
+		case CMD_PARSE_SUCCESS:
+			new_item = cmdq_get_command(pr->cmdlist, fs, m, 0);
+			cmdq_insert_after(item, new_item);
+			cmd_list_free(pr->cmdlist);
+			break;
+		}
 		return (CMD_RETURN_NORMAL);
 	}

 	cdata = xcalloc(1, sizeof *cdata);

-	cdata->cmd_if = args_make_commands_prepare(self, item, 1, NULL, wait,
-	    0);
-	if (count == 3) {
-		cdata->cmd_else = args_make_commands_prepare(self, item, 2,
-		    NULL, wait, 0);
-	}
+	cdata->cmd_if = xstrdup(args->argv[1]);
+	if (args->argc == 3)
+		cdata->cmd_else = xstrdup(args->argv[2]);
+	else
+		cdata->cmd_else = NULL;
+	memcpy(&cdata->mouse, m, sizeof cdata->mouse);

-	if (wait) {
-		cdata->client = cmdq_get_client(item);
-		cdata->item = item;
-	} else
-		cdata->client = tc;
+	if (!args_has(args, 'b'))
+		cdata->client = item->client;
+	else
+		cdata->client = c;
 	if (cdata->client != NULL)
 		cdata->client->references++;

-	if (job_run(shellcmd, 0, NULL, NULL, s,
-	    server_client_get_cwd(cmdq_get_client(item), s), NULL,
-	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0, -1,
-	    -1) == NULL) {
+	if (!args_has(args, 'b'))
+		cdata->item = item;
+	else
+		cdata->item = NULL;
+
+	memset(&cdata->input, 0, sizeof cdata->input);
+	if (self->file != NULL)
+		cdata->input.file = xstrdup(self->file);
+	cdata->input.line = self->line;
+	cdata->input.item = cdata->item;
+	cdata->input.c = c;
+	if (cdata->input.c != NULL)
+		cdata->input.c->references++;
+	cmd_find_copy_state(&cdata->input.fs, fs);
+
+	if (job_run(shellcmd, s, server_client_get_cwd(item->client, s), NULL,
+	    cmd_if_shell_callback, cmd_if_shell_free, cdata, 0) == NULL) {
 		cmdq_error(item, "failed to run command: %s", shellcmd);
 		free(shellcmd);
-		cmd_if_shell_free(cdata);
+		free(cdata);
 		return (CMD_RETURN_ERROR);
 	}
 	free(shellcmd);

-	if (!wait)
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }
@@ -140,36 +162,39 @@ cmd_if_shell_callback(struct job *job)
 {
 	struct cmd_if_shell_data	*cdata = job_get_data(job);
 	struct client			*c = cdata->client;
-	struct cmdq_item		*item = cdata->item, *new_item;
-	struct args_command_state	*state;
-	struct cmd_list			*cmdlist;
-	char				*error;
+	struct mouse_event		*m = &cdata->mouse;
+	struct cmdq_item		*new_item = NULL;
+	char				*cmd;
 	int				 status;
+	struct cmd_parse_result		*pr;

 	status = job_get_status(job);
 	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
-		state = cdata->cmd_else;
+		cmd = cdata->cmd_else;
 	else
-		state = cdata->cmd_if;
-	if (state == NULL)
+		cmd = cdata->cmd_if;
+	if (cmd == NULL)
 		goto out;

-	cmdlist = args_make_commands(state, 0, NULL, &error);
-	if (cmdlist == NULL) {
-		if (cdata->item == NULL) {
-			*error = toupper((u_char)*error);
-			status_message_set(c, -1, 1, 0, 0, "%s", error);
-		} else
-			cmdq_error(cdata->item, "%s", error);
-		free(error);
-	} else if (item == NULL) {
-		new_item = cmdq_get_command(cmdlist, NULL);
-		cmdq_append(c, new_item);
-		cmd_list_free(cmdlist);
-	} else {
-		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
-		cmdq_insert_after(item, new_item);
-		cmd_list_free(cmdlist);
+	pr = cmd_parse_from_string(cmd, &cdata->input);
+	switch (pr->status) {
+	case CMD_PARSE_EMPTY:
+		break;
+	case CMD_PARSE_ERROR:
+		if (cdata->item != NULL)
+		       cmdq_error(cdata->item, "%s", pr->error);
+		free(pr->error);
+		break;
+	case CMD_PARSE_SUCCESS:
+		new_item = cmdq_get_command(pr->cmdlist, NULL, m, 0);
+		cmd_list_free(pr->cmdlist);
+		break;
+	}
+	if (new_item != NULL) {
+		if (cdata->item == NULL)
+			cmdq_append(c, new_item);
+		else
+			cmdq_insert_after(cdata->item, new_item);
 	}

 out:
@@ -185,9 +210,12 @@ cmd_if_shell_free(void *data)
 	if (cdata->client != NULL)
 		server_client_unref(cdata->client);

-	if (cdata->cmd_else != NULL)
-		args_make_commands_free(cdata->cmd_else);
-	args_make_commands_free(cdata->cmd_if);
+	free(cdata->cmd_else);
+	free(cdata->cmd_if);
+
+	if (cdata->input.c != NULL)
+		server_client_unref(cdata->input.c);
+	free((void *)cdata->input.file);

 	free(cdata);
 }
--- a/cmd-join-pane.c
+++ b/cmd-join-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-join-pane.c,v 1.74 2026/08/03 20:29:52 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2011 George Nachman <tmux@georgester.com>
@@ -30,15 +30,12 @@
 */

 static enum cmd_retval	cmd_join_pane_exec(struct cmd *, struct cmdq_item *);
-static enum cmd_retval	cmd_join_pane_mouse_update(struct cmdq_item *);
-static void		cmd_join_pane_mouse_move(struct client *,
-			    struct mouse_event *);

 const struct cmd_entry cmd_join_pane_entry = {
 	.name = "join-pane",
 	.alias = "joinp",

-	.args = { "bdfhvp:l:s:t:", 0, 0, NULL },
+	.args = { "bdfhvp:l:s:t:", 0, 0 },
 	.usage = "[-bdfhv] [-l size] " CMD_SRCDST_PANE_USAGE,

 	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
@@ -52,10 +49,8 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.name = "move-pane",
 	.alias = "movep",

-	.args = { "bdD::fhMvl:L::P:R::s:t:U::X:Y:z:", 0, 0, NULL },
-	.usage = "[-bdfhMv] [-D lines] [-l size] [-L columns] [-P position] "
-	         "[-R columns] " CMD_SRCDST_PANE_USAGE " [-U lines] "
-	         "[-X x-position] [-Y y-position] [-z z-index]",
+	.args = { "bdhvp:l:s:t:", 0, 0 },
+	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,

 	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -64,454 +59,112 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.exec = cmd_join_pane_exec
 };

-static enum cmd_retval
-cmd_join_pane_place(struct cmdq_item *item, struct winlink *wl,
-    struct window_pane *wp, const char *position)
-{
-	struct window		*w = wl->window;
-	struct layout_cell	*lc = wp->layout_cell;
-	struct window_pane	*owp;
-	int			 wx = w->sx, wy = w->sy;
-	int			 px = lc->g.sx, py = lc->g.sy;
-	int			 xoff = lc->g.xoff, yoff = lc->g.yoff;
-	int			 border = 1;
-
-	if (window_pane_get_pane_lines(wp) == PANE_LINES_NONE)
-		border = 0;
-
-	if (strcmp(position, "top-left") == 0) {
-		xoff = border;
-		yoff = border;
-	} else if (strcmp(position, "top-centre") == 0 ||
-	    strcmp(position, "top-center") == 0) {
-		xoff = (wx - px) / 2;
-		yoff = border;
-	} else if (strcmp(position, "top-right") == 0) {
-		xoff = wx - px - border;
-		yoff = border;
-	} else if (strcmp(position, "centre-left") == 0 ||
-	    strcmp(position, "center-left") == 0) {
-		xoff = border;
-		yoff = (wy - py) / 2;
-	} else if (strcmp(position, "centre") == 0 ||
-	    strcmp(position, "center") == 0) {
-		xoff = (wx - px) / 2;
-		yoff = (wy - py) / 2;
-	} else if (strcmp(position, "centre-right") == 0 ||
-	    strcmp(position, "center-right") == 0) {
-		xoff = wx - px - border;
-		yoff = (wy - py) / 2;
-	} else if (strcmp(position, "bottom-left") == 0) {
-		xoff = border;
-		yoff = wy - py - border;
-	} else if (strcmp(position, "bottom-centre") == 0 ||
-	    strcmp(position, "bottom-center") == 0) {
-		xoff = (wx - px) / 2;
-		yoff = wy - py - border;
-	} else if (strcmp(position, "bottom-right") == 0) {
-		xoff = wx - px - border;
-		yoff = wy - py - border;
-	} else if (strcmp(position, "top-left-centre") == 0 ||
-	    strcmp(position, "top-left-center") == 0) {
-		xoff = wx / 4 - px / 2;
-		yoff = wy / 4 - py / 2;
-	} else if (strcmp(position, "top-right-centre") == 0 ||
-	    strcmp(position, "top-right-center") == 0) {
-		xoff = (3 * wx) / 4 - px / 2;
-		yoff = wy / 4 - py / 2;
-	} else if (strcmp(position, "bottom-left-centre") == 0 ||
-	    strcmp(position, "bottom-left-center") == 0) {
-		xoff = wx / 4 - px / 2;
-		yoff = (3 * wy) / 4 - py / 2;
-	} else if (strcmp(position, "bottom-right-centre") == 0 ||
-	    strcmp(position, "bottom-right-center") == 0) {
-		xoff = (3 * wx) / 4 - px / 2;
-		yoff = (3 * wy) / 4 - py / 2;
-	} else if (strcmp(position, "front") == 0) {
-		TAILQ_REMOVE(&w->z_index, wp, zentry);
-		TAILQ_INSERT_HEAD(&w->z_index, wp, zentry);
-	} else if (strcmp(position, "back") == 0) {
-		TAILQ_REMOVE(&w->z_index, wp, zentry);
-		TAILQ_FOREACH(owp, &w->z_index, zentry) {
-			if (!window_pane_is_floating(owp))
-				break;
-		}
-		if (owp != NULL)
-			TAILQ_INSERT_BEFORE(owp, wp, zentry);
-		else
-			TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
-	} else if (strcmp(position, "forward") == 0) {
-		owp = TAILQ_PREV(wp, window_panes_zindex, zentry);
-		if (owp != NULL) {
-			TAILQ_REMOVE(&w->z_index, wp, zentry);
-			TAILQ_INSERT_BEFORE(owp, wp, zentry);
-		}
-	} else if (strcmp(position, "backward") == 0) {
-		owp = TAILQ_NEXT(wp, zentry);
-		if (owp != NULL && window_pane_is_floating(owp)) {
-			TAILQ_REMOVE(&w->z_index, wp, zentry);
-			TAILQ_INSERT_AFTER(&w->z_index, owp, wp, zentry);
-		}
-	} else if (strcmp(position, "forward-loop") == 0) {
-		owp = TAILQ_PREV(wp, window_panes_zindex, zentry);
-		TAILQ_REMOVE(&w->z_index, wp, zentry);
-		if (owp != NULL)
-			TAILQ_INSERT_BEFORE(owp, wp, zentry);
-		else {
-			TAILQ_FOREACH(owp, &w->z_index, zentry) {
-				if (!window_pane_is_floating(owp))
-					break;
-			}
-			if (owp != NULL)
-				TAILQ_INSERT_BEFORE(owp, wp, zentry);
-			else
-				TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
-		}
-	} else if (strcmp(position, "backward-loop") == 0) {
-		owp = TAILQ_NEXT(wp, zentry);
-		if (owp != NULL && window_pane_is_floating(owp)) {
-			TAILQ_REMOVE(&w->z_index, wp, zentry);
-			TAILQ_INSERT_AFTER(&w->z_index, owp, wp, zentry);
-		} else {
-			TAILQ_REMOVE(&w->z_index, wp, zentry);
-			TAILQ_INSERT_HEAD(&w->z_index, wp, zentry);
-		}
-	} else {
-		cmdq_error(item, "unknown position: %s", position);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (xoff != lc->g.xoff || yoff != lc->g.yoff) {
-		lc->g.xoff = xoff;
-		lc->g.yoff = yoff;
-		layout_fix_panes(w, NULL);
-	}
-	redraw_invalidate_scene(w);
-	events_fire_window("window-layout-changed", w);
-	server_redraw_window(w);
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_join_pane_move(struct cmdq_item *item, struct args *args,
-    struct winlink *wl, struct window_pane *wp)
-{
-	struct window		*w = wl->window;
-	struct layout_cell	*lc = wp->layout_cell;
-	const char		*errstr, *argval;
-	const char		 flags[] = { 'U', 'D', 'L', 'R' };
-	char			*cause = NULL, flag;
-	int			 xoff = lc->g.xoff, yoff = lc->g.yoff, adjust;
-	u_int			 i;
-	enum pane_lines		 lines = window_pane_get_pane_lines(wp);
-
-	if (args_has(args, 'X')) {
-		xoff = args_percentage_and_expand(args, 'X', -(int)w->sx,
-		    w->sx, w->sx, item, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "position %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		if (lines != PANE_LINES_NONE)
-			xoff += 1;
-	}
-	if (args_has(args, 'Y')) {
-		yoff = args_percentage_and_expand(args, 'Y', -(int)w->sy,
-		    w->sy, w->sy, item, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "position %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		if (lines != PANE_LINES_NONE)
-			yoff += 1;
-	}
-
-	for (i = 0; i < nitems(flags); i++) {
-		flag = flags[i];
-		if (!args_has(args, flag))
-			continue;
-
-		argval = args_get(args, flag);
-		if (argval == NULL)
-			argval = "1";
-		adjust = strtonum(argval, INT_MIN, INT_MAX, &errstr);
-		if (errstr != NULL) {
-			cmdq_error(item, "offset %s", errstr);
-			return (CMD_RETURN_ERROR);
-		}
-
-		if (flag == 'U')
-			yoff -= adjust;
-		else if (flag == 'D')
-			yoff += adjust;
-		else if (flag == 'L')
-			xoff -= adjust;
-		else
-			xoff += adjust;
-	}
-
-	if (xoff != lc->g.xoff || yoff != lc->g.yoff) {
-		lc->g.xoff = xoff;
-		lc->g.yoff = yoff;
-		layout_fix_panes(w, NULL);
-		events_fire_window("window-layout-changed", w);
-		server_redraw_window(w);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_join_pane_mouse_update(struct cmdq_item *item)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct key_event	*event = cmdq_get_event(item);
-	struct client		*c = cmdq_get_client(item);
-	struct session		*s = target->s;
-	struct winlink		*wl;
-	struct window		*w;
-	struct window_pane	*wp;
-
-	if (!event->m.valid)
-		return (CMD_RETURN_NORMAL);
-	wp = cmd_mouse_pane(&event->m, &s, &wl);
-	if (wp == NULL || c == NULL || c->session != s)
-		return (CMD_RETURN_NORMAL);
-	if (!window_pane_is_floating(wp))
-		return (CMD_RETURN_NORMAL);
-
-	w = wl->window;
-	window_redraw_active_switch(w, wp);
-	window_set_active_pane(w, wp, 1);
-
-	c->tty.mouse_drag_update = cmd_join_pane_mouse_move;
-	cmd_join_pane_mouse_move(c, &event->m);
-	return (CMD_RETURN_NORMAL);
-}
-
-static void
-cmd_join_pane_mouse_move(struct client *c, struct mouse_event *m)
-{
-	struct winlink		*wl;
-	struct window		*w;
-	struct window_pane	*wp;
-	struct layout_cell	*lc;
-	int			 y, ly, x, lx;
-	int			 old_xoff, old_yoff, old_sx, old_sy;
-
-	wp = cmd_mouse_pane(m, NULL, &wl);
-	if (wp == NULL) {
-		c->tty.mouse_drag_update = NULL;
-		return;
-	}
-	w = wl->window;
-	lc = wp->layout_cell;
-
-	y = m->y + m->oy; x = m->x + m->ox;
-	if (m->statusat == 0 && y >= (int)m->statuslines)
-		y -= m->statuslines;
-	else if (m->statusat > 0 && y >= m->statusat)
-		y = m->statusat - 1;
-	ly = m->ly + m->oy; lx = m->lx + m->ox;
-	if (m->statusat == 0 && ly >= (int)m->statuslines)
-		ly -= m->statuslines;
-	else if (m->statusat > 0 && ly >= m->statusat)
-		ly = m->statusat - 1;
-
-	if (x != lx || y != ly) {
-		old_xoff = wp->xoff;
-		old_yoff = wp->yoff;
-		old_sx = wp->sx;
-		old_sy = wp->sy;
-
-		lc->g.xoff += x - lx;
-		lc->g.yoff += y - ly;
-		layout_fix_panes(w, NULL);
-
-		window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-		    old_sy);
-		server_redraw_window_borders(w);
-	}
-}
-
-static enum cmd_retval
-cmd_join_pane_zindex(struct cmdq_item *item, struct winlink *wl,
-    struct window_pane *wp, const char *s)
-{
-	struct window		*w = wl->window;
-	struct window_pane	*owp;
-	const char		*errstr;
-	u_int			 n, z;
-
-	z = strtonum(s, 0, UINT_MAX, &errstr);
-	if (errstr != NULL) {
-		cmdq_error(item, "z-index %s", errstr);
-		return (CMD_RETURN_ERROR);
-	}
-	TAILQ_REMOVE(&w->z_index, wp, zentry);
-
-	n = 0;
-	TAILQ_FOREACH(owp, &w->z_index, zentry) {
-		if (!window_pane_is_floating(owp))
-			break;
-		if (n >= z)
-			break;
-		n++;
-	}
-
-	if (owp != NULL)
-		TAILQ_INSERT_BEFORE(owp, wp, zentry);
-	else
-		TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
-
-	redraw_invalidate_scene(w);
-	events_fire_window("window-layout-changed", w);
-	server_redraw_window(w);
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_join_pane_tile(struct cmdq_item *item, struct args *args, struct window *w,
-    struct window_pane *wp)
-{
-	struct layout_cell	*lc = wp->layout_cell;
-
-	if (!window_pane_is_floating(wp)) {
-		cmdq_error(item, "pane is not floating");
-		return (CMD_RETURN_ERROR);
-	}
-	if (w->flags & WINDOW_ZOOMED) {
-		cmdq_error(item, "can't tile a pane while window is zoomed");
-		return (CMD_RETURN_ERROR);
-	}
-
-	lc->fg.sx = lc->g.sx;
-	lc->fg.sy = lc->g.sy;
-	lc->fg.xoff = lc->g.xoff;
-	lc->fg.yoff = lc->g.yoff;
-
-	if (layout_insert_tile(w, lc) != 0) {
-		cmdq_error(item, "no space for a new pane");
-		return (CMD_RETURN_ERROR);
-	}
-	lc->flags &= ~LAYOUT_CELL_FLOATING;
-
-	TAILQ_REMOVE(&w->z_index, wp, zentry);
-	TAILQ_INSERT_TAIL(&w->z_index, wp, zentry);
-
-	if (!args_has(args, 'd'))
-		window_set_active_pane(w, wp, 1);
-	layout_fix_offsets(w);
-	layout_fix_panes(w, NULL);
-	redraw_invalidate_scene(w);
-	events_fire_window("window-layout-changed", w);
-	server_redraw_window(w);
-
-	return (CMD_RETURN_NORMAL);
-}
-
 static enum cmd_retval
 cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct cmd_find_state	*source = cmdq_get_source(item);
+	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
 	struct session		*dst_s;
 	struct winlink		*src_wl, *dst_wl;
 	struct window		*src_w, *dst_w;
 	struct window_pane	*src_wp, *dst_wp;
-	const char		*s;
-	char			*cause = NULL;
-	int			 flags = 0, dst_idx;
+	char			*cause, *copy;
+	const char		*errstr, *p;
+	size_t			 plen;
+	int			 size, percentage, dst_idx, not_same_window;
+	int			 flags;
+	enum layout_type	 type;
 	struct layout_cell	*lc;

-	dst_s = target->s;
-	dst_wl = target->wl;
-	dst_wp = target->wp;
+	if (self->entry == &cmd_join_pane_entry)
+		not_same_window = 1;
+	else
+		not_same_window = 0;
+
+	dst_s = item->target.s;
+	dst_wl = item->target.wl;
+	dst_wp = item->target.wp;
 	dst_w = dst_wl->window;
 	dst_idx = dst_wl->idx;
-
-	if (cmd_get_entry(self) == &cmd_move_pane_entry) {
-		if (args_has(args, 'M'))
-			return (cmd_join_pane_mouse_update(item));
-		if (args_has(args, 'P') ||
-		    args_has(args, 'z') ||
-		    args_has(args, 'X') ||
-		    args_has(args, 'Y') ||
-		    args_has(args, 'U') ||
-		    args_has(args, 'D') ||
-		    args_has(args, 'L') ||
-		    args_has(args, 'R')) {
-			if (!window_pane_is_floating(dst_wp)) {
-				cmdq_error(item, "pane is not floating");
-				return (CMD_RETURN_ERROR);
-			}
-			server_unzoom_window(dst_w);
-			if ((s = args_get(args, 'P')) != NULL)
-				return (cmd_join_pane_place(item, dst_wl, dst_wp, s));
-			if ((s = args_get(args, 'z')) != NULL)
-				return (cmd_join_pane_zindex(item, dst_wl, dst_wp, s));
-			return (cmd_join_pane_move(item, args, dst_wl, dst_wp));
-		}
-	}
-
-	src_wl = source->wl;
-	src_wp = source->wp;
-	src_w = src_wl->window;
-
-	if (src_wp == src_w->modal || dst_wp == dst_w->modal) {
-		cmdq_error(item, "pane is modal");
-		return (CMD_RETURN_ERROR);
-	}
-
 	server_unzoom_window(dst_w);
+
+	src_wl = item->source.wl;
+	src_wp = item->source.wp;
+	src_w = src_wl->window;
 	server_unzoom_window(src_w);

-	if (src_wp == dst_wp) {
-		if (window_pane_is_floating(src_wp))
-			return (cmd_join_pane_tile(item, args, src_w, src_wp));
+	if (not_same_window && src_w == dst_w) {
+		cmdq_error(item, "can't join a pane to its own window");
+		return (CMD_RETURN_ERROR);
+	}
+	if (!not_same_window && src_wp == dst_wp) {
 		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
 	}

+	type = LAYOUT_TOPBOTTOM;
 	if (args_has(args, 'h'))
-		flags |= SPAWN_HORIZONTAL;
+		type = LAYOUT_LEFTRIGHT;
+
+	size = -1;
+	if ((p = args_get(args, 'l')) != NULL) {
+		plen = strlen(p);
+		if (p[plen - 1] == '%') {
+			copy = xstrdup(p);
+			copy[plen - 1] = '\0';
+			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			free(copy);
+			if (errstr != NULL) {
+				cmdq_error(item, "percentage %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+			if (type == LAYOUT_TOPBOTTOM)
+				size = (dst_wp->sy * percentage) / 100;
+			else
+				size = (dst_wp->sx * percentage) / 100;
+		} else {
+			size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "size %s", cause);
+				free(cause);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+	} else if (args_has(args, 'p')) {
+		percentage = args_strtonum(args, 'p', 0, 100, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "percentage %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (type == LAYOUT_TOPBOTTOM)
+			size = (dst_wp->sy * percentage) / 100;
+		else
+			size = (dst_wp->sx * percentage) / 100;
+	}
+
+	flags = 0;
 	if (args_has(args, 'b'))
 		flags |= SPAWN_BEFORE;
 	if (args_has(args, 'f'))
 		flags |= SPAWN_FULLSIZE;

-	lc = layout_get_tiled_cell(item, args, dst_w, dst_wp, flags, &cause);
-	if (cause != NULL) {
-		cmdq_error(item, "size or position %s", cause);
-		free(cause);
+	lc = layout_split_pane(dst_wp, type, size, flags);
+	if (lc == NULL) {
+		cmdq_error(item, "create pane failed: pane too small");
 		return (CMD_RETURN_ERROR);
 	}

 	layout_close_pane(src_wp);

-	server_client_remove_pane(src_wp);
 	window_lost_pane(src_w, src_wp);
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);
-	TAILQ_REMOVE(&src_w->z_index, src_wp, zentry);

 	src_wp->window = dst_w;
 	options_set_parent(src_wp->options, dst_w->options);
-	src_wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
-	if (flags & SPAWN_BEFORE) {
-		TAILQ_INSERT_BEFORE(dst_wp, src_wp, entry);
-		TAILQ_INSERT_BEFORE(dst_wp, src_wp, zentry);
-	} else {
-		TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
-		TAILQ_INSERT_AFTER(&dst_w->z_index, dst_wp, src_wp, zentry);
-	}
-	layout_assign_pane(lc, src_wp, 0);
-	colour_palette_from_option(&src_wp->palette, src_wp->options);
+	src_wp->flags |= PANE_STYLECHANGED;
+	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
+	layout_assign_pane(lc, src_wp);

 	recalculate_sizes();

@@ -526,12 +179,11 @@ cmd_join_pane_exec(struct cmd *self, struct cmdq_item *item)
 	} else
 		server_status_session(dst_s);

-	window_fire_pane_moved(src_wp, src_w, src_wl->idx, dst_w, dst_idx);
-	if (window_count_panes(src_w, 1) == 0)
-		server_kill_window(src_w, 1);
+	if (window_count_panes(src_w) == 0)
+		server_kill_window(src_w);
 	else
-		events_fire_window("window-layout-changed", src_w);
-	events_fire_window("window-layout-changed", dst_w);
+		notify_window("window-layout-changed", src_w);
+	notify_window("window-layout-changed", dst_w);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-kill-pane.c
+++ b/cmd-kill-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-kill-pane.c,v 1.34 2026/06/09 21:22:22 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,17 +27,13 @@
 */

 static enum cmd_retval	cmd_kill_pane_exec(struct cmd *, struct cmdq_item *);
-static enum cmd_retval	cmd_kill_pane_all(struct cmdq_item *, const char *);
-static int		cmd_kill_pane_filter(struct cmdq_item *,
-			    struct session *, struct winlink *,
-			    struct window_pane *, const char *);

 const struct cmd_entry cmd_kill_pane_entry = {
 	.name = "kill-pane",
 	.alias = "killp",

-	.args = { "af:t:", 0, 0, NULL },
-	.usage = "[-a] [-f filter] " CMD_TARGET_PANE_USAGE,
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -48,68 +44,21 @@ const struct cmd_entry cmd_kill_pane_entry = {
 static enum cmd_retval
 cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct window_pane	*wp = target->wp;
-	const char		*filter = args_get(args, 'f');
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;

-	if (filter != NULL && !args_has(args, 'a')) {
-		cmdq_error(item, "-f only valid with -a");
-		return (CMD_RETURN_ERROR);
+	if (args_has(self->args, 'a')) {
+		server_unzoom_window(wl->window);
+		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
+			if (loopwp == wp)
+				continue;
+			layout_close_pane(loopwp);
+			window_remove_pane(wl->window, loopwp);
+		}
+		server_redraw_window(wl->window);
+		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'a'))
-		return (cmd_kill_pane_all(item, filter));
-
-	if (wp == NULL) {
-		cmdq_error(item, "no active pane to kill");
-		return (CMD_RETURN_ERROR);
-	}
 	server_kill_pane(wp);
 	return (CMD_RETURN_NORMAL);
 }
-
-static enum cmd_retval
-cmd_kill_pane_all(struct cmdq_item *item, const char *filter)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = target->wp;
-	struct window_pane	*loopwp, *tmpwp;
-
-	server_unzoom_window(wl->window);
-	TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
-		if (loopwp == wp)
-			continue;
-		if (!cmd_kill_pane_filter(item, s, wl, loopwp, filter))
-			continue;
-		server_client_remove_pane(loopwp);
-		layout_close_pane(loopwp);
-		window_remove_pane(wl->window, loopwp);
-	}
-	server_redraw_window(wl->window);
-	return (CMD_RETURN_NORMAL);
-}
-
-static int
-cmd_kill_pane_filter(struct cmdq_item *item, struct session *s,
-    struct winlink *wl, struct window_pane *wp, const char *filter)
-{
-	struct format_tree	*ft;
-	char			*expanded;
-	int			 flag;
-
-	if (filter == NULL)
-		return (1);
-
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, NULL, s, wl, wp);
-
-	expanded = format_expand(ft, filter);
-	flag = format_true(expanded);
-	free(expanded);
-
-	format_free(ft);
-	return (flag);
-}
--- a/cmd-kill-server.c
+++ b/cmd-kill-server.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-kill-server.c,v 1.20 2021/08/21 10:22:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_kill_server_entry = {
 	.name = "kill-server",
 	.alias = NULL,

-	.args = { "", 0, 0, NULL },
+	.args = { "", 0, 0 },
 	.usage = "",

 	.flags = 0,
@@ -44,7 +44,7 @@ const struct cmd_entry cmd_start_server_entry = {
 	.name = "start-server",
 	.alias = "start",

-	.args = { "", 0, 0, NULL },
+	.args = { "", 0, 0 },
 	.usage = "",

 	.flags = CMD_STARTSERVER,
@@ -54,7 +54,7 @@ const struct cmd_entry cmd_start_server_entry = {
 static enum cmd_retval
 cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
 {
-	if (cmd_get_entry(self) == &cmd_kill_server_entry)
+	if (self->entry == &cmd_kill_server_entry)
 		kill(getpid(), SIGTERM);

 	return (CMD_RETURN_NORMAL);
--- a/cmd-kill-session.c
+++ b/cmd-kill-session.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-kill-session.c,v 1.31 2026/06/09 12:57:40 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,8 +18,6 @@

 #include <sys/types.h>

-#include <stdlib.h>
-
 #include "tmux.h"

 /*
@@ -30,16 +28,13 @@
 */

 static enum cmd_retval	cmd_kill_session_exec(struct cmd *, struct cmdq_item *);
-static enum cmd_retval	cmd_kill_session_all(struct cmdq_item *, const char *);
-static int		cmd_kill_session_filter(struct cmdq_item *,
-			    struct session *, const char *);

 const struct cmd_entry cmd_kill_session_entry = {
 	.name = "kill-session",
 	.alias = NULL,

-	.args = { "aCgf:t:", 0, 0, NULL },
-	.usage = "[-aCg] [-f filter] " CMD_TARGET_SESSION_USAGE,
+	.args = { "aCt:", 0, 0 },
+	.usage = "[-aC] " CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },

@@ -50,17 +45,11 @@ const struct cmd_entry cmd_kill_session_entry = {
 static enum cmd_retval
 cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s, *sloop, *stmp;
-	struct session_group	*sg;
-	struct winlink		*wl;
-	const char		*filter = args_get(args, 'f');
+	struct args	*args = self->args;
+	struct session	*s, *sloop, *stmp;
+	struct winlink	*wl;

-	if (filter != NULL && (!args_has(args, 'a') || args_has(args, 'C'))) {
-		cmdq_error(item, "-f only valid with -a");
-		return (CMD_RETURN_ERROR);
-	}
+	s = item->target.s;

 	if (args_has(args, 'C')) {
 		RB_FOREACH(wl, winlinks, &s->windows) {
@@ -68,13 +57,12 @@ cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 			wl->flags &= ~WINLINK_ALERTFLAGS;
 		}
 		server_redraw_session(s);
-	} else if (args_has(args, 'a'))
-		return (cmd_kill_session_all(item, filter));
-	else if (args_has(args, 'g') &&
-	    (sg = session_group_contains(s)) != NULL) {
-		TAILQ_FOREACH_SAFE(sloop, &sg->sessions, gentry, stmp) {
-			server_destroy_session(sloop);
-			session_destroy(sloop, 1, __func__);
+	} else if (args_has(args, 'a')) {
+		RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
+			if (sloop != s) {
+				server_destroy_session(sloop);
+				session_destroy(sloop, 1, __func__);
+			}
 		}
 	} else {
 		server_destroy_session(s);
@@ -82,42 +70,3 @@ cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	return (CMD_RETURN_NORMAL);
 }
-
-static enum cmd_retval
-cmd_kill_session_all(struct cmdq_item *item, const char *filter)
-{
-	struct session	*s = cmdq_get_target(item)->s;
-	struct session	*sloop, *stmp;
-
-	RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
-		if (sloop == s)
-			continue;
-		if (!cmd_kill_session_filter(item, sloop, filter))
-			continue;
-		server_destroy_session(sloop);
-		session_destroy(sloop, 1, __func__);
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
-static int
-cmd_kill_session_filter(struct cmdq_item *item, struct session *s,
-    const char *filter)
-{
-	struct format_tree	*ft;
-	char			*expanded;
-	int			 flag;
-
-	if (filter == NULL)
-		return (1);
-
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, NULL, s, NULL, NULL);
-
-	expanded = format_expand(ft, filter);
-	flag = format_true(expanded);
-	free(expanded);
-
-	format_free(ft);
-	return (flag);
-}
--- a/cmd-kill-window.c
+++ b/cmd-kill-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-kill-window.c,v 1.30 2026/06/09 12:57:40 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,8 +18,6 @@

 #include <sys/types.h>

-#include <stdlib.h>
-
 #include "tmux.h"

 /*
@@ -27,16 +25,13 @@
 */

 static enum cmd_retval	cmd_kill_window_exec(struct cmd *, struct cmdq_item *);
-static enum cmd_retval	cmd_kill_window_all(struct cmdq_item *, const char *);
-static int		cmd_kill_window_filter(struct cmdq_item *,
-			    struct session *, struct winlink *, const char *);

 const struct cmd_entry cmd_kill_window_entry = {
 	.name = "kill-window",
 	.alias = "killw",

-	.args = { "af:t:", 0, 0, NULL },
-	.usage = "[-a] [-f filter] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "at:", 0, 0 },
+	.usage = "[-a] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },

@@ -48,7 +43,7 @@ const struct cmd_entry cmd_unlink_window_entry = {
 	.name = "unlink-window",
 	.alias = "unlinkw",

-	.args = { "kt:", 0, 0, NULL },
+	.args = { "kt:", 0, 0 },
 	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -60,98 +55,27 @@ const struct cmd_entry cmd_unlink_window_entry = {
 static enum cmd_retval
 cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl, *wl2, *wl3;
 	struct window		*w = wl->window;
-	struct session		*s = target->s;
-	const char		*filter = args_get(args, 'f');
+	struct session		*s = item->target.s;

-	if (filter != NULL && !args_has(args, 'a')) {
-		cmdq_error(item, "-f only valid with -a");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (cmd_get_entry(self) == &cmd_unlink_window_entry) {
-		if (!args_has(args, 'k') && !session_is_linked(s, w)) {
+	if (self->entry == &cmd_unlink_window_entry) {
+		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
 			cmdq_error(item, "window only linked to one session");
 			return (CMD_RETURN_ERROR);
 		}
 		server_unlink_window(s, wl);
-		recalculate_sizes();
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(args, 'a'))
-		return (cmd_kill_window_all(item, filter));
-
-	server_kill_window(wl->window, 1);
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_kill_window_all(struct cmdq_item *item, const char *filter)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	struct winlink	*loop;
-	u_int		 found, kill_current;
-
-	if (RB_PREV(winlinks, &s->windows, wl) == NULL &&
-	    RB_NEXT(winlinks, &s->windows, wl) == NULL)
-		return (CMD_RETURN_NORMAL);
-
-	/* Kill all windows except the current one. */
-	do {
-		found = 0;
-		RB_FOREACH(loop, winlinks, &s->windows) {
-			if (loop->window != wl->window &&
-			    cmd_kill_window_filter(item, s, loop, filter)) {
-				server_kill_window(loop->window, 0);
-				found++;
-				break;
+	} else {
+		if (args_has(args, 'a')) {
+			RB_FOREACH_SAFE(wl2, winlinks, &s->windows, wl3) {
+				if (wl != wl2)
+					server_kill_window(wl2->window);
 			}
-		}
-	} while (found != 0);
-
-	/*
-	 * If the current window appears in the session more than once, kill it
-	 * as well if it matches the filter.
-	 */
-	found = kill_current = 0;
-	RB_FOREACH(loop, winlinks, &s->windows) {
-		if (loop->window == wl->window) {
-			found++;
-			if (cmd_kill_window_filter(item, s, loop, filter))
-				kill_current = 1;
-		}
+		} else
+			server_kill_window(wl->window);
 	}
-	if (kill_current && found > 1)
-		server_kill_window(wl->window, 0);

-	server_renumber_all();
+	recalculate_sizes();
 	return (CMD_RETURN_NORMAL);
 }
-
-static int
-cmd_kill_window_filter(struct cmdq_item *item, struct session *s,
-    struct winlink *wl, const char *filter)
-{
-	struct format_tree	*ft;
-	char			*expanded;
-	int			 flag;
-
-	if (filter == NULL)
-		return (1);
-
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, NULL, s, wl, NULL);
-
-	expanded = format_expand(ft, filter);
-	flag = format_true(expanded);
-	free(expanded);
-
-	format_free(ft);
-	return (flag);
-}
--- a/cmd-list-buffers.c
+++ b/cmd-list-buffers.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-buffers.c,v 1.41 2026/02/27 08:25:12 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -36,8 +36,8 @@ const struct cmd_entry cmd_list_buffers_entry = {
 	.name = "list-buffers",
 	.alias = "lsb",

-	.args = { "F:f:O:r", 0, 0, NULL },
-	.usage = "[-F format] [-f filter] [-O order]",
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_buffers_exec
@@ -46,42 +46,23 @@ const struct cmd_entry cmd_list_buffers_entry = {
 static enum cmd_retval
 cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		 *args = cmd_get_args(self);
-	struct paste_buffer	**l;
-	struct format_tree	 *ft;
-	const char		 *template, *filter;
-	char			 *line, *expanded;
-	int			  flag;
-	u_int			  i, n;
-	struct sort_criteria	  sort_crit;
+	struct args		*args = self->args;
+	struct paste_buffer	*pb;
+	struct format_tree	*ft;
+	char			*line;
+	const char		*template;

 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_BUFFERS_TEMPLATE;
-	filter = args_get(args, 'f');

-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
+	pb = NULL;
+	while ((pb = paste_walk(pb)) != NULL) {
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_defaults_paste_buffer(ft, pb);

-	l = sort_get_buffers(&n, &sort_crit);
-	for (i = 0; i < n; i++) {
-		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-		format_defaults_paste_buffer(ft, l[i]);
-
-		if (filter != NULL) {
-			expanded = format_expand(ft, filter);
-			flag = format_true(expanded);
-			free(expanded);
-		} else
-			flag = 1;
-		if (flag) {
-			line = format_expand(ft, template);
-			cmdq_print(item, "%s", line);
-			free(line);
-		}
+		line = format_expand(ft, template);
+		cmdq_print(item, "%s", line);
+		free(line);

 		format_free(ft);
 	}
--- a/cmd-list-clients.c
+++ b/cmd-list-clients.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-clients.c,v 1.42 2026/02/27 08:25:12 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -28,12 +28,10 @@
 * List all clients.
 */

-#define LIST_CLIENTS_TEMPLATE						\
-	"#{client_name}: #{session_name} "				\
-	"[#{client_width}x#{client_height} #{client_termname}] "	\
-	"#{?#{!=:#{client_uid},#{uid}},"				\
-	"[user #{?client_user,#{client_user},#{client_uid},}] ,}"	\
-	"#{?client_flags,(,}#{client_flags}#{?client_flags,),}"
+#define LIST_CLIENTS_TEMPLATE					\
+	"#{client_name}: #{session_name} "			\
+	"[#{client_width}x#{client_height} #{client_termname}]"	\
+	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"

 static enum cmd_retval	cmd_list_clients_exec(struct cmd *, struct cmdq_item *);

@@ -41,8 +39,8 @@ const struct cmd_entry cmd_list_clients_entry = {
 	.name = "list-clients",
 	.alias = "lsc",

-	.args = { "F:f:O:rt:", 0, 0, NULL },
-	.usage = "[-F format] [-f filter] [-O order]" CMD_TARGET_SESSION_USAGE,
+	.args = { "F:t:", 0, 0 },
+	.usage = "[-F format] " CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },

@@ -53,55 +51,38 @@ const struct cmd_entry cmd_list_clients_entry = {
 static enum cmd_retval
 cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args 		 *args = cmd_get_args(self);
-	struct cmd_find_state	 *target = cmdq_get_target(item);
-	struct client		**l;
-	struct session		 *s;
-	struct format_tree	 *ft;
-	const char		 *template, *filter;
-	u_int			  i, n;
-	char			 *line, *expanded;
-	int			  flag;
-	struct sort_criteria	  sort_crit;
+	struct args 		*args = self->args;
+	struct client		*c;
+	struct session		*s;
+	struct format_tree	*ft;
+	const char		*template;
+	u_int			 idx;
+	char			*line;

 	if (args_has(args, 't'))
-		s = target->s;
+		s = item->target.s;
 	else
 		s = NULL;

 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_CLIENTS_TEMPLATE;
-	filter = args_get(args, 'f');

-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
-
-	l = sort_get_clients(&n, &sort_crit);
-	for (i = 0; i < n; i++) {
-		if (l[i]->session == NULL || (s != NULL && s != l[i]->session))
+	idx = 0;
+	TAILQ_FOREACH(c, &clients, entry) {
+		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;

-		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-		format_add(ft, "line", "%u", i);
-		format_defaults(ft, l[i], NULL, NULL, NULL);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_add(ft, "line", "%u", idx);
+		format_defaults(ft, c, NULL, NULL, NULL);

-		if (filter != NULL) {
-			expanded = format_expand(ft, filter);
-			flag = format_true(expanded);
-			free(expanded);
-		} else
-			flag = 1;
-		if (flag) {
-			line = format_expand(ft, template);
-			cmdq_print(item, "%s", line);
-			free(line);
-		}
+		line = format_expand(ft, template);
+		cmdq_print(item, "%s", line);
+		free(line);

 		format_free(ft);
+
+		idx++;
 	}

 	return (CMD_RETURN_NORMAL);
--- a/cmd-list-commands.c
+++ b/cmd-list-commands.c
@@ -1,107 +0,0 @@
-/* $OpenBSD: cmd-list-commands.c,v 1.15 2026/02/24 08:22:13 nicm Exp $ */
-
-/*
- * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "tmux.h"
-
-/*
- * List all commands.
- */
-
-#define LIST_COMMANDS_TEMPLATE					\
-	"#{command_list_name}"					\
-	"#{?command_list_alias, (#{command_list_alias}),} "	\
-	"#{command_list_usage}"
-
-static enum cmd_retval cmd_list_commands(struct cmd *, struct cmdq_item *);
-
-const struct cmd_entry cmd_list_commands_entry = {
-	.name = "list-commands",
-	.alias = "lscm",
-
-	.args = { "F:", 0, 1, NULL },
-	.usage = "[-F format] [command]",
-
-	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
-	.exec = cmd_list_commands
-};
-
-static void
-cmd_list_single_command(const struct cmd_entry *entry, struct format_tree *ft,
-    const char *template, struct cmdq_item *item)
-{
-	const char	*s;
-	char		*line;
-
-	format_add(ft, "command_list_name", "%s", entry->name);
-	if (entry->alias != NULL)
-		s = entry->alias;
-	else
-		s = "";
-	format_add(ft, "command_list_alias", "%s", s);
-	if (entry->usage != NULL)
-		s = entry->usage;
-	else
-		s = "";
-	format_add(ft, "command_list_usage", "%s", s);
-
-	line = format_expand(ft, template);
-	if (*line != '\0')
-		cmdq_print(item, "%s", line);
-	free(line);
-}
-
-static enum cmd_retval
-cmd_list_commands(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		 *args = cmd_get_args(self);
-	const struct cmd_entry	**entryp;
-	const struct cmd_entry	 *entry;
-	struct format_tree	 *ft;
-	const char		 *template,  *command;
-	char			 *cause;
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = LIST_COMMANDS_TEMPLATE;
-
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, NULL, NULL, NULL, NULL);
-
-	command = args_string(args, 0);
-	if (command == NULL) {
-		for (entryp = cmd_table; *entryp != NULL; entryp++)
-			cmd_list_single_command(*entryp, ft, template, item);
-	} else {
-		entry = cmd_find(command, &cause);
-		if (entry != NULL)
-			cmd_list_single_command(entry, ft, template, item);
-		else {
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			format_free(ft);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	format_free(ft);
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-list-keys.c
+++ b/cmd-list-keys.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-keys.c,v 1.78 2026/07/01 13:12:17 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,232 +27,337 @@
 * List key bindings.
 */

-#define LIST_KEYS_TEMPLATE					\
-	"#{?notes_only,"					\
-	"#{key_prefix} "					\
-	"#{p|#{key_string_width}:key_string} "			\
-	"#{?key_note,#{key_note},#{key_command}}"		\
-	","							\
-	"bind-key #{?key_has_repeat,#{?key_repeat,-r,  },} "	\
-	"-T #{p|#{key_table_width}:key_table} "			\
-	"#{p|#{key_string_width}:#{q|a:key_string}} "		\
-	"#{key_command}}"
+static enum cmd_retval	cmd_list_keys_exec(struct cmd *, struct cmdq_item *);

-static enum cmd_retval cmd_list_keys_exec(struct cmd *, struct cmdq_item *);
+static enum cmd_retval	cmd_list_keys_commands(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_list_keys_entry = {
 	.name = "list-keys",
 	.alias = "lsk",

-	.args = { "1aF:NO:P:rT:", 0, 1, NULL },
-	.usage = "[-1aNr] [-F format] [-O order] [-P prefix-string]"
-		 "[-T key-table] [key]",
+	.args = { "1aNP:T:", 0, 1 },
+	.usage = "[-1aN] [-P prefix-string] [-T key-table] [key]",

 	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
 	.exec = cmd_list_keys_exec
 };

-static char *
-cmd_list_keys_get_prefix(struct args *args)
-{
-	key_code	prefix;
+const struct cmd_entry cmd_list_commands_entry = {
+	.name = "list-commands",
+	.alias = "lscm",

-	if (args_has(args, 'P'))
-		return (xstrdup(args_get(args, 'P')));
+	.args = { "F:", 0, 1 },
+	.usage = "[-F format] [command]",

-	prefix = options_get_number(global_s_options, "prefix");
-	if (prefix == KEYC_NONE)
-		return (xstrdup(""));
-	return (xstrdup(key_string_lookup_key(prefix, 0)));
-}
+	.flags = CMD_STARTSERVER|CMD_AFTERHOOK,
+	.exec = cmd_list_keys_exec
+};

 static u_int
-cmd_list_keys_get_width(struct key_binding **l, u_int n)
+cmd_list_keys_get_width(const char *tablename, key_code only)
 {
-	u_int	i, width, keywidth = 0;
+	struct key_table	*table;
+	struct key_binding	*bd;
+	u_int			 width, keywidth = 0;

-	for (i = 0; i < n; i++) {
-		width = utf8_cstrwidth(key_string_lookup_key(l[i]->key, 0));
+	table = key_bindings_get_table(tablename, 0);
+	if (table == NULL)
+		return (0);
+	bd = key_bindings_first(table);
+	while (bd != NULL) {
+		if ((only != KEYC_UNKNOWN && bd->key != only) ||
+		    KEYC_IS_MOUSE(bd->key) ||
+		    bd->note == NULL) {
+			bd = key_bindings_next(table, bd);
+			continue;
+		}
+		width = utf8_cstrwidth(key_string_lookup_key(bd->key));
 		if (width > keywidth)
 			keywidth = width;
+
+		bd = key_bindings_next(table, bd);
 	}
 	return (keywidth);
 }

-static u_int
-cmd_list_keys_get_table_width(struct key_binding **l, u_int n)
+static int
+cmd_list_keys_print_notes(struct cmdq_item *item, struct args *args,
+    const char *tablename, u_int keywidth, key_code only, const char *prefix)
 {
-	u_int	i, width, tablewidth = 0;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct key_table	*table;
+	struct key_binding	*bd;
+	const char		*key;
+	char			*tmp, *note;
+	int	                 found = 0;

-	for (i = 0; i < n; i++) {
-		width = utf8_cstrwidth(l[i]->tablename);
-		if (width > tablewidth)
-			tablewidth = width;
-	}
-	return (tablewidth);
-}
-
-static struct key_binding **
-cmd_list_keys_get_root_and_prefix(u_int *n, struct sort_criteria *sort_crit)
-{
-	const char			 *tables[] = { "prefix", "root" };
-	struct key_table		 *t;
-	struct key_binding		**lt;
-	u_int				  i, ltsz, len = 0, offset = 0;
-	static struct key_binding	**l = NULL;
-	static u_int			  lsz = 0;
-
-	for (i = 0; i < nitems(tables); i++) {
-		t = key_bindings_get_table(tables[i], 0);
-		lt = sort_get_key_bindings_table(t, &ltsz, sort_crit);
-		len += ltsz;
-		if (lsz <= len) {
-			lsz = len + 100;
-			l = xreallocarray(l, lsz, sizeof *l);
+	table = key_bindings_get_table(tablename, 0);
+	if (table == NULL)
+		return (0);
+	bd = key_bindings_first(table);
+	while (bd != NULL) {
+		if ((only != KEYC_UNKNOWN && bd->key != only) ||
+		    KEYC_IS_MOUSE(bd->key) ||
+		    (bd->note == NULL && !args_has(args, 'a'))) {
+			bd = key_bindings_next(table, bd);
+			continue;
 		}
-		memcpy(l + offset, lt, ltsz * sizeof *l);
-		offset += ltsz;
-	}
+		found = 1;
+		key = key_string_lookup_key(bd->key);

-	*n = len;
-	return (l);
+		if (bd->note == NULL)
+			note = cmd_list_print(bd->cmdlist, 1);
+		else
+			note = xstrdup(bd->note);
+		tmp = utf8_padcstr(key, keywidth + 1);
+		if (args_has(args, '1') && c != NULL)
+			status_message_set(c, "%s%s%s", prefix, tmp, note);
+		else
+			cmdq_print(item, "%s%s%s", prefix, tmp, note);
+		free(tmp);
+		free(note);
+
+		if (args_has(args, '1'))
+			break;
+		bd = key_bindings_next(table, bd);
+	}
+	return (found);
 }

-static void
-cmd_list_keys_filter_key_list(int filter_notes, int filter_key, key_code only,
-    struct key_binding **l, u_int *n)
-{
-	key_code	key;
-	u_int		i, j = 0;
-
-	for (i = 0; i < *n; i++) {
-		key = l[i]->key & (KEYC_MASK_KEY|KEYC_MASK_MODIFIERS);
-		if (filter_key && only != key)
-			continue;
-		if (filter_notes && l[i]->note == NULL)
-			continue;
-		l[j++] = l[i];
-	}
-	*n = j;
-}
-
-static void
-cmd_list_keys_format_add_key_binding(struct format_tree *ft,
-    const struct key_binding *bd, const char *prefix)
+static char *
+cmd_list_keys_get_prefix(struct args *args, key_code *prefix)
 {
 	char	*s;

-	if (bd->flags & KEY_BINDING_REPEAT)
-		format_add(ft, "key_repeat", "1");
-	else
-		format_add(ft, "key_repeat", "0");
-
-	if (bd->note != NULL)
-		format_add(ft, "key_note", "%s", bd->note);
-	else
-		format_add(ft, "key_note", "%s", "");
-
-	format_add(ft, "key_prefix", "%s", prefix);
-	format_add(ft, "key_table", "%s", bd->tablename);
-
-	format_add(ft, "key_string", "%s", key_string_lookup_key(bd->key, 0));
-
-	s = cmd_list_print(bd->cmdlist, CMD_LIST_PRINT_ESCAPED|
-	    CMD_LIST_PRINT_NO_GROUPS);
-	format_add(ft, "key_command", "%s", s);
-	free(s);
+	*prefix = options_get_number(global_s_options, "prefix");
+	if (!args_has(args, 'P')) {
+		if (*prefix != KEYC_NONE)
+			xasprintf(&s, "%s ", key_string_lookup_key(*prefix));
+		else
+			s = xstrdup("");
+	} else
+		s = xstrdup(args_get(args, 'P'));
+	return (s);
 }

 static enum cmd_retval
 cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*tc = cmdq_get_target_client(item);
-	struct format_tree	*ft;
-	struct key_table	*table = NULL;
-	struct key_binding	**l;
-	key_code		 only = KEYC_UNKNOWN;
-	const char		*template, *tablename, *keystr;
-	char			*line;
-	char			*prefix = NULL;
-	u_int			 i, n;
-	int			 single, notes_only, filter_notes, filter_key;
-	struct sort_criteria	 sort_crit;
+	struct args		*args = self->args;
+	struct key_table	*table;
+	struct key_binding	*bd;
+	const char		*tablename, *r;
+	char			*key, *cp, *tmp, *start, *empty;
+	key_code		 prefix, only = KEYC_UNKNOWN;
+	int			 repeat, width, tablewidth, keywidth, found = 0;
+	size_t			 tmpsize, tmpused, cplen;

-	if ((keystr = args_string(args, 0)) != NULL) {
-		only = key_string_lookup_string(keystr);
+	if (self->entry == &cmd_list_commands_entry)
+		return (cmd_list_keys_commands(self, item));
+
+	if (args->argc != 0) {
+		only = key_string_lookup_string(args->argv[0]);
 		if (only == KEYC_UNKNOWN) {
-			cmdq_error(item, "invalid key: %s", keystr);
-			return (CMD_RETURN_ERROR);
-		}
-		only &= (KEYC_MASK_KEY|KEYC_MASK_MODIFIERS);
-	}
-
-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
-
-	if ((tablename = args_get(args, 'T')) != NULL) {
-		table = key_bindings_get_table(tablename, 0);
-		if (table == NULL) {
-			cmdq_error(item, "table %s doesn't exist", tablename);
+			cmdq_error(item, "invalid key: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
 	}

-	prefix = cmd_list_keys_get_prefix(args);
-	single = args_has(args, '1');
-	notes_only = args_has(args, 'N');
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = LIST_KEYS_TEMPLATE;
-
-	if (table)
-		l = sort_get_key_bindings_table(table, &n, &sort_crit);
-	else if (notes_only)
-		l = cmd_list_keys_get_root_and_prefix(&n, &sort_crit);
-	else
-		l = sort_get_key_bindings(&n, &sort_crit);
-
-	filter_notes = notes_only && !args_has(args, 'a');
-	filter_key = only != KEYC_UNKNOWN;
-	if (filter_notes || filter_key) {
-		cmd_list_keys_filter_key_list(filter_notes, filter_key, only, l,
-		    &n);
-	}
-	if (filter_key && n == 0) {
-		cmdq_error(item, "unknown key: %s", keystr);
-		free(prefix);
+	tablename = args_get(args, 'T');
+	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
+		cmdq_error(item, "table %s doesn't exist", tablename);
 		return (CMD_RETURN_ERROR);
 	}
-	if (single && n > 1)
-		n = 1;

-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, tc, NULL, NULL, NULL);
-	format_add(ft, "notes_only", "%d", notes_only);
-	format_add(ft, "key_has_repeat", "%d", key_bindings_has_repeat(l, n));
-	format_add(ft, "key_string_width", "%u", cmd_list_keys_get_width(l, n));
-	format_add(ft, "key_table_width", "%u",
-	    cmd_list_keys_get_table_width(l, n));
-	for (i = 0; i < n; i++) {
-		cmd_list_keys_format_add_key_binding(ft, l[i], prefix);
+	if (args_has(args, 'N')) {
+		if (tablename == NULL) {
+			start = cmd_list_keys_get_prefix(args, &prefix);
+			keywidth = cmd_list_keys_get_width("root", only);
+			if (prefix != KEYC_NONE) {
+				width = cmd_list_keys_get_width("prefix", only);
+				if (width == 0)
+					prefix = KEYC_NONE;
+				else if (width > keywidth)
+					keywidth = width;
+			}
+			empty = utf8_padcstr("", utf8_cstrwidth(start));

-		line = format_expand(ft, template);
-		if (single && tc != NULL && (~tc->flags & CLIENT_CONTROL))
-			status_message_set(tc, -1, 1, 0, 0, "%s", line);
-		else if (*line != '\0')
-			cmdq_print(item, "%s", line);
-		free(line);
+			found = cmd_list_keys_print_notes(item, args, "root",
+			    keywidth, only, empty);
+			if (prefix != KEYC_NONE) {
+				if (cmd_list_keys_print_notes(item, args,
+				    "prefix", keywidth, only, start))
+					found = 1;
+			}
+			free(empty);
+		} else {
+			if (args_has(args, 'P'))
+				start = xstrdup(args_get(args, 'P'));
+			else
+				start = xstrdup("");
+			keywidth = cmd_list_keys_get_width(tablename, only);
+			found = cmd_list_keys_print_notes(item, args, tablename,
+			    keywidth, only, start);

-		if (single)
-			break;
+		}
+		free(start);
+		goto out;
 	}
-	format_free(ft);
-	free(prefix);

+	repeat = 0;
+	tablewidth = keywidth = 0;
+	table = key_bindings_first_table ();
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
+			continue;
+		}
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
+			if (only != KEYC_UNKNOWN && bd->key != only) {
+				bd = key_bindings_next(table, bd);
+				continue;
+			}
+			key = args_escape(key_string_lookup_key(bd->key));
+
+			if (bd->flags & KEY_BINDING_REPEAT)
+				repeat = 1;
+
+			width = utf8_cstrwidth(table->name);
+			if (width > tablewidth)
+				tablewidth = width;
+			width = utf8_cstrwidth(key);
+			if (width > keywidth)
+				keywidth = width;
+
+			free(key);
+			bd = key_bindings_next(table, bd);
+		}
+		table = key_bindings_next_table(table);
+	}
+
+	tmpsize = 256;
+	tmp = xmalloc(tmpsize);
+
+	table = key_bindings_first_table ();
+	while (table != NULL) {
+		if (tablename != NULL && strcmp(table->name, tablename) != 0) {
+			table = key_bindings_next_table(table);
+			continue;
+		}
+		bd = key_bindings_first(table);
+		while (bd != NULL) {
+			if (only != KEYC_UNKNOWN && bd->key != only) {
+				bd = key_bindings_next(table, bd);
+				continue;
+			}
+			found = 1;
+			key = args_escape(key_string_lookup_key(bd->key));
+
+			if (!repeat)
+				r = "";
+			else if (bd->flags & KEY_BINDING_REPEAT)
+				r = "-r ";
+			else
+				r = "   ";
+			tmpused = xsnprintf(tmp, tmpsize, "%s-T ", r);
+
+			cp = utf8_padcstr(table->name, tablewidth);
+			cplen = strlen(cp) + 1;
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			tmpused = strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
+			free(cp);
+
+			cp = utf8_padcstr(key, keywidth);
+			cplen = strlen(cp) + 1;
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			tmpused = strlcat(tmp, cp, tmpsize);
+			tmpused = strlcat(tmp, " ", tmpsize);
+			free(cp);
+
+			cp = cmd_list_print(bd->cmdlist, 1);
+			cplen = strlen(cp);
+			while (tmpused + cplen + 1 >= tmpsize) {
+				tmpsize *= 2;
+				tmp = xrealloc(tmp, tmpsize);
+			}
+			strlcat(tmp, cp, tmpsize);
+			free(cp);
+
+			cmdq_print(item, "bind-key %s", tmp);
+
+			free(key);
+			bd = key_bindings_next(table, bd);
+		}
+		table = key_bindings_next_table(table);
+	}
+
+	free(tmp);
+
+out:
+	if (only != KEYC_UNKNOWN && !found) {
+		cmdq_error(item, "unknown key: %s", args->argv[0]);
+		return (CMD_RETURN_ERROR);
+	}
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cmd_list_keys_commands(struct cmd *self, struct cmdq_item *item)
+{
+	struct args		 *args = self->args;
+	const struct cmd_entry	**entryp;
+	const struct cmd_entry	 *entry;
+	struct format_tree	 *ft;
+	const char		 *template, *s, *command = NULL;
+	char			 *line;
+
+	if (args->argc != 0)
+		command = args->argv[0];
+
+	if ((template = args_get(args, 'F')) == NULL) {
+		template = "#{command_list_name}"
+		    "#{?command_list_alias, (#{command_list_alias}),} "
+		    "#{command_list_usage}";
+	}
+
+	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	format_defaults(ft, NULL, NULL, NULL, NULL);
+
+	for (entryp = cmd_table; *entryp != NULL; entryp++) {
+		entry = *entryp;
+		if (command != NULL &&
+		    (strcmp(entry->name, command) != 0 &&
+		    (entry->alias == NULL ||
+		    strcmp(entry->alias, command) != 0)))
+		    continue;
+
+		format_add(ft, "command_list_name", "%s", entry->name);
+		if (entry->alias != NULL)
+			s = entry->alias;
+		else
+			s = "";
+		format_add(ft, "command_list_alias", "%s", s);
+		if (entry->usage != NULL)
+			s = entry->usage;
+		else
+			s = "";
+		format_add(ft, "command_list_usage", "%s", s);
+
+		line = format_expand(ft, template);
+		if (*line != '\0')
+			cmdq_print(item, "%s", line);
+		free(line);
+	}
+
+	format_free(ft);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-list-panes.c
+++ b/cmd-list-panes.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-panes.c,v 1.41 2026/09/08 10:20:08 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -38,9 +38,8 @@ const struct cmd_entry cmd_list_panes_entry = {
 	.name = "list-panes",
 	.alias = "lsp",

-	.args = { "aF:f:O:rst:", 0, 0, NULL },
-	.usage = "[-asr] [-F format] [-f filter] [-O order]"
-		 CMD_TARGET_WINDOW_USAGE,
+	.args = { "asF:t:", 0, 0 },
+	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },

@@ -51,17 +50,9 @@ const struct cmd_entry cmd_list_panes_entry = {
 static enum cmd_retval
 cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	enum sort_order		 order;
-
-	order = sort_order_from_string(args_get(args, 'O'));
-	if (order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
+	struct args	*args = self->args;
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;

 	if (args_has(args, 'a'))
 		cmd_list_panes_server(self, item);
@@ -96,72 +87,51 @@ static void
 cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
    struct cmdq_item *item, int type)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmdq_get_client(item);
-	struct window_pane	*wp, **l;
-	u_int			 i, n;
+	struct args		*args = self->args;
+	struct window_pane	*wp;
+	u_int			 n;
 	struct format_tree	*ft;
-	const char		*template, *filter;
-	char			*line, *expanded;
-	int			 flag;
-	struct sort_criteria	 sort_crit;
+	const char		*template;
+	char			*line;

 	template = args_get(args, 'F');
 	if (template == NULL) {
 		switch (type) {
 		case 0:
 			template = "#{pane_index}: "
-			    "[#{pane_width}x#{pane_height}"
-			    "#{?pane_floating_flag, "
-			    "#{pane_x}#,#{pane_y}#,#{pane_z}}] [history "
+			    "[#{pane_width}x#{pane_height}] [history "
 			    "#{history_size}/#{history_limit}, "
 			    "#{history_bytes} bytes] #{pane_id}"
 			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
 			break;
 		case 1:
 			template = "#{window_index}.#{pane_index}: "
-			    "[#{pane_width}x#{pane_height}"
-			    "#{?pane_floating_flag, "
-			    "#{pane_x}#,#{pane_y}#,#{pane_z}}] [history "
+			    "[#{pane_width}x#{pane_height}] [history "
 			    "#{history_size}/#{history_limit}, "
 			    "#{history_bytes} bytes] #{pane_id}"
 			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
 			break;
 		case 2:
 			template = "#{session_name}:#{window_index}."
-			    "#{pane_index}: [#{pane_width}x#{pane_height}"
-			    "#{?pane_floating_flag, "
-			    "#{pane_x}#,#{pane_y}#,#{pane_z}}] [history "
-			    "#{history_size}/#{history_limit}, "
+			    "#{pane_index}: [#{pane_width}x#{pane_height}] "
+			    "[history #{history_size}/#{history_limit}, "
 			    "#{history_bytes} bytes] #{pane_id}"
 			    "#{?pane_active, (active),}#{?pane_dead, (dead),}";
 			break;
 		}
 	}
-	filter = args_get(args, 'f');

-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	sort_crit.reversed = args_has(args, 'r');
-
-	l = sort_get_panes_window(wl->window, &n, &sort_crit);
-	for (i = 0; i < n; i++) {
-		wp = l[i];
-		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
+	n = 0;
+	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
-		format_defaults(ft, c, s, wl, wp);
+		format_defaults(ft, NULL, s, wl, wp);

-		if (filter != NULL) {
-			expanded = format_expand(ft, filter);
-			flag = format_true(expanded);
-			free(expanded);
-		} else
-			flag = 1;
-		if (flag) {
-			line = format_expand(ft, template);
-			cmdq_print(item, "%s", line);
-			free(line);
-		}
+		line = format_expand(ft, template);
+		cmdq_print(item, "%s", line);
+		free(line);

 		format_free(ft);
+		n++;
 	}
 }
--- a/cmd-list-sessions.c
+++ b/cmd-list-sessions.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-sessions.c,v 1.37 2026/09/08 10:20:08 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -42,8 +42,8 @@ const struct cmd_entry cmd_list_sessions_entry = {
 	.name = "list-sessions",
 	.alias = "ls",

-	.args = { "F:f:O:r", 0, 0, NULL },
-	.usage = "[-r] [-F format] [-f filter] [-O order]",
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_sessions_exec
@@ -52,46 +52,28 @@ const struct cmd_entry cmd_list_sessions_entry = {
 static enum cmd_retval
 cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		 *args = cmd_get_args(self);
-	struct client		 *c = cmdq_get_client(item);
-	struct session		**l;
-	u_int		 	  n, i;
-	struct format_tree	 *ft;
-	const char		 *template, *filter;
-	char			 *line, *expanded;
-	int			  flag;
-	struct sort_criteria	  sort_crit;
+	struct args		*args = self->args;
+	struct session		*s;
+	u_int		 	 n;
+	struct format_tree	*ft;
+	const char		*template;
+	char			*line;

 	if ((template = args_get(args, 'F')) == NULL)
 		template = LIST_SESSIONS_TEMPLATE;
-	filter = args_get(args, 'f');

-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
+	n = 0;
+	RB_FOREACH(s, sessions, &sessions) {
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_add(ft, "line", "%u", n);
+		format_defaults(ft, NULL, s, NULL, NULL);

-	l = sort_get_sessions(&n, &sort_crit);
-	for (i = 0; i < n; i++) {
-		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-		format_add(ft, "line", "%u", i);
-		format_defaults(ft, c, l[i], NULL, NULL);
-
-		if (filter != NULL) {
-			expanded = format_expand(ft, filter);
-			flag = format_true(expanded);
-			free(expanded);
-		} else
-			flag = 1;
-		if (flag) {
-			line = format_expand(ft, template);
-			cmdq_print(item, "%s", line);
-			free(line);
-		}
+		line = format_expand(ft, template);
+		cmdq_print(item, "%s", line);
+		free(line);

 		format_free(ft);
+		n++;
 	}

 	return (CMD_RETURN_NORMAL);
--- a/cmd-list-windows.c
+++ b/cmd-list-windows.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-list-windows.c,v 1.51 2026/09/08 10:20:08 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -28,26 +28,29 @@
 */

 #define LIST_WINDOWS_TEMPLATE					\
-	"#{window_index}: #{window_name}#{window_raw_flags} "	\
+	"#{window_index}: #{window_name}#{window_flags} "	\
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "			\
 	"[layout #{window_layout}] #{window_id}"		\
 	"#{?window_active, (active),}";
 #define LIST_WINDOWS_WITH_SESSION_TEMPLATE			\
 	"#{session_name}:"					\
-	"#{window_index}: #{window_name}#{window_raw_flags} "	\
+	"#{window_index}: #{window_name}#{window_flags} "	\
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "

 static enum cmd_retval	cmd_list_windows_exec(struct cmd *, struct cmdq_item *);

+static void	cmd_list_windows_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_windows_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
+
 const struct cmd_entry cmd_list_windows_entry = {
 	.name = "list-windows",
 	.alias = "lsw",

-	.args = { "aF:f:O:rt:", 0, 0, NULL },
-	.usage = "[-ar] [-F format] [-f filter] [-O order]"
-		 CMD_TARGET_SESSION_USAGE,
+	.args = { "F:at:", 0, 0 },
+	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },

@@ -58,59 +61,59 @@ const struct cmd_entry cmd_list_windows_entry = {
 static enum cmd_retval
 cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*c = cmdq_get_client(item);
-	struct winlink		*wl, **l;
-	struct session		*s;
-	u_int			 i, n;
-	struct format_tree	*ft;
-	const char		*template, *filter;
-	char			*line, *expanded;
-	int			 flag;
-	struct sort_criteria	 sort_crit;
+	struct args	*args = self->args;

-	template = args_get(args, 'F');
-	filter = args_get(args, 'f');
-
-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
-
-	if (args_has(args, 'a')) {
-		l = sort_get_winlinks(&n, &sort_crit);
-		if (template == NULL)
-			template = LIST_WINDOWS_WITH_SESSION_TEMPLATE;
-	} else {
-		l = sort_get_winlinks_session(target->s, &n, &sort_crit);
-		if (template == NULL)
-			template = LIST_WINDOWS_TEMPLATE;
-	}
-
-	for (i = 0; i < n; i++) {
-		wl = l[i];
-		s = wl->session;
-		ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-		format_add(ft, "line", "%u", n);
-		format_defaults(ft, c, s, wl, NULL);
-
-		if (filter != NULL) {
-			expanded = format_expand(ft, filter);
-			flag = format_true(expanded);
-			free(expanded);
-		} else
-			flag = 1;
-		if (flag) {
-			line = format_expand(ft, template);
-			cmdq_print(item, "%s", line);
-			free(line);
-		}
-
-		format_free(ft);
-	}
+	if (args_has(args, 'a'))
+		cmd_list_windows_server(self, item);
+	else
+		cmd_list_windows_session(self, item->target.s, item, 0);

 	return (CMD_RETURN_NORMAL);
 }
+
+static void
+cmd_list_windows_server(struct cmd *self, struct cmdq_item *item)
+{
+	struct session	*s;
+
+	RB_FOREACH(s, sessions, &sessions)
+		cmd_list_windows_session(self, s, item, 1);
+}
+
+static void
+cmd_list_windows_session(struct cmd *self, struct session *s,
+    struct cmdq_item *item, int type)
+{
+	struct args		*args = self->args;
+	struct winlink		*wl;
+	u_int			 n;
+	struct format_tree	*ft;
+	const char		*template;
+	char			*line;
+
+	template = args_get(args, 'F');
+	if (template == NULL) {
+		switch (type) {
+		case 0:
+			template = LIST_WINDOWS_TEMPLATE;
+			break;
+		case 1:
+			template = LIST_WINDOWS_WITH_SESSION_TEMPLATE;
+			break;
+		}
+	}
+
+	n = 0;
+	RB_FOREACH(wl, winlinks, &s->windows) {
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
+		format_add(ft, "line", "%u", n);
+		format_defaults(ft, NULL, s, wl, NULL);
+
+		line = format_expand(ft, template);
+		cmdq_print(item, "%s", line);
+		free(line);
+
+		format_free(ft);
+		n++;
+	}
+}
--- a/cmd-load-buffer.c
+++ b/cmd-load-buffer.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-load-buffer.c,v 1.66 2025/10/28 07:32:26 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -37,15 +37,14 @@ const struct cmd_entry cmd_load_buffer_entry = {
 	.name = "load-buffer",
 	.alias = "loadb",

-	.args = { "b:t:w", 1, 1, NULL },
-	.usage = CMD_BUFFER_USAGE " " CMD_TARGET_CLIENT_USAGE " path",
+	.args = { "b:", 1, 1 },
+	.usage = CMD_BUFFER_USAGE " path",

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_load_buffer_exec
 };

 struct cmd_load_buffer_data {
-	struct client		*client;
 	struct cmdq_item	*item;
 	char			*name;
 };
@@ -55,7 +54,6 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
    int closed, struct evbuffer *buffer, void *data)
 {
 	struct cmd_load_buffer_data	*cdata = data;
-	struct client			*tc = cdata->client;
 	struct cmdq_item		*item = cdata->item;
 	void				*bdata = EVBUFFER_DATA(buffer);
 	size_t				 bsize = EVBUFFER_LENGTH(buffer);
@@ -66,7 +64,7 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
 		return;

 	if (error != 0)
-		cmdq_error(item, "%s: %s", strerror(error), path);
+		cmdq_error(item, "%s: %s", path, strerror(error));
 	else if (bsize != 0) {
 		copy = xmalloc(bsize);
 		memcpy(copy, bdata, bsize);
@@ -74,12 +72,7 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
 			cmdq_error(item, "%s", cause);
 			free(cause);
 			free(copy);
-		} else if (tc != NULL &&
-		    tc->session != NULL &&
-		    (~tc->flags & CLIENT_DEAD))
-			tty_set_selection(&tc->tty, "", copy, bsize);
-		if (tc != NULL)
-			server_client_unref(tc);
+		}
 	}
 	cmdq_continue(item);

@@ -90,23 +83,24 @@ cmd_load_buffer_done(__unused struct client *c, const char *path, int error,
 static enum cmd_retval
 cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct client			*tc = cmdq_get_target_client(item);
+	struct args			*args = self->args;
 	struct cmd_load_buffer_data	*cdata;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = item->target.wp;
 	const char			*bufname = args_get(args, 'b');
 	char				*path;

-	cdata = xcalloc(1, sizeof *cdata);
+	cdata = xmalloc(sizeof *cdata);
 	cdata->item = item;
 	if (bufname != NULL)
 		cdata->name = xstrdup(bufname);
-	if (args_has(args, 'w') && tc != NULL) {
-		cdata->client = tc;
-		cdata->client->references++;
-	}
+	else
+		cdata->name = NULL;

-	path = format_single_from_target(item, args_string(args, 0));
-	file_read(cmdq_get_client(item), path, cmd_load_buffer_done, cdata);
+	path = format_single(item, args->argv[0], c, s, wl, wp);
+	file_read(item->client, path, cmd_load_buffer_done, cdata);
 	free(path);

 	return (CMD_RETURN_WAIT);
--- a/cmd-lock-server.c
+++ b/cmd-lock-server.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-lock-server.c,v 1.31 2021/08/21 10:22:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -30,7 +30,7 @@ const struct cmd_entry cmd_lock_server_entry = {
 	.name = "lock-server",
 	.alias = "lock",

-	.args = { "", 0, 0, NULL },
+	.args = { "", 0, 0 },
 	.usage = "",

 	.flags = CMD_AFTERHOOK,
@@ -41,7 +41,7 @@ const struct cmd_entry cmd_lock_session_entry = {
 	.name = "lock-session",
 	.alias = "locks",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -54,25 +54,28 @@ const struct cmd_entry cmd_lock_client_entry = {
 	.name = "lock-client",
 	.alias = "lockc",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };

 static enum cmd_retval
 cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*tc = cmdq_get_target_client(item);
+	struct args	*args = self->args;
+	struct client	*c;

-	if (cmd_get_entry(self) == &cmd_lock_server_entry)
+	if (self->entry == &cmd_lock_server_entry)
 		server_lock();
-	else if (cmd_get_entry(self) == &cmd_lock_session_entry)
-		server_lock_session(target->s);
-	else
-		server_lock_client(tc);
+	else if (self->entry == &cmd_lock_session_entry)
+		server_lock_session(item->target.s);
+	else {
+		if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+			return (CMD_RETURN_ERROR);
+		server_lock_client(c);
+	}
 	recalculate_sizes();

 	return (CMD_RETURN_NORMAL);
--- a/cmd-move-window.c
+++ b/cmd-move-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-move-window.c,v 1.34 2021/08/21 10:22:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -32,8 +32,8 @@ const struct cmd_entry cmd_move_window_entry = {
 	.name = "move-window",
 	.alias = "movew",

-	.args = { "abdkrs:t:", 0, 0, NULL },
-	.usage = "[-abdkr] " CMD_SRCDST_WINDOW_USAGE,
+	.args = { "adkrs:t:", 0, 0 },
+	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,

 	.source = { 's', CMD_FIND_WINDOW, 0 },
 	/* -t is special */
@@ -46,8 +46,8 @@ const struct cmd_entry cmd_link_window_entry = {
 	.name = "link-window",
 	.alias = "linkw",

-	.args = { "abdks:t:", 0, 0, NULL },
-	.usage = "[-abdk] " CMD_SRCDST_WINDOW_USAGE,
+	.args = { "adks:t:", 0, 0 },
+	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,

 	.source = { 's', CMD_FIND_WINDOW, 0 },
 	/* -t is special */
@@ -59,53 +59,49 @@ const struct cmd_entry cmd_link_window_entry = {
 static enum cmd_retval
 cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct cmd_find_state	 target;
-	const char		*tflag = args_get(args, 't');
-	struct session		*src = source->s;
-	struct session		*dst;
-	struct winlink		*wl = source->wl;
-	char			*cause;
-	int			 idx, kflag, dflag, sflag, before;
+	struct args	*args = self->args;
+	const char	*tflag = args_get(args, 't');
+	struct session	*src;
+	struct session	*dst;
+	struct winlink	*wl;
+	char		*cause;
+	int		 idx, kflag, dflag, sflag;

 	if (args_has(args, 'r')) {
-		if (cmd_find_target(&target, item, tflag, CMD_FIND_SESSION,
-		    CMD_FIND_QUIET) != 0)
+		if (cmd_find_target(&item->target, item, tflag,
+		    CMD_FIND_SESSION, CMD_FIND_QUIET) != 0)
 			return (CMD_RETURN_ERROR);

-		session_renumber_windows(target.s);
+		session_renumber_windows(item->target.s);
 		recalculate_sizes();
-		server_status_session(target.s);
+		server_status_session(item->target.s);

 		return (CMD_RETURN_NORMAL);
 	}
-	if (cmd_find_target(&target, item, tflag, CMD_FIND_WINDOW,
+	if (cmd_find_target(&item->target, item, tflag, CMD_FIND_WINDOW,
 	    CMD_FIND_WINDOW_INDEX) != 0)
 		return (CMD_RETURN_ERROR);
-	dst = target.s;
-	idx = target.idx;
+	src = item->source.s;
+	dst = item->target.s;
+	wl = item->source.wl;
+	idx = item->target.idx;

-	kflag = args_has(args, 'k');
-	dflag = args_has(args, 'd');
-	sflag = args_has(args, 's');
+	kflag = args_has(self->args, 'k');
+	dflag = args_has(self->args, 'd');
+	sflag = args_has(self->args, 's');

-	before = args_has(args, 'b');
-	if (args_has(args, 'a') || before) {
-		if (target.wl != NULL)
-			idx = winlink_shuffle_up(dst, target.wl, before);
-		else
-			idx = winlink_shuffle_up(dst, dst->curw, before);
-		if (idx == -1)
+	if (args_has(self->args, 'a')) {
+		if ((idx = winlink_shuffle_up(dst, dst->curw)) == -1)
 			return (CMD_RETURN_ERROR);
 	}

-	if (server_link_window(src, wl, dst, idx, kflag, !dflag, &cause) != 0) {
-		cmdq_error(item, "%s", cause);
+	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
+	    &cause) != 0) {
+		cmdq_error(item, "can't link window: %s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
-	if (cmd_get_entry(self) == &cmd_move_window_entry)
+	if (self->entry == &cmd_move_window_entry)
 		server_unlink_window(src, wl);

 	/*
--- a/cmd-new-session.c
+++ b/cmd-new-session.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-new-session.c,v 1.152 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -39,11 +39,10 @@ const struct cmd_entry cmd_new_session_entry = {
 	.name = "new-session",
 	.alias = "new",

-	.args = { "Ac:dDe:EF:f:n:Ps:t:x:Xy:", 0, -1, NULL },
-	.usage = "[-AdDEPX] [-c start-directory] [-e environment] [-F format] "
-		 "[-f flags] [-n window-name] [-s session-name] "
-		 CMD_TARGET_SESSION_USAGE " [-x width] [-y height] "
-		 "[shell-command [argument ...]]",
+	.args = { "Ac:dDEF:n:Ps:t:x:Xy:", 0, -1 },
+	.usage = "[-AdDEPX] [-c start-directory] [-F format] [-n window-name] "
+		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
+		 "[-y height] [command]",

 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

@@ -55,7 +54,7 @@ const struct cmd_entry cmd_has_session_entry = {
 	.name = "has-session",
 	.alias = "has",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -67,26 +66,22 @@ const struct cmd_entry cmd_has_session_entry = {
 static enum cmd_retval
 cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*c = cmdq_get_client(item);
-	struct session		*s, *as, *groupwith = NULL;
+	struct args		*args = self->args;
+	struct client		*c = item->client;
+	struct session		*s, *as, *groupwith;
 	struct environ		*env;
 	struct options		*oo;
 	struct termios		 tio, *tiop;
-	struct session_group	*sg = NULL;
-	const char		*errstr, *template, *group, *tmp;
-	char			*cause, *cwd = NULL, *cp, *ename;
-	char			*wname = NULL, *sname = NULL, *prefix = NULL;
+	struct session_group	*sg;
+	const char		*errstr, *template, *group, *prefix, *tmp;
+	char			*cause, *cwd = NULL, *cp, *newname = NULL;
 	int			 detached, already_attached, is_control = 0;
-	u_int			 sx, sy, dsx, dsy, count = args_count(args);
-	struct spawn_context	 sc = { 0 };
+	u_int			 sx, sy, dsx, dsy;
+	struct spawn_context	 sc;
 	enum cmd_retval		 retval;
 	struct cmd_find_state    fs;
-	struct args_value	*av;

-	if (cmd_get_entry(self) == &cmd_has_session_entry) {
+	if (self->entry == &cmd_has_session_entry) {
 		/*
 		 * cmd_find_target() will fail if the session cannot be found,
 		 * so always return success here.
@@ -94,71 +89,59 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 't') && (count != 0 || args_has(args, 'n'))) {
+	if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n'))) {
 		cmdq_error(item, "command or window name given with target");
 		return (CMD_RETURN_ERROR);
 	}

-	if ((tmp = args_get(args, 'n')) != NULL) {
-		ename = format_single(item, tmp, c, NULL, NULL, NULL);
-		if (!check_name(ename)) {
-			cmdq_error(item, "invalid window name: %s", ename);
-			free(ename);
-			return (CMD_RETURN_ERROR);
-		}
-		wname = clean_name(ename, 0);
-		free(ename);
-	}
-	if ((tmp = args_get(args, 's')) != NULL) {
-		ename = format_single(item, tmp, c, NULL, NULL, NULL);
-		if (!check_name(ename)) {
-			cmdq_error(item, "invalid session name: %s", ename);
-			free(ename);
+	tmp = args_get(args, 's');
+	if (tmp != NULL) {
+		newname = format_single(item, tmp, c, NULL, NULL, NULL);
+		if (!session_check_name(newname)) {
+			cmdq_error(item, "bad session name: %s", newname);
 			goto fail;
 		}
-		sname = clean_name(ename, 0);
-		free(ename);
 	}
 	if (args_has(args, 'A')) {
-		if (sname != NULL)
-			as = session_find(sname);
+		if (newname != NULL)
+			as = session_find(newname);
 		else
-			as = target->s;
+			as = item->target.s;
 		if (as != NULL) {
 			retval = cmd_attach_session(item, as->name,
-			    args_has(args, 'D'), args_has(args, 'X'), 0,
-			    args_get(args, 'c'), args_has(args, 'E'),
-			    args_get(args, 'f'));
-			free(wname);
-			free(sname);
+			    args_has(args, 'D'), args_has(args, 'X'), 0, NULL,
+			    args_has(args, 'E'));
+			free(newname);
 			return (retval);
 		}
 	}
-	if (sname != NULL && session_find(sname) != NULL) {
-		cmdq_error(item, "duplicate session: %s", sname);
+	if (newname != NULL && session_find(newname) != NULL) {
+		cmdq_error(item, "duplicate session: %s", newname);
 		goto fail;
 	}

 	/* Is this going to be part of a session group? */
 	group = args_get(args, 't');
 	if (group != NULL) {
-		groupwith = target->s;
-		if (groupwith == NULL)
-			sg = session_group_find(group);
-		else
-			sg = session_group_contains(groupwith);
-		if (sg != NULL)
-			prefix = xstrdup(sg->name);
-		else if (groupwith != NULL)
-			prefix = xstrdup(groupwith->name);
-		else {
-			if (!check_name(group)) {
-				cmdq_error(item,
-				    "invalid session group name: %s", group);
+		groupwith = item->target.s;
+		if (groupwith == NULL) {
+			if (!session_check_name(group)) {
+				cmdq_error(item, "bad group name: %s", group);
 				goto fail;
 			}
-			prefix = clean_name(group, 0);
-		}
+			sg = session_group_find(group);
+		} else
+			sg = session_group_contains(groupwith);
+		if (sg != NULL)
+			prefix = sg->name;
+		else if (groupwith != NULL)
+			prefix = groupwith->name;
+		else
+			prefix = group;
+	} else {
+		groupwith = NULL;
+		sg = NULL;
+		prefix = NULL;
 	}

 	/* Set -d if no client. */
@@ -188,16 +171,13 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	 * the terminal as that calls tcsetattr() to prepare for tmux taking
 	 * over.
 	 */
-	if (!detached &&
-	    !already_attached &&
-	    c->fd != -1 &&
-	    (~c->flags & CLIENT_CONTROL)) {
-		if (server_client_check_nested(cmdq_get_client(item))) {
+	if (!detached && !already_attached && c->tty.fd != -1) {
+		if (server_client_check_nested(item->client)) {
 			cmdq_error(item, "sessions should be nested with care, "
 			    "unset $TMUX to force");
 			goto fail;
 		}
-		if (tcgetattr(c->fd, &tio) != 0)
+		if (tcgetattr(c->tty.fd, &tio) != 0)
 			fatal("tcgetattr failed");
 		tiop = &tio;
 	} else
@@ -227,8 +207,7 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 				goto fail;
 			}
 		}
-	} else
-		dsx = 80;
+	}
 	if (args_has(args, 'y')) {
 		tmp = args_get(args, 'y');
 		if (strcmp(tmp, "-") == 0) {
@@ -243,8 +222,7 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 				goto fail;
 			}
 		}
-	} else
-		dsy = 24;
+	}

 	/* Find new session size. */
 	if (!detached && !is_control) {
@@ -255,14 +233,13 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	} else {
 		tmp = options_get_string(global_s_options, "default-size");
 		if (sscanf(tmp, "%ux%u", &sx, &sy) != 2) {
-			sx = dsx;
-			sy = dsy;
-		} else {
-			if (args_has(args, 'x'))
-				sx = dsx;
-			if (args_has(args, 'y'))
-				sy = dsy;
+			sx = 80;
+			sy = 24;
 		}
+		if (args_has(args, 'x'))
+			sx = dsx;
+		if (args_has(args, 'y'))
+			sy = dsy;
 	}
 	if (sx == 0)
 		sx = 1;
@@ -281,21 +258,17 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 	env = environ_create();
 	if (c != NULL && !args_has(args, 'E'))
 		environ_update(global_s_options, c->environ, env);
-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(env, av->string, 0);
-		av = args_next_value(av);
-	}
-	s = session_create(prefix, sname, cwd, env, oo, tiop);
+	s = session_create(prefix, newname, cwd, env, oo, tiop);

 	/* Spawn the initial window. */
+	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
-	if (!detached)
-		sc.tc = c;
+	sc.c = c;

-	sc.name = wname;
-	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.name = args_get(args, 'n');
+	sc.argc = args->argc;
+	sc.argv = args->argv;

 	sc.idx = -1;
 	sc.cwd = args_get(args, 'c');
@@ -325,24 +298,37 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		session_group_synchronize_to(s);
 		session_select(s, RB_MIN(winlinks, &s->windows)->idx);
 	}
-	events_fire_session("session-created", s);
+	notify_session("session-created", s);

 	/*
 	 * Set the client to the new session. If a command client exists, it is
 	 * taking this session and needs to get MSG_READY and stay around.
 	 */
 	if (!detached) {
-		if (args_has(args, 'f'))
-			server_client_set_flags(c, args_get(args, 'f'));
 		if (!already_attached) {
 			if (~c->flags & CLIENT_CONTROL)
 				proc_send(c->peer, MSG_READY, -1, NULL, 0);
 		} else if (c->session != NULL)
 			c->last_session = c->session;
-		server_client_set_session(c, s);
-		if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
+		c->session = s;
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
 			server_client_set_key_table(c, NULL);
+		tty_update_client_offset(c);
+		status_timer_start(c);
+		notify_client("client-session-changed", c);
+		session_update_activity(s, NULL);
+		gettimeofday(&s->last_attached_time, NULL);
+		server_redraw_client(c);
 	}
+	recalculate_sizes();
+	server_update_socket();
+
+	/*
+	 * If there are still configuration file errors to display, put the new
+	 * session's current window into more mode and display them now.
+	 */
+	if (cfg_finished)
+		cfg_show_causes(s);

 	/* Print if requested. */
 	if (args_has(args, 'P')) {
@@ -353,31 +339,20 @@ cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 		free(cp);
 	}

-	if (!detached)
+	if (!detached) {
 		c->flags |= CLIENT_ATTACHED;
-	if (!args_has(args, 'd'))
-		cmd_find_from_session(current, s, 0);
+		cmd_find_from_session(&item->shared->current, s, 0);
+	}

 	cmd_find_from_session(&fs, s, 0);
 	cmdq_insert_hook(s, item, &fs, "after-new-session");

-	if (cfg_finished)
-		cfg_show_causes(s);
-
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	free(cwd);
-	free(wname);
-	free(sname);
-	free(prefix);
+	free(newname);
 	return (CMD_RETURN_NORMAL);

 fail:
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	free(cwd);
-	free(wname);
-	free(sname);
-	free(prefix);
+	free(newname);
 	return (CMD_RETURN_ERROR);
 }
--- a/cmd-new-window.c
+++ b/cmd-new-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-new-window.c,v 1.104 2026/09/03 21:04:11 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -38,10 +38,9 @@ const struct cmd_entry cmd_new_window_entry = {
 	.name = "new-window",
 	.alias = "neww",

-	.args = { "abc:de:EF:kn:PSt:", 0, -1, NULL },
-	.usage = "[-abdEkPS] [-c start-directory] [-e environment] [-F format] "
-		 "[-n window-name] " CMD_TARGET_WINDOW_USAGE
-		 " [shell-command [argument ...]]",
+	.args = { "ac:de:F:kn:Pt:", 0, -1 },
+	.usage = "[-adkP] [-c start-directory] [-e environment] [-F format] "
+		 "[-n window-name] " CMD_TARGET_WINDOW_USAGE " [command]",

 	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },

@@ -52,107 +51,44 @@ const struct cmd_entry cmd_new_window_entry = {
 static enum cmd_retval
 cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmdq_get_client(item);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct spawn_context	 sc = { 0 };
-	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl, *new_wl = NULL;
-	int			 idx = target->idx, before;
-	int			 count = args_count(args);
-	char			*cause = NULL, *cp, *expanded, *wname = NULL;
-	const char		*template, *name;
+	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct spawn_context	 sc;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	int			 idx = item->target.idx;
+	struct winlink		*new_wl;
+	char			*cause = NULL, *cp;
+	const char		*template, *add;
 	struct cmd_find_state	 fs;
-	struct args_value	*av;
+	struct args_value	*value;

-	if (args_has(args, 'E') &&
-	    count != 0 &&
-	    (count != 1 || *args_string(args, 0) != '\0')) {
-		cmdq_error(item, "command cannot be given for empty pane");
+	if (args_has(args, 'a') && (idx = winlink_shuffle_up(s, wl)) == -1) {
+		cmdq_error(item, "couldn't get a window index");
 		return (CMD_RETURN_ERROR);
 	}

-	/*
-	 * If -S is given, select an existing window instead of creating a
-	 * new one: preferring -t if it already points at a window, or
-	 * otherwise -n if one exists with that name. If neither matches,
-	 * fall through and create a window as normal.
-	 */
-	name = args_get(args, 'n');
-	if (name != NULL) {
-		expanded = format_single(item, name, c, s, NULL, NULL);
-		if (!check_name(expanded)) {
-			cmdq_error(item, "invalid window name: %s", expanded);
-			free(expanded);
-			return (CMD_RETURN_ERROR);
-		}
-		wname = clean_name(expanded, 0);
-		free(expanded);
-	}
-	if (args_has(args, 'S')) {
-		if (idx != -1)
-			new_wl = winlink_find_by_index(&s->windows, idx);
-		else if (wname != NULL) {
-			expanded = format_single(item, wname, c, s, NULL, NULL);
-			RB_FOREACH(wl, winlinks, &s->windows) {
-				if (strcmp(wl->window->name, expanded) != 0)
-					continue;
-				if (new_wl == NULL) {
-					new_wl = wl;
-					continue;
-				}
-				cmdq_error(item, "multiple windows named %s",
-				    wname);
-				free(wname);
-				free(expanded);
-				return (CMD_RETURN_ERROR);
-			}
-			free(expanded);
-		}
-	}
-
-	/* Found an existing window to select instead of creating a new one. */
-	if (new_wl != NULL) {
-		free(wname);
-		if (args_has(args, 'd'))
-			return (CMD_RETURN_NORMAL);
-		if (session_set_current(s, new_wl) == 0)
-			server_redraw_session(s);
-		if (c != NULL && c->session != NULL)
-			s->curw->window->latest = c;
-		recalculate_sizes();
-		return (CMD_RETURN_NORMAL);
-	}
-
-	before = args_has(args, 'b');
-	if (args_has(args, 'a') || before) {
-		idx = winlink_shuffle_up(s, wl, before);
-		if (idx == -1)
-			idx = target->idx;
-	}
-
+	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
-	sc.tc = tc;
+	sc.c = c;

-	sc.name = wname;
-	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.name = args_get(args, 'n');
+	sc.argc = args->argc;
+	sc.argv = args->argv;
 	sc.environ = environ_create();

-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(sc.environ, av->string, 0);
-		av = args_next_value(av);
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}

 	sc.idx = idx;
 	sc.cwd = args_get(args, 'c');

 	sc.flags = 0;
-	if (args_has(args, 'E') || (count == 1 && *args_string(args, 0) == '\0'))
-		sc.flags |= SPAWN_EMPTY;
 	if (args_has(args, 'd'))
 		sc.flags |= SPAWN_DETACHED;
 	if (args_has(args, 'k'))
@@ -161,7 +97,7 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	if ((new_wl = spawn_window(&sc, &cause)) == NULL) {
 		cmdq_error(item, "create window failed: %s", cause);
 		free(cause);
-		goto fail;
+		return (CMD_RETURN_ERROR);
 	}
 	if (!args_has(args, 'd') || new_wl == s->curw) {
 		cmd_find_from_winlink(current, new_wl, 0);
@@ -172,8 +108,8 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_WINDOW_TEMPLATE;
-		cp = format_single(item, template, tc, s, new_wl,
-			new_wl->window->active);
+		cp = format_single(item, template, c, s, new_wl,
+		    new_wl->window->active);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}
@@ -181,16 +117,6 @@ cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 	cmd_find_from_winlink(&fs, new_wl, 0);
 	cmdq_insert_hook(s, item, &fs, "after-new-window");

-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	environ_free(sc.environ);
-	free(wname);
 	return (CMD_RETURN_NORMAL);
-
-fail:
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
-	environ_free(sc.environ);
-	free(wname);
-	return (CMD_RETURN_ERROR);
 }
--- a/cmd-parse.y
+++ b/cmd-parse.y
--- a/cmd-paste-buffer.c
+++ b/cmd-paste-buffer.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-paste-buffer.c,v 1.44 2026/03/04 07:19:32 tb Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,8 +33,8 @@ const struct cmd_entry cmd_paste_buffer_entry = {
 	.name = "paste-buffer",
 	.alias = "pasteb",

-	.args = { "db:prSs:t:", 0, 0, NULL },
-	.usage = "[-dprS] [-s separator] " CMD_BUFFER_USAGE " "
+	.args = { "db:prs:t:", 0, 0 },
+	.usage = "[-dpr] [-s separator] " CMD_BUFFER_USAGE " "
 		 CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -43,33 +43,16 @@ const struct cmd_entry cmd_paste_buffer_entry = {
 	.exec = cmd_paste_buffer_exec
 };

-static void
-cmd_paste_buffer_paste(struct window_pane *wp, const char *buf, size_t len)
-{
-	char	*cp;
-	size_t	 n;
-
-	n = utf8_stravisx(&cp, buf, len, VIS_SAFE|VIS_NOSLASH);
-	bufferevent_write(wp->event, cp, n);
-	free(cp);
-}
-
 static enum cmd_retval
 cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct window_pane	*wp = target->wp;
+	struct args		*args = self->args;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
 	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
-	size_t			 seplen, bufsize, len;
+	size_t			 seplen, bufsize;
 	int			 bracket = args_has(args, 'p');

-	if (window_pane_exited(wp)) {
-		cmdq_error(item, "target pane has exited");
-		return (CMD_RETURN_ERROR);
-	}
-
 	bufname = NULL;
 	if (args_has(args, 'b'))
 		bufname = args_get(args, 'b');
@@ -104,22 +87,14 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 			line = memchr(bufdata, '\n', bufend - bufdata);
 			if (line == NULL)
 				break;
-			len = line - bufdata;
-			if (args_has(args, 'S'))
-				bufferevent_write(wp->event, bufdata, len);
-			else
-				cmd_paste_buffer_paste(wp, bufdata, len);
+
+			bufferevent_write(wp->event, bufdata, line - bufdata);
 			bufferevent_write(wp->event, sepstr, seplen);

 			bufdata = line + 1;
 		}
-		if (bufdata != bufend) {
-			len = bufend - bufdata;
-			if (args_has(args, 'S'))
-				bufferevent_write(wp->event, bufdata, len);
-			else
-				cmd_paste_buffer_paste(wp, bufdata, len);
-		}
+		if (bufdata != bufend)
+			bufferevent_write(wp->event, bufdata, bufend - bufdata);

 		if (bracket && (wp->screen->mode & MODE_BRACKETPASTE))
 			bufferevent_write(wp->event, "\033[201~", 6);
--- a/cmd-pipe-pane.c
+++ b/cmd-pipe-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-pipe-pane.c,v 1.64 2026/07/27 14:25:46 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -43,8 +43,8 @@ const struct cmd_entry cmd_pipe_pane_entry = {
 	.name = "pipe-pane",
 	.alias = "pipep",

-	.args = { "IOot:", 0, 1, NULL },
-	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [shell-command]",
+	.args = { "IOot:", 0, 1 },
+	.usage = "[-IOo] " CMD_TARGET_PANE_USAGE " [command]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -55,23 +55,15 @@ const struct cmd_entry cmd_pipe_pane_entry = {
 static enum cmd_retval
 cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct client			*tc = cmdq_get_target_client(item);
-	struct window_pane		*wp = target->wp;
-	struct session			*s = target->s;
-	struct winlink			*wl = target->wl;
-	struct window_pane_offset	*wpo = &wp->pipe_offset;
-	char				*cmd;
-	int				 old_fd, pipe_fd[2], null_fd, in, out;
-	struct format_tree		*ft;
-	sigset_t			 set, oldset;
-
-	/* Do nothing if pane is dead. */
-	if (window_pane_exited(wp)) {
-		cmdq_error(item, "target pane has exited");
-		return (CMD_RETURN_ERROR);
-	}
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	char			*cmd;
+	int			 old_fd, pipe_fd[2], null_fd, in, out;
+	struct format_tree	*ft;
+	sigset_t		 set, oldset;

 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -87,7 +79,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	/* If no pipe command, that is enough. */
-	if (args_count(args) == 0 || *args_string(args, 0) == '\0')
+	if (args->argc == 0 || *args->argv[0] == '\0')
 		return (CMD_RETURN_NORMAL);

 	/*
@@ -96,13 +88,13 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	 *
 	 *	bind ^p pipep -o 'cat >>~/output'
 	 */
-	if (args_has(args, 'o') && old_fd != -1)
+	if (args_has(self->args, 'o') && old_fd != -1)
 		return (CMD_RETURN_NORMAL);

 	/* What do we want to do? Neither -I or -O is -O. */
-	if (args_has(args, 'I')) {
+	if (args_has(self->args, 'I')) {
 		in = 1;
-		out = args_has(args, 'O');
+		out = args_has(self->args, 'O');
 	} else {
 		in = 0;
 		out = 1;
@@ -115,21 +107,19 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	/* Expand the command. */
-	ft = format_create(cmdq_get_client(item), item, FORMAT_NONE, 0);
-	format_defaults(ft, tc, s, wl, wp);
-	cmd = format_expand_time(ft, args_string(args, 0));
+	ft = format_create(item->client, item, FORMAT_NONE, 0);
+	format_defaults(ft, c, s, wl, wp);
+	cmd = format_expand_time(ft, args->argv[0]);
 	format_free(ft);

 	/* Fork the child. */
 	sigfillset(&set);
 	sigprocmask(SIG_BLOCK, &set, &oldset);
-	switch ((wp->pipe_pid = fork())) {
+	switch (fork()) {
 	case -1:
 		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		cmdq_error(item, "fork error: %s", strerror(errno));

-		close(pipe_fd[0]);
-		close(pipe_fd[1]);
 		free(cmd);
 		return (CMD_RETURN_ERROR);
 	case 0:
@@ -138,10 +128,7 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[0]);

-		if (setpgid(0, 0) == -1)
-			_exit(1);
-
-		null_fd = open(_PATH_DEVNULL, O_WRONLY);
+		null_fd = open(_PATH_DEVNULL, O_WRONLY, 0);
 		if (out) {
 			if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
 				_exit(1);
@@ -170,7 +157,10 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 		close(pipe_fd[1]);

 		wp->pipe_fd = pipe_fd[0];
-		memcpy(wpo, &wp->offset, sizeof *wpo);
+		if (wp->fd != -1)
+			wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
+		else
+			wp->pipe_off = 0;

 		setblocking(wp->pipe_fd, 0);
 		wp->pipe_event = bufferevent_new(wp->pipe_fd,
@@ -194,13 +184,9 @@ static void
 cmd_pipe_pane_read_callback(__unused struct bufferevent *bufev, void *data)
 {
 	struct window_pane	*wp = data;
-	struct evbuffer		*evb;
+	struct evbuffer		*evb = wp->pipe_event->input;
 	size_t			 available;

-	if (wp->pipe_event == NULL)
-		return;
-	evb = wp->pipe_event->input;
-
 	available = EVBUFFER_LENGTH(evb);
 	log_debug("%%%u pipe read %zu", wp->id, available);

--- a/cmd-queue.c
+++ b/cmd-queue.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-queue.c,v 1.123 2026/08/24 20:34:26 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -19,77 +19,14 @@
 #include <sys/types.h>

 #include <ctype.h>
-#include <pwd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>

 #include "tmux.h"

-/* Command queue flags. */
-#define CMDQ_FIRED 0x1
-#define CMDQ_WAITING 0x2
-
-/* Command queue item type. */
-enum cmdq_type {
-	CMDQ_COMMAND,
-	CMDQ_CALLBACK,
-};
-
-/* Command queue item. */
-struct cmdq_item {
-	char			*name;
-	struct cmdq_list	*queue;
-	struct cmdq_item	*next;
-
-	struct client		*client;
-	struct client		*target_client;
-
-	enum cmdq_type		 type;
-	u_int			 group;
-
-	u_int			 number;
-	time_t			 time;
-
-	int			 flags;
-
-	struct cmdq_state	*state;
-	struct cmd_find_state	 source;
-	struct cmd_find_state	 target;
-
-	struct cmd_list		*cmdlist;
-	struct cmd		*cmd;
-
-	cmdq_cb			 cb;
-	void			*data;
-
-	TAILQ_ENTRY(cmdq_item)	 entry;
-};
-TAILQ_HEAD(cmdq_item_list, cmdq_item);
-
-/*
- * Command queue state. This is the context for commands on the command queue.
- * It holds information about how the commands were fired (the key and flags),
- * any additional formats for the commands, and the current default target.
- * Multiple commands can share the same state and a command may update the
- * default target.
- */
-struct cmdq_state {
-	int			 references;
-	int			 flags;
-
-	struct format_tree	*formats;
-
-	struct key_event	 event;
-	struct cmd_find_state	 current;
-};
-
-/* Command queue. */
-struct cmdq_list {
-	struct cmdq_item	*item;
-	struct cmdq_item_list	 list;
-};
+/* Global command queue. */
+static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);

 /* Get command queue name. */
 static const char *
@@ -110,197 +47,9 @@ cmdq_name(struct client *c)
 static struct cmdq_list *
 cmdq_get(struct client *c)
 {
-	static struct cmdq_list *global_queue;
-
-	if (c == NULL) {
-		if (global_queue == NULL)
-			global_queue = cmdq_new();
-		return (global_queue);
-	}
-	return (c->queue);
-}
-
-/* Create a queue. */
-struct cmdq_list *
-cmdq_new(void)
-{
-	struct cmdq_list	*queue;
-
-	queue = xcalloc(1, sizeof *queue);
-	TAILQ_INIT (&queue->list);
-	return (queue);
-}
-
-/* Free a queue. */
-void
-cmdq_free(struct cmdq_list *queue)
-{
-	if (!TAILQ_EMPTY(&queue->list))
-		fatalx("queue not empty");
-	free(queue);
-}
-
-/* Get item name. */
-const char *
-cmdq_get_name(struct cmdq_item *item)
-{
-	return (item->name);
-}
-
-/* Get item command. */
-struct cmd *
-cmdq_get_cmd(struct cmdq_item *item)
-{
-	return (item->cmd);
-}
-
-/* Get item client. */
-struct client *
-cmdq_get_client(struct cmdq_item *item)
-{
-	return (item->client);
-}
-
-/* Get item target client. */
-struct client *
-cmdq_get_target_client(struct cmdq_item *item)
-{
-	return (item->target_client);
-}
-
-/* Get item state. */
-struct cmdq_state *
-cmdq_get_state(struct cmdq_item *item)
-{
-	return (item->state);
-}
-
-/* Get item target. */
-struct cmd_find_state *
-cmdq_get_target(struct cmdq_item *item)
-{
-	return (&item->target);
-}
-
-/* Get item source. */
-struct cmd_find_state *
-cmdq_get_source(struct cmdq_item *item)
-{
-	return (&item->source);
-}
-
-/* Get state event. */
-struct key_event *
-cmdq_get_event(struct cmdq_item *item)
-{
-	return (&item->state->event);
-}
-
-/* Get state current target. */
-struct cmd_find_state *
-cmdq_get_current(struct cmdq_item *item)
-{
-	return (&item->state->current);
-}
-
-/* Get state flags. */
-int
-cmdq_get_flags(struct cmdq_item *item)
-{
-	return (item->state->flags);
-}
-
-/* Create a new state. */
-struct cmdq_state *
-cmdq_new_state(struct cmd_find_state *current, struct key_event *event,
-    int flags)
-{
-	struct cmdq_state	*state;
-
-	state = xcalloc(1, sizeof *state);
-	state->references = 1;
-	state->flags = flags;
-
-	if (event != NULL)
-		memcpy(&state->event, event, sizeof state->event);
-	else
-		state->event.key = KEYC_NONE;
-	if (current != NULL && cmd_find_valid_state(current))
-		cmd_find_copy_state(&state->current, current);
-	else
-		cmd_find_clear_state(&state->current, 0);
-
-	return (state);
-}
-
-/* Add a reference to a state. */
-struct cmdq_state *
-cmdq_link_state(struct cmdq_state *state)
-{
-	state->references++;
-	return (state);
-}
-
-/* Make a copy of a state. */
-struct cmdq_state *
-cmdq_copy_state(struct cmdq_state *state, struct cmd_find_state *current)
-{
-	if (current != NULL)
-		return (cmdq_new_state(current, &state->event, state->flags));
-	return (cmdq_new_state(&state->current, &state->event, state->flags));
-}
-
-/* Free a state. */
-void
-cmdq_free_state(struct cmdq_state *state)
-{
-	if (--state->references != 0)
-		return;
-
-	if (state->formats != NULL)
-		format_free(state->formats);
-	free(state);
-}
-
-/* Add a format to command queue. */
-void
-cmdq_add_format(struct cmdq_state *state, const char *key, const char *fmt, ...)
-{
-	va_list	 ap;
-	char	*value;
-
-	va_start(ap, fmt);
-	xvasprintf(&value, fmt, ap);
-	va_end(ap);
-
-	if (state->formats == NULL)
-		state->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
-	format_add(state->formats, key, "%s", value);
-
-	free(value);
-}
-
-/* Add formats to command queue. */
-void
-cmdq_add_formats(struct cmdq_state *state, struct format_tree *ft)
-{
-	if (state->formats == NULL)
-		state->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
-	format_merge(state->formats, ft);
-}
-
-/* Merge formats from item. */
-void
-cmdq_merge_formats(struct cmdq_item *item, struct format_tree *ft)
-{
-	const struct cmd_entry	*entry;
-
-	if (item->cmd != NULL) {
-		entry = cmd_get_entry(item->cmd);
-		format_add(ft, "command", "%s", entry->name);
-	}
-	if (item->state->formats != NULL)
-		format_merge(ft, item->state->formats);
+	if (c == NULL)
+		return (&global_queue);
+	return (&c->queue);
 }

 /* Append an item. */
@@ -319,12 +68,12 @@ cmdq_append(struct client *c, struct cmdq_item *item)
 		item->client = c;

 		item->queue = queue;
-		TAILQ_INSERT_TAIL(&queue->list, item, entry);
+		TAILQ_INSERT_TAIL(queue, item, entry);
 		log_debug("%s %s: %s", __func__, cmdq_name(c), item->name);

 		item = next;
 	} while (item != NULL);
-	return (TAILQ_LAST(&queue->list, cmdq_item_list));
+	return (TAILQ_LAST(queue, cmdq_list));
 }

 /* Insert an item. */
@@ -345,7 +94,7 @@ cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
 		item->client = c;

 		item->queue = queue;
-		TAILQ_INSERT_AFTER(&queue->list, after, item, entry);
+		TAILQ_INSERT_AFTER(queue, after, item, entry);
 		log_debug("%s %s: %s after %s", __func__, cmdq_name(c),
 		    item->name, after->name);

@@ -357,61 +106,53 @@ cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)

 /* Insert a hook. */
 void
-cmdq_insert_hook(__unused struct session *s, struct cmdq_item *item,
-    struct cmd_find_state *current, const char *fmt, ...)
+cmdq_insert_hook(struct session *s, struct cmdq_item *item,
+    struct cmd_find_state *fs, const char *fmt, ...)
 {
-	struct cmd			*cmd = item->cmd;
-	struct args			*args = cmd_get_args(cmd);
-	struct args_entry		*ae;
-	struct args_value		*av;
-	struct event_payload		*ep;
+	struct options			*oo;
 	va_list				 ap;
-	char				*name, tmp[32], flag, *arguments;
-	u_int				 i;
-	const char			*value;
+	char				*name;
+	struct cmdq_item		*new_item;
+	struct options_entry		*o;
+	struct options_array_item	*a;
+	struct cmd_list			*cmdlist;

-	if (item->state->flags & CMDQ_STATE_NOHOOKS)
+	if (item->flags & CMDQ_NOHOOKS)
 		return;
+	if (s == NULL)
+		oo = global_s_options;
+	else
+		oo = s->options;

 	va_start(ap, fmt);
 	xvasprintf(&name, fmt, ap);
 	va_end(ap);

-	ep = event_payload_create();
-	if (current != NULL)
-		event_payload_set_target(ep, current);
-	event_payload_set_pointer(ep, "_cmdq_item", item, NULL, NULL);
-
-	arguments = args_print(args);
-	event_payload_set_string(ep, "arguments", "%s", arguments);
-	free(arguments);
-
-	for (i = 0; i < args_count(args); i++) {
-		xsnprintf(tmp, sizeof tmp, "argument_%u", i);
-		event_payload_set_string(ep, tmp, "%s", args_string(args, i));
+	o = options_get(oo, name);
+	if (o == NULL) {
+		free(name);
+		return;
 	}
-	flag = args_first(args, &ae);
-	while (flag != 0) {
-		value = args_get(args, flag);
-		xsnprintf(tmp, sizeof tmp, "flag_%c", flag);
-		if (value == NULL)
-			event_payload_set_string(ep, tmp, "1");
-		else
-			event_payload_set_string(ep, tmp, "%s", value);
+	log_debug("running hook %s (parent %p)", name, item);

-		i = 0;
-		av = args_first_value(args, flag);
-		while (av != NULL) {
-			xsnprintf(tmp, sizeof tmp, "flag_%c_%u", flag, i);
-			event_payload_set_string(ep, tmp, "%s", av->string);
-			i++;
-			av = args_next_value(av);
+	a = options_array_first(o);
+	while (a != NULL) {
+		cmdlist = options_array_item_value(a)->cmdlist;
+		if (cmdlist == NULL) {
+			a = options_array_next(a);
+			continue;
 		}

-		flag = args_next(&ae);
+		new_item = cmdq_get_command(cmdlist, fs, NULL, CMDQ_NOHOOKS);
+		cmdq_format(new_item, "hook", "%s", name);
+		if (item != NULL)
+			item = cmdq_insert_after(item, new_item);
+		else
+			item = cmdq_append(NULL, new_item);
+
+		a = options_array_next(a);
 	}

-	events_fire(name, ep);
 	free(name);
 }

@@ -426,13 +167,19 @@ cmdq_continue(struct cmdq_item *item)
 static void
 cmdq_remove(struct cmdq_item *item)
 {
+	if (item->shared != NULL && --item->shared->references == 0) {
+		if (item->shared->formats != NULL)
+			format_free(item->shared->formats);
+		free(item->shared);
+	}
+
 	if (item->client != NULL)
 		server_client_unref(item->client);
+
 	if (item->cmdlist != NULL)
 		cmd_list_free(item->cmdlist);
-	cmdq_free_state(item->state);

-	TAILQ_REMOVE(&item->queue->list, item, entry);
+	TAILQ_REMOVE(item->queue, item, entry);

 	free(item->name);
 	free(item);
@@ -455,57 +202,50 @@ cmdq_remove_group(struct cmdq_item *item)
 	}
 }

-/* Empty command callback. */
-static enum cmd_retval
-cmdq_empty_command(__unused struct cmdq_item *item, __unused void *data)
-{
-	return (CMD_RETURN_NORMAL);
-}
-
 /* Get a command for the command queue. */
 struct cmdq_item *
-cmdq_get_command(struct cmd_list *cmdlist, struct cmdq_state *state)
+cmdq_get_command(struct cmd_list *cmdlist, struct cmd_find_state *current,
+    struct mouse_event *m, int flags)
 {
 	struct cmdq_item	*item, *first = NULL, *last = NULL;
 	struct cmd		*cmd;
-	const struct cmd_entry	*entry;
-	int			 created = 0;
+	struct cmdq_shared	*shared = NULL;
+	u_int			 group = 0;

-	if ((cmd = cmd_list_first(cmdlist)) == NULL)
-		return (cmdq_get_callback(cmdq_empty_command, NULL));
-
-	if (state == NULL) {
-		state = cmdq_new_state(NULL, NULL, 0);
-		created = 1;
-	}
-
-	while (cmd != NULL) {
-		entry = cmd_get_entry(cmd);
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		if (cmd->group != group) {
+			shared = xcalloc(1, sizeof *shared);
+			if (current != NULL)
+				cmd_find_copy_state(&shared->current, current);
+			else
+				cmd_find_clear_state(&shared->current, 0);
+			if (m != NULL)
+				memcpy(&shared->mouse, m, sizeof shared->mouse);
+			group = cmd->group;
+		}

 		item = xcalloc(1, sizeof *item);
-		xasprintf(&item->name, "[%s/%p]", entry->name, item);
+		xasprintf(&item->name, "[%s/%p]", cmd->entry->name, item);
 		item->type = CMDQ_COMMAND;

-		item->group = cmd_get_group(cmd);
-		item->state = cmdq_link_state(state);
+		item->group = cmd->group;
+		item->flags = flags;

+		item->shared = shared;
 		item->cmdlist = cmdlist;
 		item->cmd = cmd;

-		cmdlist->references++;
 		log_debug("%s: %s group %u", __func__, item->name, item->group);

+		shared->references++;
+		cmdlist->references++;
+
 		if (first == NULL)
 			first = item;
 		if (last != NULL)
 			last->next = item;
 		last = item;
-
-		cmd = cmd_list_next(cmd);
 	}
-
-	if (created)
-		cmdq_free_state(state);
 	return (first);
 }

@@ -517,11 +257,11 @@ cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
 	const char	*value;

 	if (flag->flag == 0) {
-		cmd_find_from_client(fs, item->target_client, 0);
+		cmd_find_clear_state(fs, 0);
 		return (CMD_RETURN_NORMAL);
 	}

-	value = args_get(cmd_get_args(item->cmd), flag->flag);
+	value = args_get(item->cmd->args, flag->flag);
 	if (cmd_find_target(fs, item, value, flag->type, flag->flags) != 0) {
 		cmd_find_clear_state(fs, 0);
 		return (CMD_RETURN_ERROR);
@@ -529,89 +269,31 @@ cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
 	return (CMD_RETURN_NORMAL);
 }

-/* Add message with command. */
-static void
-cmdq_add_message(struct cmdq_item *item)
-{
-	struct client		*c = item->client;
-	struct cmdq_state	*state = item->state;
-	const char		*key;
-	char			*tmp;
-	uid_t                    uid;
-	struct passwd		*pw;
-	char                    *user = NULL;
-
-	tmp = cmd_print(item->cmd);
-	if (c != NULL) {
-		uid = proc_get_peer_uid(c->peer);
-		if (uid != (uid_t)-1 && uid != getuid()) {
-			if ((pw = getpwuid(uid)) != NULL)
-				xasprintf(&user, "[%s]", pw->pw_name);
-			else
-				user = xstrdup("[unknown]");
-		} else
-			user = xstrdup("");
-		if (c->session != NULL && state->event.key != KEYC_NONE) {
-			key = key_string_lookup_key(state->event.key, 0);
-			server_add_message("%s%s key %s: %s", c->name, user,
-			    key, tmp);
-		} else {
-			server_add_message("%s%s command: %s", c->name, user,
-			    tmp);
-		}
-		free(user);
-	} else
-		server_add_message("command: %s", tmp);
-	free(tmp);
-}
-
 /* Fire command on command queue. */
 static enum cmd_retval
 cmdq_fire_command(struct cmdq_item *item)
 {
-	const char		*name = cmdq_name(item->client);
-	struct cmdq_state	*state = item->state;
+	struct client		*c = item->client;
+	const char		*name = cmdq_name(c);
+	struct cmdq_shared	*shared = item->shared;
 	struct cmd		*cmd = item->cmd;
-	struct args		*args = cmd_get_args(cmd);
-	const struct cmd_entry	*entry = cmd_get_entry(cmd);
-	struct client		*tc, *saved = item->client;
+	const struct cmd_entry	*entry = cmd->entry;
 	enum cmd_retval		 retval;
 	struct cmd_find_state	*fsp, fs;
-	int			 flags, quiet = 0;
+	int			 flags;
 	char			*tmp;

-	if (cfg_finished)
-		cmdq_add_message(item);
 	if (log_get_level() > 1) {
 		tmp = cmd_print(cmd);
 		log_debug("%s %s: (%u) %s", __func__, name, item->group, tmp);
 		free(tmp);
 	}

-	flags = !!(state->flags & CMDQ_STATE_CONTROL);
+	flags = !!(shared->flags & CMDQ_SHARED_CONTROL);
 	cmdq_guard(item, "begin", flags);

 	if (item->client == NULL)
 		item->client = cmd_find_client(item, NULL, 1);
-
-	if (entry->flags & CMD_CLIENT_CANFAIL)
-		quiet = 1;
-	if (entry->flags & CMD_CLIENT_CFLAG) {
-		tc = cmd_find_client(item, args_get(args, 'c'), quiet);
-		if (tc == NULL && !quiet) {
-			retval = CMD_RETURN_ERROR;
-			goto out;
-		}
-	} else if (entry->flags & CMD_CLIENT_TFLAG) {
-		tc = cmd_find_client(item, args_get(args, 't'), quiet);
-		if (tc == NULL && !quiet) {
-			retval = CMD_RETURN_ERROR;
-			goto out;
-		}
-	} else
-		tc = cmd_find_client(item, NULL, 1);
-	item->target_client = tc;
-
 	retval = cmdq_find_flag(item, &item->source, &entry->source);
 	if (retval == CMD_RETURN_ERROR)
 		goto out;
@@ -626,8 +308,8 @@ cmdq_fire_command(struct cmdq_item *item)
 	if (entry->flags & CMD_AFTERHOOK) {
 		if (cmd_find_valid_state(&item->target))
 			fsp = &item->target;
-		else if (cmd_find_valid_state(&item->state->current))
-			fsp = &item->state->current;
+		else if (cmd_find_valid_state(&item->shared->current))
+			fsp = &item->shared->current;
 		else if (cmd_find_from_client(&fs, item->client, 0) == 0)
 			fsp = &fs;
 		else
@@ -636,19 +318,10 @@ cmdq_fire_command(struct cmdq_item *item)
 	}

 out:
-	item->client = saved;
-	if (retval == CMD_RETURN_ERROR) {
-		fsp = NULL;
-		if (cmd_find_valid_state(&item->target))
-			fsp = &item->target;
-		else if (cmd_find_valid_state(&item->state->current))
-			fsp = &item->state->current;
-		else if (cmd_find_from_client(&fs, item->client, 0) == 0)
-			fsp = &fs;
-		cmdq_insert_hook(fsp != NULL ? fsp->s : NULL, item, fsp,
-		    "command-error");
+	item->client = c;
+	if (retval == CMD_RETURN_ERROR)
 		cmdq_guard(item, "error", flags);
-	} else
+	else
 		cmdq_guard(item, "end", flags);
 	return (retval);
 }
@@ -664,7 +337,7 @@ cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
 	item->type = CMDQ_CALLBACK;

 	item->group = 0;
-	item->state = cmdq_new_state(NULL, NULL, 0);
+	item->flags = 0;

 	item->cb = cb;
 	item->data = data;
@@ -698,6 +371,25 @@ cmdq_fire_callback(struct cmdq_item *item)
 	return (item->cb(item, item->data));
 }

+/* Add a format to command queue. */
+void
+cmdq_format(struct cmdq_item *item, const char *key, const char *fmt, ...)
+{
+	struct cmdq_shared	*shared = item->shared;
+	va_list			 ap;
+	char			*value;
+
+	va_start(ap, fmt);
+	xvasprintf(&value, fmt, ap);
+	va_end(ap);
+
+	if (shared->formats == NULL)
+		shared->formats = format_create(NULL, NULL, FORMAT_NONE, 0);
+	format_add(shared->formats, key, "%s", value);
+
+	free(value);
+}
+
 /* Process next item on command queue. */
 u_int
 cmdq_next(struct client *c)
@@ -709,18 +401,18 @@ cmdq_next(struct client *c)
 	u_int			 items = 0;
 	static u_int		 number;

-	if (TAILQ_EMPTY(&queue->list)) {
+	if (TAILQ_EMPTY(queue)) {
 		log_debug("%s %s: empty", __func__, name);
 		return (0);
 	}
-	if (TAILQ_FIRST(&queue->list)->flags & CMDQ_WAITING) {
+	if (TAILQ_FIRST(queue)->flags & CMDQ_WAITING) {
 		log_debug("%s %s: waiting", __func__, name);
 		return (0);
 	}

 	log_debug("%s %s: enter", __func__, name);
 	for (;;) {
-		item = queue->item = TAILQ_FIRST(&queue->list);
+		item = TAILQ_FIRST(queue);
 		if (item == NULL)
 			break;
 		log_debug("%s %s: %s (%d), flags %x", __func__, name,
@@ -770,7 +462,6 @@ cmdq_next(struct client *c)
 		}
 		cmdq_remove(item);
 	}
-	queue->item = NULL;

 	log_debug("%s %s: exit (empty)", __func__, name);
 	return (items);
@@ -780,19 +471,6 @@ waiting:
 	return (items);
 }

-/* Get running item if any. */
-struct cmdq_item *
-cmdq_running(struct client *c)
-{
-	struct cmdq_list	*queue = cmdq_get(c);
-
-	if (queue->item == NULL)
-		return (NULL);
-	if (queue->item->flags & CMDQ_WAITING)
-		return (NULL);
-	return (queue->item);
-}
-
 /* Print a guard line. */
 void
 cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
@@ -802,33 +480,43 @@ cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
 	u_int		 number = item->number;

 	if (c != NULL && (c->flags & CLIENT_CONTROL))
-		control_write_guard(c, guard, t, number, flags);
-}
-
-/* Show message from command. */
-void
-cmdq_print_data(struct cmdq_item *item, struct evbuffer *evb)
-{
-	server_client_print(item->client, 1, evb);
+		file_print(c, "%%%s %ld %u %d\n", guard, t, number, flags);
 }

 /* Show message from command. */
 void
 cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 {
-	va_list		 ap;
-	struct evbuffer	*evb;
-
-	evb = evbuffer_new();
-	if (evb == NULL)
-		fatalx("out of memory");
+	struct client			*c = item->client;
+	struct window_pane		*wp;
+	struct window_mode_entry	*wme;
+	va_list				 ap;
+	char				*tmp, *msg;

 	va_start(ap, fmt);
-	evbuffer_add_vprintf(evb, fmt, ap);
+	xvasprintf(&msg, fmt, ap);
 	va_end(ap);

-	cmdq_print_data(item, evb);
-	evbuffer_free(evb);
+	log_debug("%s: %s", __func__, msg);
+
+	if (c == NULL)
+		/* nothing */;
+	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
+		if (~c->flags & CLIENT_UTF8) {
+			tmp = msg;
+			msg = utf8_sanitize(tmp);
+			free(tmp);
+		}
+		file_print(c, "%s\n", msg);
+	} else {
+		wp = c->session->curw->window->active;
+		wme = TAILQ_FIRST(&wp->modes);
+		if (wme == NULL || wme->mode != &window_view_mode)
+			window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+		window_copy_add(wp, "%s", msg);
+	}
+
+	free(msg);
 }

 /* Show error from command. */
@@ -838,9 +526,8 @@ cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 	struct client	*c = item->client;
 	struct cmd	*cmd = item->cmd;
 	va_list		 ap;
-	char		*msg, *tmp;
-	const char	*file;
-	u_int		 line;
+	char		*msg;
+	char		*tmp;

 	va_start(ap, fmt);
 	xvasprintf(&msg, fmt, ap);
@@ -848,35 +535,22 @@ cmdq_error(struct cmdq_item *item, const char *fmt, ...)

 	log_debug("%s: %s", __func__, msg);

-	if (c == NULL) {
-		cmd_get_source(cmd, &file, &line);
-		if (!cfg_finished) {
-			if (file != NULL)
-				cfg_add_cause("%s:%u: %s", file, line, msg);
-			else
-				cfg_add_cause("%s", msg);
-		} else {
-			if (file != NULL) {
-				server_add_message("message: %s:%u: %s", file,
-				    line, msg);
-			} else
-				server_add_message("message: %s", msg);
-		}
-	} else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
-		server_add_message("%s message: %s", c->name, msg);
+	if (c == NULL)
+		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
+	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
 		if (~c->flags & CLIENT_UTF8) {
 			tmp = msg;
 			msg = utf8_sanitize(tmp);
 			free(tmp);
 		}
 		if (c->flags & CLIENT_CONTROL)
-			control_write(c, "%s", msg);
+			file_print(c, "%s\n", msg);
 		else
 			file_error(c, "%s\n", msg);
 		c->retval = 1;
 	} else {
 		*msg = toupper((u_char) *msg);
-		status_message_set(c, -1, 1, 0, 0, "%s", msg);
+		status_message_set(c, "%s", msg);
 	}

 	free(msg);
--- a/cmd-refresh-client.c
+++ b/cmd-refresh-client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-refresh-client.c,v 1.55 2026/07/17 08:37:29 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,154 +34,28 @@ const struct cmd_entry cmd_refresh_client_entry = {
 	.name = "refresh-client",
 	.alias = "refresh",

-	.args = { "A:B:cC:Df:r:F:lLRSt:U", 0, 1, NULL },
-	.usage = "[-cDlLRSU] [-A pane:state] [-B name:what:format] "
-		 "[-C XxY] [-f flags] [-r pane:report] " CMD_TARGET_CLIENT_USAGE
-		 " [adjustment]",
+	.args = { "cC:DF:lLRSt:U", 0, 1 },
+	.usage = "[-cDlLRSU] [-C XxY] [-F flags] " CMD_TARGET_CLIENT_USAGE
+		" [adjustment]",

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_refresh_client_exec
 };

-static void
-cmd_refresh_client_update_subscription(struct client *tc, const char *value)
-{
-	char			*name, *format;
-	enum monitor_type	 type;
-	int			 id;
-
-	if (monitor_parse(value, &name, &type, &id, &format) != 0) {
-		control_remove_sub(tc, value);
-		return;
-	}
-	control_add_sub(tc, name, type, id, format);
-	free(name);
-	free(format);
-}
-
-static enum cmd_retval
-cmd_refresh_client_control_client_size(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		*args = cmd_get_args(self);
-	struct client		*tc = cmdq_get_target_client(item);
-	const char		*size = args_get(args, 'C');
-	u_int			 w, x, y;
-
-	if (sscanf(size, "@%u:%ux%u", &w, &x, &y) == 3) {
-		if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
-		    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
-			cmdq_error(item, "size too small or too big");
-			return (CMD_RETURN_ERROR);
-		}
-		log_debug("%s: client %s window @%u: size %ux%u", __func__,
-		    tc->name, w, x, y);
-		control_set_window_size(tc, w, x, y);
-		tc->flags |= CLIENT_WINDOWSIZECHANGED;
-		recalculate_sizes_now(1);
-		return (CMD_RETURN_NORMAL);
-	}
-	if (sscanf(size, "@%u:", &w) == 1) {
-		log_debug("%s: client %s window @%u: no size", __func__,
-		    tc->name, w);
-		control_clear_window_size(tc, w);
-		recalculate_sizes_now(1);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (sscanf(size, "%u,%u", &x, &y) != 2 &&
-	    sscanf(size, "%ux%u", &x, &y) != 2) {
-		cmdq_error(item, "bad size argument");
-		return (CMD_RETURN_ERROR);
-	}
-	if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
-	    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
-		cmdq_error(item, "size too small or too big");
-		return (CMD_RETURN_ERROR);
-	}
-	tty_set_size(&tc->tty, x, y, 0, 0);
-	tc->flags |= CLIENT_SIZECHANGED;
-	recalculate_sizes_now(1);
-	return (CMD_RETURN_NORMAL);
-}
-
-static void
-cmd_refresh_client_update_offset(struct client *tc, const char *value)
-{
-	struct window_pane	*wp;
-	char			*copy, *split;
-	u_int			 pane;
-
-	if (*value != '%')
-		return;
-	copy = xstrdup(value);
-	if ((split = strchr(copy, ':')) == NULL)
-		goto out;
-	*split++ = '\0';
-
-	if (sscanf(copy, "%%%u", &pane) != 1)
-		goto out;
-	wp = window_pane_find_by_id(pane);
-	if (wp == NULL)
-		goto out;
-
-	if (strcmp(split, "on") == 0)
-		control_set_pane_on(tc, wp);
-	else if (strcmp(split, "off") == 0)
-		control_set_pane_off(tc, wp);
-	else if (strcmp(split, "continue") == 0)
-		control_continue_pane(tc, wp);
-	else if (strcmp(split, "pause") == 0)
-		control_pause_pane(tc, wp);
-
-out:
-	free(copy);
-}
-
-static void
-cmd_refresh_report(struct tty *tty, const char *value)
-{
-	struct window_pane	*wp;
-	u_int			 pane;
-	int			 fg, bg;
-	size_t			 size = 0;
-	char			*copy, *split;
-
-	if (*value != '%')
-		return;
-	copy = xstrdup(value);
-	if ((split = strchr(copy, ':')) == NULL)
-		goto out;
-	*split++ = '\0';
-
-	if (sscanf(copy, "%%%u", &pane) != 1)
-		goto out;
-	wp = window_pane_find_by_id(pane);
-	if (wp == NULL)
-		goto out;
-
-	fg = wp->control_fg;
-	bg = wp->control_bg;
-	if (tty_keys_colours(tty, split, strlen(split), &size, &fg, &bg) == 0) {
-		if (bg != wp->control_bg)
-			wp->flags |= PANE_THEMECHANGED;
-		wp->control_fg = fg;
-	        wp->control_bg = bg;
-	}
-
-out:
-	free(copy);
-}
-
 static enum cmd_retval
 cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*tc = cmdq_get_target_client(item);
-	struct tty		*tty = &tc->tty;
-	struct window		*w;
-	const char		*errstr;
-	u_int			 adjust;
-	struct args_value	*av;
+	struct args	*args = self->args;
+	struct client	*c;
+	struct tty	*tty;
+	struct window	*w;
+	const char	*size, *errstr;
+	char		*copy, *next, *s;
+	u_int		 x, y, adjust;
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+	tty = &c->tty;

 	if (args_has(args, 'c') ||
 	    args_has(args, 'L') ||
@@ -189,11 +63,10 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 	    args_has(args, 'U') ||
 	    args_has(args, 'D'))
 	{
-		if (args_count(args) == 0)
+		if (args->argc == 0)
 			adjust = 1;
 		else {
-			adjust = strtonum(args_string(args, 0), 1, INT_MAX,
-			    &errstr);
+			adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 			if (errstr != NULL) {
 				cmdq_error(item, "adjustment %s", errstr);
 				return (CMD_RETURN_ERROR);
@@ -201,87 +74,88 @@ cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 		}

 		if (args_has(args, 'c'))
-			tc->pan_window = NULL;
+		    c->pan_window = NULL;
 		else {
-			w = tc->session->curw->window;
-			if (tc->pan_window != w) {
-				tc->pan_window = w;
-				tc->pan_ox = tty->oox;
-				tc->pan_oy = tty->ooy;
+			w = c->session->curw->window;
+			if (c->pan_window != w) {
+				c->pan_window = w;
+				c->pan_ox = tty->oox;
+				c->pan_oy = tty->ooy;
 			}
 			if (args_has(args, 'L')) {
-				if (tc->pan_ox > adjust)
-					tc->pan_ox -= adjust;
+				if (c->pan_ox > adjust)
+					c->pan_ox -= adjust;
 				else
-					tc->pan_ox = 0;
+					c->pan_ox = 0;
 			} else if (args_has(args, 'R')) {
-				tc->pan_ox += adjust;
-				if (tc->pan_ox > w->sx - tty->osx)
-					tc->pan_ox = w->sx - tty->osx;
+				c->pan_ox += adjust;
+				if (c->pan_ox > w->sx - tty->osx)
+					c->pan_ox = w->sx - tty->osx;
 			} else if (args_has(args, 'U')) {
-				if (tc->pan_oy > adjust)
-					tc->pan_oy -= adjust;
+				if (c->pan_oy > adjust)
+					c->pan_oy -= adjust;
 				else
-					tc->pan_oy = 0;
+					c->pan_oy = 0;
 			} else if (args_has(args, 'D')) {
-				tc->pan_oy += adjust;
-				if (tc->pan_oy > w->sy - tty->osy)
-					tc->pan_oy = w->sy - tty->osy;
+				c->pan_oy += adjust;
+				if (c->pan_oy > w->sy - tty->osy)
+					c->pan_oy = w->sy - tty->osy;
 			}
 		}
-		tty_update_client_offset(tc);
-		server_redraw_client(tc);
+		tty_update_client_offset(c);
+		server_redraw_client(c);
 		return (CMD_RETURN_NORMAL);
 	}

 	if (args_has(args, 'l')) {
-		tty_clipboard_query(&tc->tty);
+		if (c->session != NULL)
+			tty_putcode_ptr2(&c->tty, TTYC_MS, "", "?");
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'F')) /* -F is an alias for -f */
-		server_client_set_flags(tc, args_get(args, 'F'));
-	if (args_has(args, 'f'))
-		server_client_set_flags(tc, args_get(args, 'f'));
-	if (args_has(args, 'r'))
-		cmd_refresh_report(tty, args_get(args, 'r'));
-
-	if (args_has(args, 'A')) {
-		if (~tc->flags & CLIENT_CONTROL)
-			goto not_control_client;
-		av = args_first_value(args, 'A');
-		while (av != NULL) {
-			cmd_refresh_client_update_offset(tc, av->string);
-			av = args_next_value(av);
+	if (args_has(args, 'C') || args_has(args, 'F')) {
+		if (args_has(args, 'C')) {
+			if (!(c->flags & CLIENT_CONTROL)) {
+				cmdq_error(item, "not a control client");
+				return (CMD_RETURN_ERROR);
+			}
+			size = args_get(args, 'C');
+			if (sscanf(size, "%u,%u", &x, &y) != 2 &&
+			    sscanf(size, "%ux%u", &x, &y) != 2) {
+				cmdq_error(item, "bad size argument");
+				return (CMD_RETURN_ERROR);
+			}
+			if (x < WINDOW_MINIMUM || x > WINDOW_MAXIMUM ||
+			    y < WINDOW_MINIMUM || y > WINDOW_MAXIMUM) {
+				cmdq_error(item, "size too small or too big");
+				return (CMD_RETURN_ERROR);
+			}
+			tty_set_size(&c->tty, x, y, 0, 0);
+			c->flags |= CLIENT_SIZECHANGED;
+			recalculate_sizes();
+		}
+		if (args_has(args, 'F')) {
+			if (!(c->flags & CLIENT_CONTROL)) {
+				cmdq_error(item, "not a control client");
+				return (CMD_RETURN_ERROR);
+			}
+			s = copy = xstrdup(args_get(args, 'F'));
+			while ((next = strsep(&s, ",")) != NULL) {
+				/* Unknown flags are ignored. */
+				if (strcmp(next, "no-output") == 0)
+					c->flags |= CLIENT_CONTROL_NOOUTPUT;
+			}
+			free(copy);
 		}
 		return (CMD_RETURN_NORMAL);
 	}
-	if (args_has(args, 'B')) {
-		if (~tc->flags & CLIENT_CONTROL)
-			goto not_control_client;
-		av = args_first_value(args, 'B');
-		while (av != NULL) {
-			cmd_refresh_client_update_subscription(tc, av->string);
-			av = args_next_value(av);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-	if (args_has(args, 'C')) {
-		if (~tc->flags & CLIENT_CONTROL)
-			goto not_control_client;
-		return (cmd_refresh_client_control_client_size(self, item));
-	}

 	if (args_has(args, 'S')) {
-		tc->flags |= CLIENT_STATUSFORCE;
-		server_status_client(tc);
+		c->flags |= CLIENT_STATUSFORCE;
+		server_status_client(c);
 	} else {
-		tc->flags |= CLIENT_STATUSFORCE;
-		server_redraw_client(tc);
+		c->flags |= CLIENT_STATUSFORCE;
+		server_redraw_client(c);
 	}
 	return (CMD_RETURN_NORMAL);
-
-not_control_client:
-	cmdq_error(item, "not a control client");
-	return (CMD_RETURN_ERROR);
 }
--- a/cmd-rename-session.c
+++ b/cmd-rename-session.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-rename-session.c,v 1.39 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,7 +34,7 @@ const struct cmd_entry cmd_rename_session_entry = {
 	.name = "rename-session",
 	.alias = "rename",

-	.args = { "t:", 1, 1, NULL },
+	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_SESSION_USAGE " new-name",

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -46,45 +46,35 @@ const struct cmd_entry cmd_rename_session_entry = {
 static enum cmd_retval
 cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*s = target->s;
-	struct event_payload	*ep;
-	struct cmd_find_state	 fs;
-	char			*newname, *tmp;
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	char			*newname;

-	tmp = format_single_from_target(item, args_string(args, 0));
-	if (!check_name(tmp)) {
-		cmdq_error(item, "invalid session name: %s", tmp);
-		free(tmp);
-		return (CMD_RETURN_ERROR);
-	}
-	newname = clean_name(tmp, 0);
-	free(tmp);
+	newname = format_single(item, args->argv[0], c, s, NULL, NULL);
 	if (strcmp(newname, s->name) == 0) {
 		free(newname);
 		return (CMD_RETURN_NORMAL);
 	}
+
+	if (!session_check_name(newname)) {
+		cmdq_error(item, "bad session name: %s", newname);
+		free(newname);
+		return (CMD_RETURN_ERROR);
+	}
 	if (session_find(newname) != NULL) {
 		cmdq_error(item, "duplicate session: %s", newname);
 		free(newname);
 		return (CMD_RETURN_ERROR);
 	}

-	ep = event_payload_create();
-	cmd_find_from_session(&fs, s, 0);
-	event_payload_set_target(ep, &fs);
-	event_payload_set_session(ep, "session", s);
-	event_payload_set_string(ep, "old_name", "%s", s->name);
-	event_payload_set_string(ep, "new_name", "%s", newname);
-
 	RB_REMOVE(sessions, &sessions, s);
 	free(s->name);
 	s->name = newname;
 	RB_INSERT(sessions, &sessions, s);

 	server_status_session(s);
-	events_fire("session-renamed", ep);
+	notify_session("session-renamed", s);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-rename-window.c
+++ b/cmd-rename-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-rename-window.c,v 1.30 2026/06/29 18:17:28 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_rename_window_entry = {
 	.name = "rename-window",
 	.alias = "renamew",

-	.args = { "t:", 1, 1, NULL },
+	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_WINDOW_USAGE " new-name",

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -45,24 +45,18 @@ const struct cmd_entry cmd_rename_window_entry = {
 static enum cmd_retval
 cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = target->wl;
-	char			*name;
+	struct args	*args = self->args;
+	struct client	*c = cmd_find_client(item, NULL, 1);
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;
+	char		*newname;

-	name = format_single_from_target(item, args_string(args, 0));
-	if (!check_name(name)) {
-		cmdq_error(item, "invalid window name: %s", name);
-		free(name);
-		return (CMD_RETURN_ERROR);
-	}
-
-	window_set_name(wl->window, name, 0);
+	newname = format_single(item, args->argv[0], c, s, wl, NULL);
+	window_set_name(wl->window, newname);
 	options_set_number(wl->window->options, "automatic-rename", 0);
-	free(name);

-	server_redraw_window_borders(wl->window);
 	server_status_window(wl->window);
+	free(newname);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-resize-pane.c
+++ b/cmd-resize-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-resize-pane.c,v 1.68 2026/08/31 07:44:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,7 +18,6 @@

 #include <sys/types.h>

-#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>

@@ -30,20 +29,16 @@

 static enum cmd_retval	cmd_resize_pane_exec(struct cmd *, struct cmdq_item *);

-static enum cmd_retval	cmd_resize_pane_mouse_update(struct cmd *,
-			    struct cmdq_item *);
-static void		cmd_resize_pane_mouse_resize_move_floating(
-			    struct client *, struct mouse_event *);
-static void		cmd_resize_pane_mouse_resize_tiled(struct client *,
-			    struct mouse_event *);
+static void	cmd_resize_pane_mouse_update(struct client *,
+		    struct mouse_event *);

 const struct cmd_entry cmd_resize_pane_entry = {
 	.name = "resize-pane",
 	.alias = "resizep",

-	.args = { "D::L::MR::Tt:U::x:y:Z", 0, 1, NULL },
-	.usage = "[-MTZ] [-D lines] [-L columns] [-R columns] [-U lines] "
-		 "[-x width] [-y height] " CMD_TARGET_PANE_USAGE,
+	.args = { "DLMRt:Ux:y:Z", 0, 1 },
+	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
+		 "[adjustment]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -54,317 +49,126 @@ const struct cmd_entry cmd_resize_pane_entry = {
 static enum cmd_retval
 cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct window_pane	*wp = target->wp;
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct cmdq_shared	*shared = item->shared;
+	struct window_pane	*wp = item->target.wp;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct layout_cell	*lc = wp->layout_cell;
-	enum layout_type	 type;
-	const char		*errstr, *argval;
-	const char		 flags[4] = { 'U', 'D', 'L', 'R' };
-	char			*cause = NULL, flag;
-	int			 adjust, x, y, status, opposite = 0;
-	long unsigned		 i;
-	struct grid		*gd = wp->base.grid;
+	struct client		*c = item->client;
+	struct session		*s = item->target.s;
+	const char	       	*errstr, *p;
+	char			*cause, *copy;
+	u_int			 adjust;
+	int			 x, y, percentage;
+	size_t			 plen;

-	if (args_has(args, 'T')) {
-		if (!TAILQ_EMPTY(&wp->modes))
+	if (args_has(args, 'M')) {
+		if (cmd_mouse_window(&shared->mouse, &s) == NULL)
 			return (CMD_RETURN_NORMAL);
-		adjust = screen_size_y(&wp->base) - 1 - wp->base.cy;
-		if (adjust > (int)gd->hsize)
-			adjust = gd->hsize;
-		grid_remove_history(gd, adjust);
-		wp->base.cy += adjust;
-		wp->flags |= PANE_REDRAW;
+		if (c == NULL || c->session != s)
+			return (CMD_RETURN_NORMAL);
+		c->tty.mouse_drag_update = cmd_resize_pane_mouse_update;
+		cmd_resize_pane_mouse_update(c, &shared->mouse);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'M'))
-		return (cmd_resize_pane_mouse_update(self, item));
-
 	if (args_has(args, 'Z')) {
 		if (w->flags & WINDOW_ZOOMED)
-			window_unzoom(w, 1);
+			window_unzoom(w);
 		else
 			window_zoom(wp);
 		server_redraw_window(w);
+		server_status_window(w);
 		return (CMD_RETURN_NORMAL);
 	}
 	server_unzoom_window(w);
-	lc = wp->layout_cell; /* may have been replaced by unzoom */

-	if (args_has(args, 'x')) {
-		x = args_percentage(args, 'x', 0, PANE_MAXIMUM, w->sx, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "width %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		if (window_pane_is_floating(wp)) {
-			if (layout_resize_floating_pane_to(wp, LAYOUT_LEFTRIGHT,
-			    x, &cause) != 0) {
-				cmdq_error(item, "size %s", cause);
-				free(cause);
-				return (CMD_RETURN_ERROR);
-			}
-		} else
-			layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
-	}
-	if (args_has(args, 'y')) {
-		y = args_percentage(args, 'y', 0, PANE_MAXIMUM, w->sy, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "height %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-		status = window_get_pane_status(w);
-		switch (status) {
-		case PANE_STATUS_TOP:
-			if (y != INT_MAX && wp->yoff == 1)
-				y++;
-			break;
-		case PANE_STATUS_BOTTOM:
-			if (y != INT_MAX && wp->yoff + wp->sy == w->sy - 1)
-				y++;
-			break;
-		}
-		if (window_pane_is_floating(wp)) {
-			if (layout_resize_floating_pane_to(wp, LAYOUT_TOPBOTTOM,
-			    y, &cause) != 0) {
-				cmdq_error(item, "size %s", cause);
-				free(cause);
-				return (CMD_RETURN_ERROR);
-			}
-		} else
-			layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
-	}
-
-	for (i = 0; i < nitems(flags); i++) {
-		flag = flags[i];
-		if (!args_has(args, flag))
-			continue;
-
-		argval = args_get(args, flag);
-		if (argval == NULL) {
-			if (args_count(args) == 0)
-				argval = "1";
-			else
-				argval = args_string(args, 0);
-		}
-
-		adjust = strtonum(argval, INT_MIN, INT_MAX, &errstr);
+	if (args->argc == 0)
+		adjust = 1;
+	else {
+		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 		if (errstr != NULL) {
 			cmdq_error(item, "adjustment %s", errstr);
 			return (CMD_RETURN_ERROR);
 		}
+	}

-		type = LAYOUT_TOPBOTTOM;
-		if (flag == 'L' || flag == 'R')
-			type = LAYOUT_LEFTRIGHT;
-
-		if (window_pane_is_floating(wp)) {
-			if (flag == 'L' || flag == 'U')
-				opposite = 1;
-
-			if (layout_resize_floating_pane(wp, type, adjust,
-			    opposite, &cause) != 0) {
-				cmdq_error(item, "adjustment %s", cause);
+	if ((p = args_get(args, 'x')) != NULL) {
+		plen = strlen(p);
+		if (p[plen - 1] == '%') {
+			copy = xstrdup(p);
+			copy[plen - 1] = '\0';
+			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			free(copy);
+			if (errstr != NULL) {
+				cmdq_error(item, "width %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+			x = (w->sx * percentage) / 100;
+			if (x < PANE_MINIMUM)
+				x = PANE_MINIMUM;
+			if (x > INT_MAX)
+				x = INT_MAX;
+		} else {
+			x = args_strtonum(args, 'x', PANE_MINIMUM, INT_MAX,
+			    &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "width %s", cause);
 				free(cause);
 				return (CMD_RETURN_ERROR);
 			}
-		} else {
-			if (flag == 'L' || flag == 'U')
-				adjust = -adjust;
-			layout_resize_pane(wp, type, adjust, 1);
 		}
+		layout_resize_pane_to(wp, LAYOUT_LEFTRIGHT, x);
+	}
+	if ((p = args_get(args, 'y')) != NULL) {
+		plen = strlen(p);
+		if (p[plen - 1] == '%') {
+			copy = xstrdup(p);
+			copy[plen - 1] = '\0';
+			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			free(copy);
+			if (errstr != NULL) {
+				cmdq_error(item, "height %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+			y = (w->sy * percentage) / 100;
+			if (y < PANE_MINIMUM)
+				y = PANE_MINIMUM;
+			if (y > INT_MAX)
+				y = INT_MAX;
+		}
+		else {
+			y = args_strtonum(args, 'y', PANE_MINIMUM, INT_MAX,
+			    &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "height %s", cause);
+				free(cause);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+		layout_resize_pane_to(wp, LAYOUT_TOPBOTTOM, y);
 	}

-	if (lc->parent != NULL)
-		layout_fix_offsets(w);
-	layout_fix_panes(w, NULL);
-	events_fire_window("window-layout-changed", w);
-	server_redraw_window(w);
+	if (args_has(args, 'L'))
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
+	else if (args_has(args, 'R'))
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
+	else if (args_has(args, 'U'))
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
+	else if (args_has(args, 'D'))
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust, 1);
+	server_redraw_window(wl->window);

 	return (CMD_RETURN_NORMAL);
 }

-static enum cmd_retval
-cmd_resize_pane_mouse_update(__unused struct cmd *self, struct cmdq_item *item)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct key_event	*event = cmdq_get_event(item);
-	struct window_pane	*wp = target->wp;
-	struct winlink		*wl = target->wl;
-	struct window		*w = wl->window;
-	struct client		*c = cmdq_get_client(item);
-	struct session		*s = target->s;
-
-	if (!event->m.valid)
-		return (CMD_RETURN_NORMAL);
-	wp = cmd_mouse_pane(&event->m, &s, NULL);
-	if (wp == NULL || c == NULL || c->session != s)
-		return (CMD_RETURN_NORMAL);
-
-	if (!window_pane_is_floating(wp)) {
-		c->tty.mouse_drag_update = cmd_resize_pane_mouse_resize_tiled;
-		cmd_resize_pane_mouse_resize_tiled(c, &event->m);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	window_redraw_active_switch(w, wp);
-	window_set_active_pane(w, wp, 1);
-
-	c->tty.mouse_drag_update = cmd_resize_pane_mouse_resize_move_floating;
-	cmd_resize_pane_mouse_resize_move_floating(c, &event->m);
-	return (CMD_RETURN_NORMAL);
-}
-
-/*
- * Resizes or moves the pane by dragging. Resize a floating pane by dragging
- * the borders or corners. Grabbing an edge only resizes that axis (special
- * case). Moves the pane if dragging the top border. Since characters are
- * generally rectangular, to make it easier to grab the corner, the character
- * next to the corner is also considered the corner.
- */
 static void
-cmd_resize_pane_mouse_resize_move_floating(struct client *c,
-    struct mouse_event *m)
-{
-	struct winlink		*wl;
-	struct window		*w;
-	struct window_pane	*wp;
-	struct layout_cell	*lc;
-	int			 y, ly, x, lx, sx, sy, new_sx, new_sy;
-	int			 left, right;
-	int			 new_xoff, new_yoff, resizes = 0;
-	int			 old_xoff, old_yoff, old_sx, old_sy;
-
-	wp = cmd_mouse_pane(m, NULL, &wl);
-	if (wp == NULL) {
-		c->tty.mouse_drag_update = NULL;
-		return;
-	}
-	w = wl->window;
-	lc = wp->layout_cell;
-	sx = wp->sx;
-	sy = wp->sy;
-	old_xoff = wp->xoff;
-	old_yoff = wp->yoff;
-	old_sx = (int)wp->sx;
-	old_sy = (int)wp->sy;
-	left = wp->xoff - 1;
-	right = wp->xoff + sx;
-	if (window_pane_scrollbar_reserve(wp) &&
-	    w->sb_pos == PANE_SCROLLBARS_LEFT) {
-		left -= wp->scrollbar_style.width + wp->scrollbar_style.pad;
-	} else if (window_pane_scrollbar_reserve(wp) &&
-	    w->sb_pos == PANE_SCROLLBARS_RIGHT) {
-		right += wp->scrollbar_style.width + wp->scrollbar_style.pad;
-	}
-
-	y = m->y + m->oy; x = m->x + m->ox;
-	if (m->statusat == 0 && y >= (int)m->statuslines)
-		y -= m->statuslines;
-	else if (m->statusat > 0 && y >= m->statusat)
-		y = m->statusat - 1;
-	ly = m->ly + m->oy; lx = m->lx + m->ox;
-	if (m->statusat == 0 && ly >= (int)m->statuslines)
-		ly -= m->statuslines;
-	else if (m->statusat > 0 && ly >= m->statusat)
-		ly = m->statusat - 1;
-
-	if ((lx == left || lx == left + 1) && ly == wp->yoff - 1) {
-		/* Top left corner. */
-		new_sx = lc->g.sx + (lx - x);
-		if (new_sx < PANE_MINIMUM)
-			new_sx = PANE_MINIMUM;
-		new_sy = lc->g.sy + (ly - y);
-		if (new_sy < PANE_MINIMUM)
-			new_sy = PANE_MINIMUM;
-		new_xoff = x + 1; /* because mouse is on border at xoff - 1 */
-		new_yoff = y + 1;
-		layout_set_size(lc, new_sx, new_sy, new_xoff, new_yoff);
-		resizes++;
-	} else if ((lx == right + 1 || lx == right) &&
-	    ly == wp->yoff - 1) {
-		/* Top right corner. */
-		new_sx = x - lc->g.xoff;
-		if (new_sx < PANE_MINIMUM)
-			new_sx = PANE_MINIMUM;
-		new_sy = lc->g.sy + (ly - y);
-		if (new_sy < PANE_MINIMUM)
-			new_sy = PANE_MINIMUM;
-		new_yoff = y + 1;
-		layout_set_size(lc, new_sx, new_sy, lc->g.xoff, new_yoff);
-		resizes++;
-	} else if ((lx == left || lx == left + 1) &&
-	    ly == wp->yoff + sy) {
-		/* Bottom left corner. */
-		new_sx = lc->g.sx + (lx - x);
-		if (new_sx < PANE_MINIMUM)
-			new_sx = PANE_MINIMUM;
-		new_sy = y - lc->g.yoff;
-		if (new_sy < PANE_MINIMUM)
-			return;
-		new_xoff = x + 1;
-		layout_set_size(lc, new_sx, new_sy, new_xoff, lc->g.yoff);
-		resizes++;
-	} else if ((lx == right + 1 || lx == right) &&
-	    ly == wp->yoff + sy) {
-		/* Bottom right corner. */
-		new_sx = x - lc->g.xoff;
-		if (new_sx < PANE_MINIMUM)
-			new_sx = PANE_MINIMUM;
-		new_sy = y - lc->g.yoff;
-		if (new_sy < PANE_MINIMUM)
-			new_sy = PANE_MINIMUM;
-		layout_set_size(lc, new_sx, new_sy, lc->g.xoff, lc->g.yoff);
-		resizes++;
-	} else if (lx == right) {
-		/* Right border. */
-		new_sx = x - lc->g.xoff;
-		if (new_sx < PANE_MINIMUM)
-			return;
-		layout_set_size(lc, new_sx, lc->g.sy, lc->g.xoff, lc->g.yoff);
-		resizes++;
-	} else if (lx == left) {
-		/* Left border. */
-		new_sx = lc->g.sx + (lx - x);
-		if (new_sx < PANE_MINIMUM)
-			return;
-		new_xoff = x + 1;
-		layout_set_size(lc, new_sx, lc->g.sy, new_xoff, lc->g.yoff);
-		resizes++;
-	} else if (ly == wp->yoff + sy) {
-		/* Bottom border. */
-		new_sy = y - lc->g.yoff;
-		if (new_sy < PANE_MINIMUM)
-			return;
-		layout_set_size(lc, lc->g.sx, new_sy, lc->g.xoff, lc->g.yoff);
-		resizes++;
-	} else if (ly == wp->yoff - 1) {
-		/* Top border (move instead of resize). */
-		new_xoff = lc->g.xoff + (x - lx);
-		new_yoff = y + 1;
-		layout_set_size(lc, lc->g.sx, lc->g.sy, new_xoff, new_yoff);
-		resizes++;
-	}
-	if (resizes != 0) {
-		layout_fix_panes(w, NULL);
-		window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-		    old_sy);
-		server_redraw_window_borders(w);
-	}
-}
-
-static void
-cmd_resize_pane_mouse_resize_tiled(struct client *c, struct mouse_event *m)
+cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 {
 	struct winlink		*wl;
 	struct window		*w;
 	u_int			 y, ly, x, lx;
-	static const int	 offsets[][2] = {
+	static const int         offsets[][2] = {
 	    { 0, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
 	};
 	struct layout_cell	*cells[nitems(offsets)], *lc;
--- a/cmd-resize-window.c
+++ b/cmd-resize-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-resize-window.c,v 1.10 2023/06/30 13:19:32 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2018 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_resize_window_entry = {
 	.name = "resize-window",
 	.alias = "resizew",

-	.args = { "aADLRt:Ux:y:", 0, 1, NULL },
+	.args = { "aADLRt:Ux:y:", 0, 1 },
 	.usage = "[-aADLRU] [-x width] [-y height] " CMD_TARGET_WINDOW_USAGE " "
 		 "[adjustment]",

@@ -46,19 +46,19 @@ const struct cmd_entry cmd_resize_window_entry = {
 static enum cmd_retval
 cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct session		*s = target->s;
+	struct session		*s = item->target.s;
 	const char	       	*errstr;
 	char			*cause;
-	u_int			 adjust, sx, sy, xpixel = 0, ypixel = 0;
+	u_int			 adjust, sx, sy;
+	int			 xpixel = -1, ypixel = -1;

-	if (args_count(args) == 0)
+	if (args->argc == 0)
 		adjust = 1;
 	else {
-		adjust = strtonum(args_string(args, 0), 1, INT_MAX, &errstr);
+		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 		if (errstr != NULL) {
 			cmdq_error(item, "adjustment %s", errstr);
 			return (CMD_RETURN_ERROR);
@@ -107,9 +107,7 @@ cmd_resize_window_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	options_set_number(w->options, "window-size", WINDOW_SIZE_MANUAL);
-	w->manual_sx = sx;
-	w->manual_sy = sy;
-	recalculate_size(w, 1);
+	resize_window(w, sx, sy, xpixel, ypixel);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-respawn-pane.c
+++ b/cmd-respawn-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-respawn-pane.c,v 1.40 2026/07/03 16:09:49 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,9 +34,9 @@ const struct cmd_entry cmd_respawn_pane_entry = {
 	.name = "respawn-pane",
 	.alias = "respawnp",

-	.args = { "c:e:Ekt:", 0, -1, NULL },
-	.usage = "[-Ek] [-c start-directory] [-e environment] "
-		 CMD_TARGET_PANE_USAGE " [shell-command [argument ...]]",
+	.args = { "c:e:kt:", 0, -1 },
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_PANE_USAGE " [command]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -47,54 +47,50 @@ const struct cmd_entry cmd_respawn_pane_entry = {
 static enum cmd_retval
 cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct spawn_context	 sc = { 0 };
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = target->wp;
+	struct args		*args = self->args;
+	struct spawn_context	 sc;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	char			*cause = NULL;
-	struct args_value	*av;
+	const char		*add;
+	struct args_value	*value;

+	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
 	sc.wl = wl;

 	sc.wp0 = wp;
+	sc.lc = NULL;

-	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.name = NULL;
+	sc.argc = args->argc;
+	sc.argv = args->argv;
 	sc.environ = environ_create();

-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(sc.environ, av->string, 0);
-		av = args_next_value(av);
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}

 	sc.idx = -1;
 	sc.cwd = args_get(args, 'c');

 	sc.flags = SPAWN_RESPAWN;
-	if (args_has(args, 'E'))
-		sc.flags |= SPAWN_EMPTY;
 	if (args_has(args, 'k'))
 		sc.flags |= SPAWN_KILL;

 	if (spawn_pane(&sc, &cause) == NULL) {
 		cmdq_error(item, "respawn pane failed: %s", cause);
 		free(cause);
-		if (sc.argv != NULL)
-			cmd_free_argv(sc.argc, sc.argv);
-		environ_free(sc.environ);
 		return (CMD_RETURN_ERROR);
 	}

 	wp->flags |= PANE_REDRAW;
-	server_redraw_window_borders(wp->window);
 	server_status_window(wp->window);

-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	environ_free(sc.environ);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-respawn-window.c
+++ b/cmd-respawn-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-respawn-window.c,v 1.51 2026/07/03 16:09:49 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,9 +34,9 @@ const struct cmd_entry cmd_respawn_window_entry = {
 	.name = "respawn-window",
 	.alias = "respawnw",

-	.args = { "c:e:Ekt:", 0, -1, NULL },
-	.usage = "[-Ek] [-c start-directory] [-e environment] "
-		 CMD_TARGET_WINDOW_USAGE " [shell-command [argument ...]]",
+	.args = { "c:e:kt:", 0, -1 },
+	.usage = "[-k] [-c start-directory] [-e environment] "
+		 CMD_TARGET_WINDOW_USAGE " [command]",

 	.target = { 't', CMD_FIND_WINDOW, 0 },

@@ -47,51 +47,46 @@ const struct cmd_entry cmd_respawn_window_entry = {
 static enum cmd_retval
 cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct spawn_context	 sc = { 0 };
-	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct spawn_context	 sc;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
 	char			*cause = NULL;
-	struct args_value	*av;
+	const char		*add;
+	struct args_value	*value;

+	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
 	sc.wl = wl;
-	sc.tc = tc;
+	sc.c = cmd_find_client(item, NULL, 1);

-	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.name = NULL;
+	sc.argc = args->argc;
+	sc.argv = args->argv;
 	sc.environ = environ_create();

-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(sc.environ, av->string, 0);
-		av = args_next_value(av);
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}

 	sc.idx = -1;
 	sc.cwd = args_get(args, 'c');

 	sc.flags = SPAWN_RESPAWN;
-	if (args_has(args, 'E'))
-		sc.flags |= SPAWN_EMPTY;
 	if (args_has(args, 'k'))
 		sc.flags |= SPAWN_KILL;

 	if (spawn_window(&sc, &cause) == NULL) {
 		cmdq_error(item, "respawn window failed: %s", cause);
 		free(cause);
-		if (sc.argv != NULL)
-			cmd_free_argv(sc.argc, sc.argv);
-		environ_free(sc.environ);
 		return (CMD_RETURN_ERROR);
 	}

 	server_redraw_window(wl->window);

-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	environ_free(sc.environ);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-rotate-window.c
+++ b/cmd-rotate-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-rotate-window.c,v 1.34 2026/06/22 08:47:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -31,7 +31,7 @@ const struct cmd_entry cmd_rotate_window_entry = {
 	.name = "rotate-window",
 	.alias = "rotatew",

-	.args = { "Dt:UZ", 0, 0, NULL },
+	.args = { "Dt:UZ", 0, 0 },
 	.usage = "[-DUZ] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -43,18 +43,16 @@ const struct cmd_entry cmd_rotate_window_entry = {
 static enum cmd_retval
 cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = target->wl;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
 	struct window_pane	*wp, *wp2;
 	struct layout_cell	*lc;
 	u_int			 sx, sy, xoff, yoff;

-	window_push_zoom(w, 0, args_has(args, 'Z'));
+	window_push_zoom(w, args_has(self->args, 'Z'));

-	if (args_has(args, 'D')) {
+	if (args_has(self->args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
 		TAILQ_INSERT_HEAD(&w->panes, wp, entry);
@@ -109,7 +107,6 @@ cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 	window_set_active_pane(w, wp, 1);
 	cmd_find_from_winlink_pane(current, wl, wp, 0);
 	window_pop_zoom(w);
-	redraw_invalidate_scene(w);
 	server_redraw_window(w);

 	return (CMD_RETURN_NORMAL);
--- a/cmd-run-shell.c
+++ b/cmd-run-shell.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-run-shell.c,v 1.94 2026/08/25 06:04:33 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -20,7 +20,6 @@
 #include <sys/types.h>
 #include <sys/wait.h>

-#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>

@@ -30,12 +29,8 @@
 * Runs a command without a window.
 */

-static enum args_parse_type	cmd_run_shell_args_parse(struct args *, u_int,
-				    char **);
-static enum cmd_retval		cmd_run_shell_exec(struct cmd *,
-				    struct cmdq_item *);
+static enum cmd_retval	cmd_run_shell_exec(struct cmd *, struct cmdq_item *);

-static void	cmd_run_shell_timer(int, short, void *);
 static void	cmd_run_shell_callback(struct job *);
 static void	cmd_run_shell_free(void *);
 static void	cmd_run_shell_print(struct job *, const char *);
@@ -44,9 +39,8 @@ const struct cmd_entry cmd_run_shell_entry = {
 	.name = "run-shell",
 	.alias = "run",

-	.args = { "bd:Ct:Es:c:", 0, -1, cmd_run_shell_args_parse },
-	.usage = "[-bCE] [-c start-directory] [-d delay] " CMD_TARGET_PANE_USAGE
-	         " [shell-command [argument ...]]",
+	.args = { "bt:", 1, 1 },
+	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",

 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },

@@ -55,26 +49,11 @@ const struct cmd_entry cmd_run_shell_entry = {
 };

 struct cmd_run_shell_data {
-	struct client			*client;
-	char				*cmd;
-	struct args_command_state	*state;
-	char				*cwd;
-	struct cmdq_item		*item;
-	struct session			*s;
-	int				 wp_id;
-	struct event			 timer;
-	int				 flags;
+	char			*cmd;
+	struct cmdq_item	*item;
+	int			 wp_id;
 };

-static enum args_parse_type
-cmd_run_shell_args_parse(struct args *args, __unused u_int idx,
-    __unused char **cause)
-{
-	if (args_has(args, 'C'))
-		return (ARGS_PARSE_COMMANDS_OR_STRING);
-	return (ARGS_PARSE_STRING);
-}
-
 static void
 cmd_run_shell_print(struct job *job, const char *msg)
 {
@@ -90,174 +69,63 @@ cmd_run_shell_print(struct job *job, const char *msg)
 			cmdq_print(cdata->item, "%s", msg);
 			return;
 		}
-		if (cdata->client != NULL && cdata->client->session != NULL)
-			wp = cdata->client->session->curw->window->active;
-		if (wp == NULL && cmd_find_from_nothing(&fs, 0) == 0)
-			wp = fs.wp;
+		if (cmd_find_from_nothing(&fs, 0) != 0)
+			return;
+		wp = fs.wp;
 		if (wp == NULL)
 			return;
 	}

 	wme = TAILQ_FIRST(&wp->modes);
 	if (wme == NULL || wme->mode != &window_view_mode)
-		window_pane_set_mode(wp, NULL, &window_view_mode, NULL, NULL,
-		    NULL);
-	window_copy_add(wp, 1, "%s", msg);
+		window_pane_set_mode(wp, &window_view_mode, NULL, NULL);
+	window_copy_add(wp, "%s", msg);
 }

 static enum cmd_retval
 cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct args			*args = self->args;
 	struct cmd_run_shell_data	*cdata;
-	struct client			*c = cmdq_get_client(item);
-	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s = target->s;
-	struct window_pane		*wp = target->wp;
-	const char			*delay, *cmd;
-	struct format_tree		*ft;
-	double				 d;
-	struct timeval			 tv;
-	char				*end, key[16];
-	u_int				 i;
-	int				 wait = !args_has(args, 'b');
-
-	if ((delay = args_get(args, 'd')) != NULL) {
-		d = strtod(delay, &end);
-		if (*end != '\0') {
-			cmdq_error(item, "invalid delay time: %s", delay);
-			return (CMD_RETURN_ERROR);
-		}
-	} else if (args_count(args) == 0)
-		return (CMD_RETURN_NORMAL);
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct window_pane		*wp = item->target.wp;

 	cdata = xcalloc(1, sizeof *cdata);
-	if (!args_has(args, 'C')) {
-		cmd = args_string(args, 0);
-		if (cmd != NULL) {
-			ft = format_create_from_target(item);
-			for (i = 1; i < args_count(args); i++) {
-				xsnprintf(key, sizeof key, "%u", i);
-				format_add(ft, key, "%s", args_string(args, i));
-			}
-			cdata->cmd = format_expand(ft, cmd);
-			format_free(ft);
-		}
-	} else {
-		cdata->state = args_make_commands_prepare(self, item, 0, NULL,
-		    wait, 1);
-	}
+	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);

 	if (args_has(args, 't') && wp != NULL)
 		cdata->wp_id = wp->id;
 	else
 		cdata->wp_id = -1;

-	if (wait) {
-		cdata->client = c;
+	if (!args_has(args, 'b'))
 		cdata->item = item;
-	} else {
-		cdata->client = tc;
-		cdata->flags |= JOB_NOWAIT;
+
+	if (job_run(cdata->cmd, s, server_client_get_cwd(item->client, s), NULL,
+	    cmd_run_shell_callback, cmd_run_shell_free, cdata, 0) == NULL) {
+		cmdq_error(item, "failed to run command: %s", cdata->cmd);
+		free(cdata);
+		return (CMD_RETURN_ERROR);
 	}
-	if (cdata->client != NULL)
-		cdata->client->references++;
-	if (args_has(args, 'c'))
-		cdata->cwd = xstrdup(args_get(args, 'c'));
-	else
-		cdata->cwd = xstrdup(server_client_get_cwd(c, s));

-	if (args_has(args, 'E'))
-		cdata->flags |= JOB_SHOWSTDERR;
-
-	cdata->s = s;
-	if (s != NULL)
-		session_add_ref(s, __func__);
-
-	evtimer_set(&cdata->timer, cmd_run_shell_timer, cdata);
-	if (delay != NULL) {
-		timerclear(&tv);
-		tv.tv_sec = (time_t)d;
-		tv.tv_usec = (d - (double)tv.tv_sec) * 1000000U;
-		evtimer_add(&cdata->timer, &tv);
-	} else
-		event_active(&cdata->timer, EV_TIMEOUT, 1);
-
-	if (!wait)
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }

-static void
-cmd_run_shell_timer(__unused int fd, __unused short events, void* arg)
-{
-	struct cmd_run_shell_data	*cdata = arg;
-	struct client			*c = cdata->client;
-	const char			*cmd = cdata->cmd;
-	struct cmdq_item		*item = cdata->item, *new_item;
-	struct cmd_list			*cmdlist;
-	char				*error;
-
-	if (cdata->state == NULL) {
-		if (cmd == NULL) {
-			if (cdata->item != NULL)
-				cmdq_continue(cdata->item);
-			cmd_run_shell_free(cdata);
-			return;
-		}
-		if (job_run(cmd, 0, NULL, NULL, cdata->s, cdata->cwd, NULL,
-		    cmd_run_shell_callback, cmd_run_shell_free, cdata,
-		    cdata->flags, -1, -1) == NULL) {
-			if (cdata->item == NULL)
-				status_message_set(c, -1, 1, 0, 0,
-				    "failed to run command: %s", cmd);
-			else {
-				cmdq_error(cdata->item,
-				    "failed to run command: %s", cmd);
-				cmdq_continue(cdata->item);
-			}
-			cmd_run_shell_free(cdata);
-		}
-		return;
-	}
-
-	cmdlist = args_make_commands(cdata->state, 0, NULL, &error);
-	if (cmdlist == NULL) {
-		if (cdata->item == NULL) {
-			*error = toupper((u_char)*error);
-			status_message_set(c, -1, 1, 0, 0, "%s", error);
-		} else
-			cmdq_error(cdata->item, "%s", error);
-		free(error);
-	} else if (item == NULL) {
-		new_item = cmdq_get_command(cmdlist, NULL);
-		cmdq_append(c, new_item);
-		cmd_list_free(cmdlist);
-	} else {
-		new_item = cmdq_get_command(cmdlist, cmdq_get_state(item));
-		cmdq_insert_after(item, new_item);
-		cmd_list_free(cmdlist);
-	}
-
-	if (cdata->item != NULL)
-		cmdq_continue(cdata->item);
-	cmd_run_shell_free(cdata);
-}
-
 static void
 cmd_run_shell_callback(struct job *job)
 {
 	struct cmd_run_shell_data	*cdata = job_get_data(job);
 	struct bufferevent		*event = job_get_event(job);
-	struct cmdq_item		*item = cdata->item;
 	char				*cmd = cdata->cmd, *msg = NULL, *line;
 	size_t				 size;
 	int				 retcode, status;

 	do {
-		line = evbuffer_readln(event->input, NULL, EVBUFFER_EOL_LF);
-		if (line != NULL) {
+		if ((line = evbuffer_readline(event->input)) != NULL) {
 			cmd_run_shell_print(job, line);
 			free(line);
 		}
@@ -281,19 +149,13 @@ cmd_run_shell_callback(struct job *job)
 	} else if (WIFSIGNALED(status)) {
 		retcode = WTERMSIG(status);
 		xasprintf(&msg, "'%s' terminated by signal %d", cmd, retcode);
-		retcode += 128;
-	} else
-		retcode = 0;
+	}
 	if (msg != NULL)
 		cmd_run_shell_print(job, msg);
 	free(msg);

-	if (item != NULL) {
-		if (cmdq_get_client(item) != NULL &&
-		    cmdq_get_client(item)->session == NULL)
-			cmdq_get_client(item)->retval = retcode;
-		cmdq_continue(item);
-	}
+	if (cdata->item != NULL)
+		cmdq_continue(cdata->item);
 }

 static void
@@ -301,14 +163,6 @@ cmd_run_shell_free(void *data)
 {
 	struct cmd_run_shell_data	*cdata = data;

-	evtimer_del(&cdata->timer);
-	if (cdata->s != NULL)
-		session_remove_ref(cdata->s, __func__);
-	if (cdata->client != NULL)
-		server_client_unref(cdata->client);
-	if (cdata->state != NULL)
-		args_make_commands_free(cdata->state);
-	free(cdata->cwd);
 	free(cdata->cmd);
 	free(cdata);
 }
--- a/cmd-save-buffer.c
+++ b/cmd-save-buffer.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-save-buffer.c,v 1.57 2025/10/28 07:32:26 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Tiago Cunha <me@tiagocunha.org>
@@ -37,7 +37,7 @@ const struct cmd_entry cmd_save_buffer_entry = {
 	.name = "save-buffer",
 	.alias = "saveb",

-	.args = { "ab:", 1, 1, NULL },
+	.args = { "ab:", 1, 1 },
 	.usage = "[-a] " CMD_BUFFER_USAGE " path",

 	.flags = CMD_AFTERHOOK,
@@ -48,7 +48,7 @@ const struct cmd_entry cmd_show_buffer_entry = {
 	.name = "show-buffer",
 	.alias = "showb",

-	.args = { "b:", 0, 0, NULL },
+	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,

 	.flags = CMD_AFTERHOOK,
@@ -65,21 +65,23 @@ cmd_save_buffer_done(__unused struct client *c, const char *path, int error,
 		return;

 	if (error != 0)
-		cmdq_error(item, "%s: %s", strerror(error), path);
+		cmdq_error(item, "%s: %s", path, strerror(error));
 	cmdq_continue(item);
 }

 static enum cmd_retval
 cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmdq_get_client(item);
+	struct args		*args = self->args;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
 	int			 flags;
 	const char		*bufname = args_get(args, 'b'), *bufdata;
 	size_t			 bufsize;
 	char			*path;
-	struct evbuffer		*evb;

 	if (bufname == NULL) {
 		if ((pb = paste_get_top(NULL)) == NULL) {
@@ -95,24 +97,15 @@ cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	}
 	bufdata = paste_buffer_data(pb, &bufsize);

-	if (cmd_get_entry(self) == &cmd_show_buffer_entry) {
-		if (c->session != NULL || (c->flags & CLIENT_CONTROL)) {
-			evb = evbuffer_new();
-			if (evb == NULL)
-				fatalx("out of memory");
-			evbuffer_add(evb, bufdata, bufsize);
-			cmdq_print_data(item, evb);
-			evbuffer_free(evb);
-			return (CMD_RETURN_NORMAL);
-		}
+	if (self->entry == &cmd_show_buffer_entry)
 		path = xstrdup("-");
-	} else
-		path = format_single_from_target(item, args_string(args, 0));
-	if (args_has(args, 'a'))
+	else
+		path = format_single(item, args->argv[0], c, s, wl, wp);
+	if (args_has(self->args, 'a'))
 		flags = O_APPEND;
 	else
-		flags = O_TRUNC;
-	file_write(cmdq_get_client(item), path, flags, bufdata, bufsize,
+		flags = 0;
+	file_write(item->client, path, flags, bufdata, bufsize,
 	    cmd_save_buffer_done, item);
 	free(path);

--- a/cmd-select-layout.c
+++ b/cmd-select-layout.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-select-layout.c,v 1.45 2026/09/09 07:03:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_select_layout_entry = {
 	.name = "select-layout",
 	.alias = "selectl",

-	.args = { "Enopt:", 0, 1, NULL },
+	.args = { "Enopt:", 0, 1 },
 	.usage = "[-Enop] " CMD_TARGET_PANE_USAGE " [layout-name]",

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -46,7 +46,7 @@ const struct cmd_entry cmd_next_layout_entry = {
 	.name = "next-layout",
 	.alias = "nextl",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -59,7 +59,7 @@ const struct cmd_entry cmd_previous_layout_entry = {
 	.name = "previous-layout",
 	.alias = "prevl",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -71,31 +71,25 @@ const struct cmd_entry cmd_previous_layout_entry = {
 static enum cmd_retval
 cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct client		*c = cmdq_get_target_client(item);
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct window_pane	*wp = target->wp;
+	struct window_pane	*wp = item->target.wp;
 	const char		*layoutname;
-	char			*oldlayout, *cause = NULL;
-	int			 next, previous, layout, flags = 0;
+	char			*oldlayout;
+	int			 next, previous, layout;

 	server_unzoom_window(w);

-	next = (cmd_get_entry(self) == &cmd_next_layout_entry);
+	next = self->entry == &cmd_next_layout_entry;
 	if (args_has(args, 'n'))
 		next = 1;
-	previous = (cmd_get_entry(self) == &cmd_previous_layout_entry);
+	previous = self->entry == &cmd_previous_layout_entry;
 	if (args_has(args, 'p'))
 		previous = 1;

-	if (c != NULL &&
-	    (c->flags & CLIENT_CONTROL) &&
-	    (~c->flags & CLIENT_CONTROL_NEWLAYOUTS))
-		flags |= LAYOUT_CUSTOM_OLD_FORMAT;
 	oldlayout = w->old_layout;
-	w->old_layout = layout_dump(w, w->layout_root, flags);
+	w->old_layout = layout_dump(w->layout_root);

 	if (next || previous) {
 		if (next)
@@ -110,28 +104,27 @@ cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 		goto changed;
 	}

-	if (args_count(args) != 0)
-		layoutname = args_string(args, 0);
-	else if (args_has(args, 'o'))
-		layoutname = oldlayout;
-	else
-		layoutname = NULL;
-
 	if (!args_has(args, 'o')) {
-		if (layoutname == NULL)
+		if (args->argc == 0)
 			layout = w->lastlayout;
 		else
-			layout = layout_set_lookup(layoutname);
+			layout = layout_set_lookup(args->argv[0]);
 		if (layout != -1) {
 			layout_set_select(w, layout);
 			goto changed;
 		}
 	}

+	if (args->argc != 0)
+		layoutname = args->argv[0];
+	else if (args_has(args, 'o'))
+		layoutname = oldlayout;
+	else
+		layoutname = NULL;
+
 	if (layoutname != NULL) {
-		if (layout_parse(w, layoutname, &cause) == -1) {
-			cmdq_error(item, "%s: %s", cause, layoutname);
-			free(cause);
+		if (layout_parse(w, layoutname) == -1) {
+			cmdq_error(item, "can't set layout: %s", layoutname);
 			goto error;
 		}
 		goto changed;
@@ -144,7 +137,7 @@ changed:
 	free(oldlayout);
 	recalculate_sizes();
 	server_redraw_window(w);
-	events_fire_window("window-layout-changed", w);
+	notify_window("window-layout-changed", w);
 	return (CMD_RETURN_NORMAL);

 error:
--- a/cmd-select-pane.c
+++ b/cmd-select-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-select-pane.c,v 1.78 2026/08/20 09:19:24 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_select_pane_entry = {
 	.name = "select-pane",
 	.alias = "selectp",

-	.args = { "DdegLlMmP:RT:t:UZ", 0, 0, NULL }, /* -P and -g deprecated */
+	.args = { "DdegLlMmP:RT:t:UZ", 0, 0 }, /* -P and -g deprecated */
 	.usage = "[-DdeLlMmRUZ] [-T title] " CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -46,7 +46,7 @@ const struct cmd_entry cmd_last_pane_entry = {
 	.name = "last-pane",
 	.alias = "lastp",

-	.args = { "det:Z", 0, 0, NULL },
+	.args = { "det:Z", 0, 0 },
 	.usage = "[-deZ] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -80,95 +80,24 @@ cmd_select_pane_redraw(struct window *w)
 	}
 }

-static enum cmd_retval
-cmd_select_pane_marked_pane(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct event_payload	*ep;
-	struct cmd_find_state	 fs;
-	struct winlink		*wl = target->wl;
-	struct window_pane	*wp = target->wp, *lwp = NULL, *mwp;
-	struct session		*s = target->s;
-
-	if (args_has(args, 'm') && !window_pane_is_visible(wp))
-		return (CMD_RETURN_NORMAL);
-	if (server_check_marked())
-		lwp = marked_pane.wp;
-
-	if (args_has(args, 'M') || server_is_marked(s, wl, wp))
-		server_clear_marked();
-	else
-		server_set_marked(s, wl, wp);
-	mwp = marked_pane.wp;
-
-	ep = event_payload_create();
-	if (mwp != NULL)
-		cmd_find_from_pane(&fs, mwp, 0);
-	else if (lwp != NULL)
-		cmd_find_from_pane(&fs, lwp, 0);
-	else
-		cmd_find_from_pane(&fs, wp, 0);
-	event_payload_set_target(ep, &fs);
-	if (mwp != NULL) {
-		event_payload_set_pane(ep, "pane", mwp);
-		event_payload_set_pane(ep, "new_pane", mwp);
-		event_payload_set_window(ep, "window", mwp->window);
-	} else if (lwp != NULL) {
-		event_payload_set_pane(ep, "pane", lwp);
-		event_payload_set_window(ep, "window", lwp->window);
-	} else {
-		event_payload_set_pane(ep, "pane", wp);
-		event_payload_set_window(ep, "window", wp->window);
-	}
-	if (lwp != NULL)
-		event_payload_set_pane(ep, "old_pane", lwp);
-	event_payload_set_int(ep, "marked", mwp != NULL);
-	events_fire("marked-pane-changed", ep);
-
-	if (lwp != NULL) {
-		lwp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|PANE_THEMECHANGED);
-		server_redraw_window_borders(lwp->window);
-		server_status_window(lwp->window);
-	}
-	if (mwp != NULL) {
-		mwp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|PANE_THEMECHANGED);
-		server_redraw_window_borders(mwp->window);
-		server_status_window(mwp->window);
-	}
-	if (window_pane_is_floating(wp)) {
-		window_redraw_active_switch(wp->window, wp);
-		window_set_active_pane(wp->window, wp, 1);
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
 static enum cmd_retval
 cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	const struct cmd_entry	*entry = cmd_get_entry(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct event_payload	*ep;
-	struct cmd_find_state	 fs;
-	struct winlink		*wl = target->wl;
+	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct session		*s = target->s;
-	struct window_pane	*wp = target->wp, *lastwp;
-	struct options		*oo = wp->options;
-	char			*title;
+	struct session		*s = item->target.s;
+	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
+	char			*pane_title;
 	const char		*style;
+	struct style		*sy;
 	struct options_entry	*o;
-	int			 visible, Zflag = args_has(args, 'Z');

-	if (entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-		/*
-		 * Check for no last pane found in case the other pane was
-		 * spawned without being visited (for example split-window -d).
-		 */
-		lastwp = TAILQ_FIRST(&w->last_panes);
-		if (lastwp == NULL && window_count_panes(w, 1) == 2) {
+	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
+		lastwp = w->last;
+		if (lastwp == NULL && window_count_panes(w) == 2) {
 			lastwp = TAILQ_PREV(w->active, window_panes, entry);
 			if (lastwp == NULL)
 				lastwp = TAILQ_NEXT(w->active, entry);
@@ -177,114 +106,114 @@ cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(args, 'e')) {
+		if (args_has(self->args, 'e'))
 			lastwp->flags &= ~PANE_INPUTOFF;
-			server_redraw_window_borders(lastwp->window);
-			server_status_window(lastwp->window);
-		} else if (args_has(args, 'd')) {
+		else if (args_has(self->args, 'd'))
 			lastwp->flags |= PANE_INPUTOFF;
-			server_redraw_window_borders(lastwp->window);
-			server_status_window(lastwp->window);
-		} else {
-			if (w->modal != NULL && lastwp != w->modal)
-				visible = 1;
-			else
-				visible = window_pane_is_visible(lastwp);
-			if (!visible && window_push_zoom(w, 0, Zflag))
+		else {
+			if (window_push_zoom(w, args_has(self->args, 'Z')))
 				server_redraw_window(w);
 			window_redraw_active_switch(w, lastwp);
 			if (window_set_active_pane(w, lastwp, 1)) {
 				cmd_find_from_winlink(current, wl, 0);
 				cmd_select_pane_redraw(w);
 			}
-			if (!visible && window_pop_zoom(w))
+			if (window_pop_zoom(w))
 				server_redraw_window(w);
 		}
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'm') || args_has(args, 'M'))
-		return (cmd_select_pane_marked_pane(self, item));
+	if (args_has(args, 'm') || args_has(args, 'M')) {
+		if (args_has(args, 'm') && !window_pane_visible(wp))
+			return (CMD_RETURN_NORMAL);
+		lastwp = marked_pane.wp;

-	style = args_get(args, 'P');
-	if (style != NULL) {
-		o = options_set_string(oo, "window-style", 0, "%s", style);
-		if (o == NULL) {
-			cmdq_error(item, "bad style: %s", style);
-			return (CMD_RETURN_ERROR);
+		if (args_has(args, 'M') || server_is_marked(s, wl, wp))
+			server_clear_marked();
+		else
+			server_set_marked(s, wl, wp);
+		markedwp = marked_pane.wp;
+
+		if (lastwp != NULL) {
+			server_redraw_window_borders(lastwp->window);
+			server_status_window(lastwp->window);
+		}
+		if (markedwp != NULL) {
+			server_redraw_window_borders(markedwp->window);
+			server_status_window(markedwp->window);
 		}
-		options_set_string(oo, "window-active-style", 0, "%s", style);
-		wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|PANE_THEMECHANGED);
-	}
-	if (args_has(args, 'g')) {
-		cmdq_print(item, "%s", options_get_string(oo, "window-style"));
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'L')) {
-		window_push_zoom(w, 0, 1);
+	if (args_has(self->args, 'P') || args_has(self->args, 'g')) {
+		if ((style = args_get(args, 'P')) != NULL) {
+			o = options_set_style(wp->options, "window-style", 0,
+			    style);
+			if (o == NULL) {
+				cmdq_error(item, "bad style: %s", style);
+				return (CMD_RETURN_ERROR);
+			}
+			options_set_style(wp->options, "window-active-style", 0,
+			    style);
+			wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED);
+		}
+		if (args_has(self->args, 'g')) {
+			sy = options_get_style(wp->options, "window-style");
+			cmdq_print(item, "%s", style_tostring(sy));
+		}
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (args_has(self->args, 'L')) {
+		window_push_zoom(w, 1);
 		wp = window_pane_find_left(wp);
 		window_pop_zoom(w);
-	} else if (args_has(args, 'R')) {
-		window_push_zoom(w, 0, 1);
+	} else if (args_has(self->args, 'R')) {
+		window_push_zoom(w, 1);
 		wp = window_pane_find_right(wp);
 		window_pop_zoom(w);
-	} else if (args_has(args, 'U')) {
-		window_push_zoom(w, 0, 1);
+	} else if (args_has(self->args, 'U')) {
+		window_push_zoom(w, 1);
 		wp = window_pane_find_up(wp);
 		window_pop_zoom(w);
-	} else if (args_has(args, 'D')) {
-		window_push_zoom(w, 0, 1);
+	} else if (args_has(self->args, 'D')) {
+		window_push_zoom(w, 1);
 		wp = window_pane_find_down(wp);
 		window_pop_zoom(w);
 	}
 	if (wp == NULL)
 		return (CMD_RETURN_NORMAL);

-	if (args_has(args, 'e')) {
+	if (args_has(self->args, 'e')) {
 		wp->flags &= ~PANE_INPUTOFF;
-		server_redraw_window_borders(wp->window);
-		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}
-	if (args_has(args, 'd')) {
+	if (args_has(self->args, 'd')) {
 		wp->flags |= PANE_INPUTOFF;
-		server_redraw_window_borders(wp->window);
-		server_status_window(wp->window);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'T')) {
-		title = format_single_from_target(item, args_get(args, 'T'));
-		if (screen_set_title(&wp->base, title, 0)) {
-			ep = event_payload_create();
-			cmd_find_from_pane(&fs, wp, 0);
-			event_payload_set_target(ep, &fs);
-			event_payload_set_pane(ep, "pane", wp);
-			event_payload_set_window(ep, "window", wp->window);
-			event_payload_set_string(ep, "new_title", "%s", title);
-			events_fire("pane-title-changed", ep);
-			server_redraw_window_borders(wp->window);
+	if (args_has(self->args, 'T')) {
+		pane_title = format_single(item, args_get(self->args, 'T'),
+		    c, s, wl, wp);
+		if (screen_set_title(&wp->base, pane_title))
 			server_status_window(wp->window);
-		}
-		free(title);
+		free(pane_title);
 		return (CMD_RETURN_NORMAL);
 	}

 	if (wp == w->active)
 		return (CMD_RETURN_NORMAL);
-	if (w->modal != NULL && wp != w->modal)
-		visible = 1;
-	else
-		visible = window_pane_is_visible(wp);
-	if (!visible && window_push_zoom(w, 0, Zflag))
+	if (window_push_zoom(w, args_has(self->args, 'Z')))
 		server_redraw_window(w);
 	window_redraw_active_switch(w, wp);
-	if (window_set_active_pane(w, wp, 1))
+	if (window_set_active_pane(w, wp, 1)) {
 		cmd_find_from_winlink_pane(current, wl, wp, 0);
-	cmdq_insert_hook(s, item, current, "after-select-pane");
-	cmd_select_pane_redraw(w);
-	if (!visible && window_pop_zoom(w))
+		cmdq_insert_hook(s, item, current, "after-select-pane");
+		cmd_select_pane_redraw(w);
+	}
+	if (window_pop_zoom(w))
 		server_redraw_window(w);

 	return (CMD_RETURN_NORMAL);
--- a/cmd-select-window.c
+++ b/cmd-select-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-select-window.c,v 1.30 2021/08/21 10:22:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_select_window_entry = {
 	.name = "select-window",
 	.alias = "selectw",

-	.args = { "lnpTt:", 0, 0, NULL },
+	.args = { "lnpTt:", 0, 0 },
 	.usage = "[-lnpT] " CMD_TARGET_WINDOW_USAGE,

 	.target = { 't', CMD_FIND_WINDOW, 0 },
@@ -46,7 +46,7 @@ const struct cmd_entry cmd_next_window_entry = {
 	.name = "next-window",
 	.alias = "next",

-	.args = { "at:", 0, 0, NULL },
+	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -59,7 +59,7 @@ const struct cmd_entry cmd_previous_window_entry = {
 	.name = "previous-window",
 	.alias = "prev",

-	.args = { "at:", 0, 0, NULL },
+	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -72,7 +72,7 @@ const struct cmd_entry cmd_last_window_entry = {
 	.name = "last-window",
 	.alias = "last",

-	.args = { "t:", 0, 0, NULL },
+	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

 	.target = { 't', CMD_FIND_SESSION, 0 },
@@ -84,26 +84,23 @@ const struct cmd_entry cmd_last_window_entry = {
 static enum cmd_retval
 cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*c = cmdq_get_client(item);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct winlink		*wl = target->wl;
-	struct session		*s = target->s;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct winlink		*wl = item->target.wl;
+	struct session		*s = item->target.s;
 	int			 next, previous, last, activity;

-	next = (cmd_get_entry(self) == &cmd_next_window_entry);
-	if (args_has(args, 'n'))
+	next = self->entry == &cmd_next_window_entry;
+	if (args_has(self->args, 'n'))
 		next = 1;
-	previous = (cmd_get_entry(self) == &cmd_previous_window_entry);
-	if (args_has(args, 'p'))
+	previous = self->entry == &cmd_previous_window_entry;
+	if (args_has(self->args, 'p'))
 		previous = 1;
-	last = (cmd_get_entry(self) == &cmd_last_window_entry);
-	if (args_has(args, 'l'))
+	last = self->entry == &cmd_last_window_entry;
+	if (args_has(self->args, 'l'))
 		last = 1;

 	if (next || previous || last) {
-		activity = args_has(args, 'a');
+		activity = args_has(self->args, 'a');
 		if (next) {
 			if (session_next(s, activity) != 0) {
 				cmdq_error(item, "no next window");
@@ -128,7 +125,7 @@ cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 		 * If -T and select-window is invoked on same window as
 		 * current, switch to previous window.
 		 */
-		if (args_has(args, 'T') && wl == s->curw) {
+		if (args_has(self->args, 'T') && wl == s->curw) {
 			if (session_last(s) != 0) {
 				cmdq_error(item, "no last window");
 				return (-1);
@@ -142,8 +139,6 @@ cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		cmdq_insert_hook(s, item, current, "after-select-window");
 	}
-	if (c != NULL && c->session != NULL)
-		s->curw->window->latest = c;
 	recalculate_sizes();

 	return (CMD_RETURN_NORMAL);
--- a/cmd-send-keys.c
+++ b/cmd-send-keys.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-send-keys.c,v 1.81 2026/06/11 19:13:34 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,14 +33,13 @@ const struct cmd_entry cmd_send_keys_entry = {
 	.name = "send-keys",
 	.alias = "send",

-	.args = { "c:FHKlMN:Rt:X", 0, -1, NULL },
-	.usage = "[-FHKlMRX] [-c target-client] [-N repeat-count] "
-	         CMD_TARGET_PANE_USAGE " [key ...]",
+	.args = { "FHlMN:Rt:X", 0, -1 },
+	.usage = "[-FHlMRX] [-N repeat-count] " CMD_TARGET_PANE_USAGE
+	         " key ...",

 	.target = { 't', CMD_FIND_PANE, 0 },

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_CFLAG|CMD_CLIENT_CANFAIL|
-		 CMD_READONLY,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_send_keys_exec
 };

@@ -48,7 +47,7 @@ const struct cmd_entry cmd_send_prefix_entry = {
 	.name = "send-prefix",
 	.alias = NULL,

-	.args = { "2t:", 0, 0, NULL },
+	.args = { "2t:", 0, 0 },
 	.usage = "[-2] " CMD_TARGET_PANE_USAGE,

 	.target = { 't', CMD_FIND_PANE, 0 },
@@ -58,63 +57,43 @@ const struct cmd_entry cmd_send_prefix_entry = {
 };

 static struct cmdq_item *
-cmd_send_keys_inject_key(struct cmdq_item *item, struct cmdq_item *after,
-    struct args *args, key_code key)
+cmd_send_keys_inject_key(struct client *c, struct cmd_find_state *fs,
+    struct cmdq_item *item, key_code key)
 {
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s = target->s;
-	struct winlink			*wl = target->wl;
-	struct window_pane		*wp = target->wp;
+	struct session			*s = fs->s;
+	struct winlink			*wl = fs->wl;
+	struct window_pane		*wp = fs->wp;
 	struct window_mode_entry	*wme;
-	struct key_table		*table = NULL;
+	struct key_table		*table;
 	struct key_binding		*bd;
-	struct key_event		*event;
-	struct cmdq_item		*new_after = after;

-	if (args_has(args, 'K')) {
-		if (tc == NULL)
-			return (item);
-		event = xcalloc(1, sizeof *event);
-		event->key = key|KEYC_SENT;
-		memset(&event->m, 0, sizeof event->m);
-		if (after == NULL) {
-			if (server_client_handle_key(tc, event) != 0)
-				return (item);
-		} else {
-			if (server_client_handle_key_after(tc, event, after,
-			    &new_after) != 0)
-				return (new_after);
-		}
-		free(event->buf);
-		free(event);
-		return (item);
-	}
-
-	wme = TAILQ_FIRST(&wp->modes);
+	wme = TAILQ_FIRST(&fs->wp->modes);
 	if (wme == NULL || wme->mode->key_table == NULL) {
-		if (window_pane_key(wp, tc, s, wl, key, NULL) != 0)
+		if (options_get_number(fs->wp->window->options, "xterm-keys"))
+			key |= KEYC_XTERM;
+		if (window_pane_key(wp, item->client, s, wl, key, NULL) != 0)
 			return (NULL);
 		return (item);
 	}
 	table = key_bindings_get_table(wme->mode->key_table(wme), 1);

-	bd = key_bindings_get(table, key & ~KEYC_MASK_FLAGS);
+	bd = key_bindings_get(table, key & ~KEYC_XTERM);
 	if (bd != NULL) {
 		table->references++;
-		after = key_bindings_dispatch(bd, after, tc, NULL, target);
+		item = key_bindings_dispatch(bd, item, c, NULL, &item->target);
 		key_bindings_unref_table(table);
 	}
-	return (after);
+	return (item);
 }

 static struct cmdq_item *
-cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after,
-    struct args *args, int i)
+cmd_send_keys_inject_string(struct client *c, struct cmd_find_state *fs,
+    struct cmdq_item *item, struct args *args, int i)
 {
-	const char		*s = args_string(args, i);
-	struct utf8_data	*ud, *loop;
-	utf8_char		 uc;
+	const char		*s = args->argv[i];
+	struct cmdq_item	*new_item;
+	struct utf8_data	*ud, *uc;
+	wchar_t			 wc;
 	key_code		 key;
 	char			*endptr;
 	long			 n;
@@ -124,72 +103,56 @@ cmd_send_keys_inject_string(struct cmdq_item *item, struct cmdq_item *after,
 		n = strtol(s, &endptr, 16);
 		if (*s =='\0' || n < 0 || n > 0xff || *endptr != '\0')
 			return (item);
-		return (cmd_send_keys_inject_key(item, after, args,
-		    KEYC_LITERAL|n));
+		return (cmd_send_keys_inject_key(c, fs, item, KEYC_LITERAL|n));
 	}

 	literal = args_has(args, 'l');
 	if (!literal) {
 		key = key_string_lookup_string(s);
 		if (key != KEYC_NONE && key != KEYC_UNKNOWN) {
-			after = cmd_send_keys_inject_key(item, after, args,
-			    key);
-			if (after != NULL)
-				return (after);
+			new_item = cmd_send_keys_inject_key(c, fs, item, key);
+			if (new_item != NULL)
+				return (new_item);
 		}
 		literal = 1;
 	}
 	if (literal) {
 		ud = utf8_fromcstr(s);
-		for (loop = ud; loop->size != 0; loop++) {
-			if (loop->size == 1 && loop->data[0] <= 0x7f)
-				key = loop->data[0];
-			else {
-				if (utf8_from_data(loop, &uc) != UTF8_DONE)
-					continue;
-				key = uc;
-			}
-			after = cmd_send_keys_inject_key(item, after, args,
-			    key);
+		for (uc = ud; uc->size != 0; uc++) {
+			if (utf8_combine(uc, &wc) != UTF8_DONE)
+				continue;
+			item = cmd_send_keys_inject_key(c, fs, item, wc);
 		}
 		free(ud);
 	}
-	return (after);
+	return (item);
 }

 static enum cmd_retval
 cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct client			*tc = cmdq_get_target_client(item);
-	struct session			*s = target->s;
-	struct winlink			*wl = target->wl;
-	struct window_pane		*wp = target->wp;
-	struct key_event		*event = cmdq_get_event(item);
-	struct mouse_event		*m = &event->m;
+	struct args			*args = self->args;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct cmd_find_state		*fs = &item->target;
+	struct window_pane		*wp = item->target.wp;
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
+	struct mouse_event		*m = &item->shared->mouse;
 	struct window_mode_entry	*wme = TAILQ_FIRST(&wp->modes);
-	struct cmdq_item		*after = item;
+	int				 i;
 	key_code			 key;
-	u_int				 i, np = 1;
-	u_int				 count = args_count(args);
+	u_int				 np = 1;
 	char				*cause = NULL;

-	if (tc != NULL && tc->flags & CLIENT_READONLY && !args_has(args, 'X')) {
-		cmdq_error(item, "client is read-only");
-		return (CMD_RETURN_ERROR);
-	}
-
 	if (args_has(args, 'N')) {
-		np = args_strtonum_and_expand(args, 'N', 1, UINT_MAX, item,
-			 &cause);
+		np = args_strtonum(args, 'N', 1, UINT_MAX, &cause);
 		if (cause != NULL) {
 			cmdq_error(item, "repeat count %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-		if (wme != NULL && (args_has(args, 'X') || count == 0)) {
-			if (wme->mode->command == NULL) {
+		if (wme != NULL && (args_has(args, 'X') || args->argc == 0)) {
+			if (wme == NULL || wme->mode->command == NULL) {
 				cmdq_error(item, "not in a mode");
 				return (CMD_RETURN_ERROR);
 			}
@@ -204,7 +167,7 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		if (!m->valid)
 			m = NULL;
-		wme->mode->command(wme, tc, s, wl, args, m);
+		wme->mode->command(wme, c, s, wl, args, m);
 		return (CMD_RETURN_NORMAL);
 	}

@@ -214,40 +177,27 @@ cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "no mouse target");
 			return (CMD_RETURN_ERROR);
 		}
-		window_pane_key(wp, tc, s, wl, m->key, m);
+		window_pane_key(wp, item->client, s, wl, m->key, m);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (cmd_get_entry(self) == &cmd_send_prefix_entry) {
+	if (self->entry == &cmd_send_prefix_entry) {
 		if (args_has(args, '2'))
 			key = options_get_number(s->options, "prefix2");
 		else
 			key = options_get_number(s->options, "prefix");
-		cmd_send_keys_inject_key(item, item, args, key);
+		cmd_send_keys_inject_key(c, fs, item, key);
 		return (CMD_RETURN_NORMAL);
 	}

 	if (args_has(args, 'R')) {
-		colour_palette_clear(&wp->palette);
-		input_reset(wp->ictx, 1);
-		wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED|PANE_REDRAW);
-	}
-
-	if (count == 0) {
-		if (args_has(args, 'N') || args_has(args, 'R'))
-			return (CMD_RETURN_NORMAL);
-		after = args_has(args, 'K') ? item : NULL;
-		for (; np != 0; np--)
-			after = cmd_send_keys_inject_key(item, after, args,
-			    event->key);
-		return (CMD_RETURN_NORMAL);
+		window_pane_reset_palette(wp);
+		input_reset(wp, 1);
 	}

 	for (; np != 0; np--) {
-		for (i = 0; i < count; i++) {
-			after = cmd_send_keys_inject_string(item, after, args,
-			    i);
-		}
+		for (i = 0; i < args->argc; i++)
+			item = cmd_send_keys_inject_string(c, fs, item, args, i);
 	}

 	return (CMD_RETURN_NORMAL);
--- a/cmd-server-access.c
+++ b/cmd-server-access.c
@@ -1,152 +0,0 @@
-/* $OpenBSD: cmd-server-access.c,v 1.6 2026/06/09 12:58:40 nicm Exp $ */
-
-/*
- * Copyright (c) 2021 Dallas Lyons <dallasdlyons@gmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <grp.h>
-#include <pwd.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "tmux.h"
-
-/*
- * Controls access to session.
- */
-
-static enum cmd_retval cmd_server_access_exec(struct cmd *, struct cmdq_item *);
-
-const struct cmd_entry cmd_server_access_entry = {
-	.name = "server-access",
-	.alias = NULL,
-
-	.args = { "adglrw", 0, 1, NULL },
-	.usage = "[-adglrw] " CMD_TARGET_PANE_USAGE " [user|group]",
-
-	.flags = CMD_CLIENT_CANFAIL,
-	.exec = cmd_server_access_exec
-};
-
-static enum cmd_retval
-cmd_server_access_deny(struct cmdq_item *item, id_t id, int flags,
-    const char *type, const char *name)
-{
-	if (!server_acl_find(id, flags)) {
-		cmdq_error(item, "%s %s not found", type, name);
-		return (CMD_RETURN_ERROR);
-	}
-	server_acl_deny(id, flags);
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_server_access_exec(struct cmd *self, struct cmdq_item *item)
-{
-	struct args	*args = cmd_get_args(self);
-	struct client	*c = cmdq_get_target_client(item);
-	char		*arg;
-	const char	*name = NULL, *type;
-	struct passwd	*pw;
-	struct group	*gr;
-	id_t		 id;
-	int		 flags = 0;
-
-	if (args_has(args, 'l')) {
-		server_acl_display(item);
-		return (CMD_RETURN_NORMAL);
-	}
-	if (args_count(args) == 0) {
-		cmdq_error(item, "missing user or group argument");
-		return (CMD_RETURN_ERROR);
-	}
-
-	arg = format_single(item, args_string(args, 0), c, NULL, NULL, NULL);
-	if (args_has(args, 'g')) {
-		type = "group";
-		if ((gr = getgrnam(arg)) != NULL) {
-			id = gr->gr_gid;
-			name = gr->gr_name;
-			flags |= SERVER_ACL_IS_GROUP;
-		}
-	} else {
-		type = "user";
-		if ((pw = getpwnam(arg)) != NULL) {
-			id = pw->pw_uid;
-			name = pw->pw_name;
-		}
-	}
-	if (name == NULL) {
-		cmdq_error(item, "unknown %s: %s", type, arg);
-		free(arg);
-		return (CMD_RETURN_ERROR);
-	}
-	free(arg);
-
-	if ((~flags & SERVER_ACL_IS_GROUP) && (id == 0 || id == getuid())) {
-		cmdq_error(item, "%s owns the server, can't change access",
-		    name);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (args_has(args, 'a') && args_has(args, 'd')) {
-		cmdq_error(item, "-a and -d cannot be used together");
-		return (CMD_RETURN_ERROR);
-	}
-	if (args_has(args, 'w') && args_has(args, 'r')) {
-		cmdq_error(item, "-r and -w cannot be used together");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (args_has(args, 'd'))
-		return (cmd_server_access_deny(item, id, flags, type, name));
-	if (args_has(args, 'a')) {
-		if (server_acl_find(id, flags)) {
-			cmdq_error(item, "%s %s is already added", type, name);
-			return (CMD_RETURN_ERROR);
-		}
-		server_acl_allow(id, flags);
-		/* Do not return - allow -r or -w with -a. */
-	} else if (args_has(args, 'r') || args_has(args, 'w')) {
-		/* -r or -w implies -a if the entry does not exist. */
-		if (!server_acl_find(id, flags))
-			server_acl_allow(id, flags);
-	}
-
-	if (args_has(args, 'w')) {
-		if (!server_acl_find(id, flags)) {
-			cmdq_error(item, "%s %s not found", type, name);
-			return (CMD_RETURN_ERROR);
-		}
-		server_acl_allow_write(id, flags);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (args_has(args, 'r')) {
-		if (!server_acl_find(id, flags)) {
-			cmdq_error(item, "%s %s not found", type, name);
-			return (CMD_RETURN_ERROR);
-		}
-		server_acl_deny_write(id, flags);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-set-buffer.c
+++ b/cmd-set-buffer.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-set-buffer.c,v 1.38 2026/08/24 07:05:23 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -33,11 +33,10 @@ const struct cmd_entry cmd_set_buffer_entry = {
 	.name = "set-buffer",
 	.alias = "setb",

-	.args = { "ab:t:n:w", 0, 1, NULL },
-	.usage = "[-aw] " CMD_BUFFER_USAGE " [-n new-buffer-name] "
-	         CMD_TARGET_CLIENT_USAGE " [data]",
+	.args = { "ab:n:", 0, 1 },
+	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };

@@ -45,7 +44,7 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 	.name = "delete-buffer",
 	.alias = "deleteb",

-	.args = { "b:", 0, 0, NULL },
+	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,

 	.flags = CMD_AFTERHOOK,
@@ -55,63 +54,53 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 static enum cmd_retval
 cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct client		*tc = cmdq_get_target_client(item);
-	struct paste_buffer	*pb = NULL;
-	char			*bufname = NULL, *bufdata = NULL, *cause = NULL;
-	const char		*olddata;
-	size_t			 bufsize = 0, newsize;
+	struct args		*args = self->args;
+	struct paste_buffer	*pb;
+	char			*bufdata, *cause;
+	const char		*bufname, *olddata;
+	size_t			 bufsize, newsize;

-	if (args_get(args, 'b') != NULL) {
-		bufname = xstrdup(args_get(args, 'b'));
+	bufname = args_get(args, 'b');
+	if (bufname == NULL)
+		pb = NULL;
+	else
 		pb = paste_get_name(bufname);
-	}

-	if (cmd_get_entry(self) == &cmd_delete_buffer_entry) {
-		if (pb == NULL) {
-			if (bufname != NULL) {
-				cmdq_error(item, "unknown buffer: %s", bufname);
-				goto fail;
-			}
+	if (self->entry == &cmd_delete_buffer_entry) {
+		if (pb == NULL)
 			pb = paste_get_top(&bufname);
-		}
 		if (pb == NULL) {
 			cmdq_error(item, "no buffer");
-			goto fail;
+			return (CMD_RETURN_ERROR);
 		}
 		paste_free(pb);
-		free(bufname);
 		return (CMD_RETURN_NORMAL);
 	}

 	if (args_has(args, 'n')) {
-		if (pb == NULL) {
-			if (bufname != NULL) {
-				cmdq_error(item, "unknown buffer: %s", bufname);
-				goto fail;
-			}
+		if (pb == NULL)
 			pb = paste_get_top(&bufname);
-		}
 		if (pb == NULL) {
 			cmdq_error(item, "no buffer");
-			goto fail;
+			return (CMD_RETURN_ERROR);
 		}
 		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
 			cmdq_error(item, "%s", cause);
-			goto fail;
+			free(cause);
+			return (CMD_RETURN_ERROR);
 		}
-		free(bufname);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_count(args) != 1) {
+	if (args->argc != 1) {
 		cmdq_error(item, "no data specified");
-		goto fail;
+		return (CMD_RETURN_ERROR);
 	}
-	if ((newsize = strlen(args_string(args, 0))) == 0) {
-		free(bufname);
+	if ((newsize = strlen(args->argv[0])) == 0)
 		return (CMD_RETURN_NORMAL);
-	}
+
+	bufsize = 0;
+	bufdata = NULL;

 	if (args_has(args, 'a') && pb != NULL) {
 		olddata = paste_buffer_data(pb, &bufsize);
@@ -120,22 +109,15 @@ cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	bufdata = xrealloc(bufdata, bufsize + newsize);
-	memcpy(bufdata + bufsize, args_string(args, 0), newsize);
+	memcpy(bufdata + bufsize, args->argv[0], newsize);
 	bufsize += newsize;

 	if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
 		cmdq_error(item, "%s", cause);
-		goto fail;
+		free(bufdata);
+		free(cause);
+		return (CMD_RETURN_ERROR);
 	}
-	if (args_has(args, 'w') && tc != NULL)
- 		tty_set_selection(&tc->tty, "", bufdata, bufsize);

-	free(bufname);
 	return (CMD_RETURN_NORMAL);
-
-fail:
-	free(bufdata);
-	free(bufname);
-	free(cause);
-	return (CMD_RETURN_ERROR);
 }
--- a/cmd-set-environment.c
+++ b/cmd-set-environment.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-set-environment.c,v 1.29 2025/04/09 06:27:43 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,8 +34,8 @@ const struct cmd_entry cmd_set_environment_entry = {
 	.name = "set-environment",
 	.alias = "setenv",

-	.args = { "Fhgrt:u", 1, 2, NULL },
-	.usage = "[-Fhgru] " CMD_TARGET_SESSION_USAGE " variable [value]",
+	.args = { "grt:u", 1, 2 },
+	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",

 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

@@ -46,14 +46,11 @@ const struct cmd_entry cmd_set_environment_entry = {
 static enum cmd_retval
 cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct environ		*env;
-	const char		*name = args_string(args, 0), *value;
-	const char		*tflag;
-	char			*expanded = NULL;
-	enum cmd_retval		 retval = CMD_RETURN_NORMAL;
+	struct args	*args = self->args;
+	struct environ	*env;
+	const char	*name, *value, *target;

+	name = args->argv[0];
 	if (*name == '\0') {
 		cmdq_error(item, "empty variable name");
 		return (CMD_RETURN_ERROR);
@@ -63,57 +60,44 @@ cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 		return (CMD_RETURN_ERROR);
 	}

-	if (args_count(args) < 2)
+	if (args->argc < 2)
 		value = NULL;
 	else
-		value = args_string(args, 1);
-	if (value != NULL && args_has(args, 'F')) {
-		expanded = format_single_from_target(item, value);
-		value = expanded;
-	}
-	if (args_has(args, 'g'))
+		value = args->argv[1];
+
+	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (target->s == NULL) {
-			tflag = args_get(args, 't');
-			if (tflag != NULL)
-				cmdq_error(item, "no such session: %s", tflag);
+		if (item->target.s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
 			else
 				cmdq_error(item, "no current session");
-			retval = CMD_RETURN_ERROR;
-			goto out;
+			return (CMD_RETURN_ERROR);
 		}
-		env = target->s->environ;
+		env = item->target.s->environ;
 	}

-	if (args_has(args, 'u')) {
+	if (args_has(self->args, 'u')) {
 		if (value != NULL) {
 			cmdq_error(item, "can't specify a value with -u");
-			retval = CMD_RETURN_ERROR;
-			goto out;
+			return (CMD_RETURN_ERROR);
 		}
 		environ_unset(env, name);
-	} else if (args_has(args, 'r')) {
+	} else if (args_has(self->args, 'r')) {
 		if (value != NULL) {
 			cmdq_error(item, "can't specify a value with -r");
-			retval = CMD_RETURN_ERROR;
-			goto out;
+			return (CMD_RETURN_ERROR);
 		}
 		environ_clear(env, name);
 	} else {
 		if (value == NULL) {
 			cmdq_error(item, "no value specified");
-			retval = CMD_RETURN_ERROR;
-			goto out;
+			return (CMD_RETURN_ERROR);
 		}
-
-		if (args_has(args, 'h'))
-			environ_set(env, name, ENVIRON_HIDDEN, "%s", value);
-		else
-			environ_set(env, name, 0, "%s", value);
+		environ_set(env, name, "%s", value);
 	}

-out:
-	free(expanded);
-	return (retval);
+	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-set-option.c
+++ b/cmd-set-option.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-set-option.c,v 1.146 2026/07/10 15:20:06 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,6 +18,7 @@

 #include <sys/types.h>

+#include <fnmatch.h>
 #include <stdlib.h>
 #include <string.h>

@@ -27,21 +28,23 @@
 * Set an option.
 */

-static enum args_parse_type	cmd_set_option_args_parse(struct args *,
-				    u_int, char **);
-static enum cmd_retval		cmd_set_option_exec(struct cmd *,
-				    struct cmdq_item *);
-static enum cmd_retval		cmd_set_hook_event_exec(struct cmd *,
-				    struct cmdq_item *);
-static enum cmd_retval		cmd_set_hook_monitor_exec(struct cmdq_item *,
-				    struct args *, int);
+static enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmdq_item *);
+
+static int	cmd_set_option_set(struct cmd *, struct cmdq_item *,
+		    struct options *, struct options_entry *, const char *);
+static int	cmd_set_option_flag(struct cmdq_item *,
+		    const struct options_table_entry *, struct options *,
+		    const char *);
+static int	cmd_set_option_choice(struct cmdq_item *,
+		    const struct options_table_entry *, struct options *,
+		    const char *);

 const struct cmd_entry cmd_set_option_entry = {
 	.name = "set-option",
 	.alias = "set",

-	.args = { "aFgopqst:uUw", 1, 2, cmd_set_option_args_parse },
-	.usage = "[-aFgopqsuUw] " CMD_TARGET_PANE_USAGE " option [value]",
+	.args = { "aFgopqst:uw", 1, 2 },
+	.usage = "[-aFgopqsuw] " CMD_TARGET_PANE_USAGE " option [value]",

 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },

@@ -53,7 +56,7 @@ const struct cmd_entry cmd_set_window_option_entry = {
 	.name = "set-window-option",
 	.alias = "setw",

-	.args = { "aFgoqt:u", 1, 2, cmd_set_option_args_parse },
+	.args = { "aFgoqt:u", 1, 2 },
 	.usage = "[-aFgoqu] " CMD_TARGET_WINDOW_USAGE " option [value]",

 	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },
@@ -66,200 +69,48 @@ const struct cmd_entry cmd_set_hook_entry = {
 	.name = "set-hook",
 	.alias = NULL,

-	.args = { "agpERTt:uB:w", 0, 2, cmd_set_option_args_parse },
-	.usage = "[-agpERTuw] [-B name:what:format] " CMD_TARGET_PANE_USAGE " "
-		 "[hook] [command]",
+	.args = { "agRt:u", 1, 2 },
+	.usage = "[-agRu] " CMD_TARGET_SESSION_USAGE " hook [command]",

-	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
 };

-static enum args_parse_type
-cmd_set_option_args_parse(struct args *args, u_int idx,
-    __unused char **cause)
-{
-	if (args_has(args, 'B'))
-		return (ARGS_PARSE_COMMANDS_OR_STRING);
-	if (idx == 1)
-		return (ARGS_PARSE_COMMANDS_OR_STRING);
-	return (ARGS_PARSE_STRING);
-}
-
-static enum cmd_retval
-cmd_set_hook_event_exec(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct event_payload	*ep;
-	struct client		*c;
-	char			*argument;
-
-	if (args_count(args) == 0) {
-		cmdq_error(item, "missing argument");
-		return (CMD_RETURN_ERROR);
-	}
-	if (args_count(args) != 1) {
-		cmdq_error(item, "too many arguments");
-		return (CMD_RETURN_ERROR);
-	}
-
-	argument = format_single_from_target(item, args_string(args, 0));
-	if (*argument != '@') {
-		cmdq_error(item, "event name must start with @");
-		free(argument);
-		return (CMD_RETURN_ERROR);
-	}
-
-	ep = event_payload_create();
-	event_payload_set_target(ep, target);
-	c = cmdq_get_client(item);
-	if (c != NULL)
-		event_payload_set_client(ep, "client", c);
-	if (target->s != NULL)
-		event_payload_set_session(ep, "session", target->s);
-	if (target->w != NULL)
-		event_payload_set_window(ep, "window", target->w);
-	if (target->wl != NULL)
-		event_payload_set_int(ep, "window_index", target->wl->idx);
-	else if (target->idx != -1)
-		event_payload_set_int(ep, "window_index", target->idx);
-	if (target->wp != NULL)
-		event_payload_set_pane(ep, "pane", target->wp);
-	events_fire(argument, ep);
-	free(argument);
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_set_hook_monitor_exec(struct cmdq_item *item, struct args *args, int window)
-{
-	struct cmd_find_state	*target = cmdq_get_target(item), fs;
-	struct options		*oo;
-	struct options_entry	*o;
-	struct session		*s = NULL;
-	char			*cause = NULL, *name = NULL, *format = NULL;
-	char			*expanded = NULL, *newvalue = NULL;
-	const char		*value, *old;
-	enum monitor_type	 type;
-	int			 id, scope, flags = 0;
-
-	if (args_count(args) > 1) {
-		cmdq_error(item, "too many arguments");
-		return (CMD_RETURN_ERROR);
-	}
-
-	value = args_get(args, 'B');
-	if (args_has(args, 'u')) {
-		if (monitor_parse(value, &name, &type, &id, &format) != 0)
-			name = xstrdup(value);
-		free(format);
-		format = NULL;
-	} else {
-		if (monitor_parse(value, &name, &type, &id, &format) != 0) {
-			cmdq_error(item, "invalid subscription: %s", value);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	if (*name != '@') {
-		cmdq_error(item, "monitor hook name must start with @");
-		goto fail;
-	}
-
-	scope = options_scope_from_name(args, window, name, target, &oo,
-	    &cause);
-	if (scope == OPTIONS_TABLE_NONE) {
-		cmdq_error(item, "%s", cause);
-		free(cause);
-		goto fail;
-	}
-	cmd_find_copy_state(&fs, target);
-
-	if (args_has(args, 'u')) {
-		hooks_monitor_remove(oo, name);
-		goto out;
-	}
-
-	if (args_count(args) != 0) {
-		value = args_string(args, 0);
-		if (args_has(args, 'F')) {
-			expanded = format_single_from_target(item, value);
-			value = expanded;
-		}
-		o = options_get_only(oo, name);
-		if (!args_has(args, 'o') || o == NULL) {
-			if (args_has(args, 'a') && o != NULL) {
-				old = options_get_string(oo, name);
-				xasprintf(&newvalue, "%s%s", old, value);
-				value = newvalue;
-			}
-			options_set_string(oo, name, 0, "%s", value);
-			options_push_changes(name);
-		}
-	}
-
-	if (oo != global_options &&
-	    oo != global_s_options &&
-	    oo != global_w_options)
-		s = target->s;
-	if (args_has(args, 'T'))
-		flags |= MONITOR_NOTIFY_TRUE;
-	hooks_monitor_add(item, oo, name, type, id, format, flags, &fs, s);
-
-out:
-	free(newvalue);
-	free(expanded);
-	free(name);
-	free(format);
-	return (CMD_RETURN_NORMAL);
-
-fail:
-	free(newvalue);
-	free(expanded);
-	free(name);
-	free(format);
-	return (CMD_RETURN_ERROR);
-}
-
 static enum cmd_retval
 cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
+	struct args			*args = self->args;
 	int				 append = args_has(args, 'a');
-	struct cmd_find_state		*target = cmdq_get_target(item);
-	struct window_pane		*loop;
+	struct cmd_find_state		*fs = &item->target;
+	struct client			*c, *loop;
+	struct session			*s = fs->s;
+	struct winlink			*wl = fs->wl;
+	struct window			*w;
+	struct window_pane		*wp;
 	struct options			*oo;
-	struct options_entry		*parent, *o, *po;
-	char				*name, *argument, *cause;
-	char				*expanded = NULL, *array_key = NULL;
-	const char			*value;
-	int				 window, already, error, ambiguous;
+	struct options_entry		*parent, *o;
+	char				*name, *argument, *value = NULL, *cause;
+	int				 window, idx, already, error, ambiguous;
 	int				 scope;
+	struct style			*sy;

-	window = (cmd_get_entry(self) == &cmd_set_window_option_entry);
-	if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'E'))
-		return (cmd_set_hook_event_exec(self, item));
-	if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'B'))
-		return (cmd_set_hook_monitor_exec(item, args, window));
-	if (args_count(args) == 0) {
-		cmdq_error(item, "missing argument");
-		return (CMD_RETURN_ERROR);
-	}
+	window = (self->entry == &cmd_set_window_option_entry);

 	/* Expand argument. */
-	argument = format_single_from_target(item, args_string(args, 0));
+	c = cmd_find_client(item, NULL, 1);
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);

 	/* If set-hook -R, fire the hook straight away. */
-	if (cmd_get_entry(self) == &cmd_set_hook_entry && args_has(args, 'R')) {
-		hooks_run(item, argument);
+	if (self->entry == &cmd_set_hook_entry && args_has(args, 'R')) {
+		notify_hook(item, argument);
 		free(argument);
 		return (CMD_RETURN_NORMAL);
 	}

-	/* Parse option name and array key. */
-	name = options_match(argument, &array_key, &ambiguous);
+	/* Parse option name and index. */
+	name = options_match(argument, &idx, &ambiguous);
 	if (name == NULL) {
 		if (args_has(args, 'q'))
 			goto out;
@@ -269,18 +120,15 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 			cmdq_error(item, "invalid option: %s", argument);
 		goto fail;
 	}
-	if (args_count(args) < 2)
+	if (args->argc < 2)
 		value = NULL;
+	else if (args_has(args, 'F'))
+		value = format_single(item, args->argv[1], c, s, wl, NULL);
 	else
-		value = args_string(args, 1);
-	if (value != NULL && args_has(args, 'F')) {
-		expanded = format_single_from_target(item, value);
-		value = expanded;
-	}
+		value = xstrdup(args->argv[1]);

 	/* Get the scope and table for the option .*/
-	scope = options_scope_from_name(args, window, name, target, &oo,
-	    &cause);
+	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
 	if (scope == OPTIONS_TABLE_NONE) {
 		if (args_has(args, 'q'))
 			goto out;
@@ -291,23 +139,21 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	o = options_get_only(oo, name);
 	parent = options_get(oo, name);

-	/* Check that array options and keys match up. */
-	if (array_key != NULL && (*name == '@' || !options_is_array(parent))) {
+	/* Check that array options and indexes match up. */
+	if (idx != -1 && (*name == '@' || !options_isarray(parent))) {
 		cmdq_error(item, "not an array: %s", argument);
 		goto fail;
 	}

 	/* With -o, check this option is not already set. */
 	if (!args_has(args, 'u') && args_has(args, 'o')) {
-		if (array_key == NULL)
+		if (idx == -1)
 			already = (o != NULL);
 		else {
 			if (o == NULL)
 				already = 0;
-			else if (options_array_get(o, array_key) != NULL)
-				already = 1;
 			else
-				already = 0;
+				already = (options_array_get(o, idx) != NULL);
 		}
 		if (already) {
 			if (args_has(args, 'q'))
@@ -318,23 +164,19 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 	}

 	/* Change the option. */
-	if (args_has(args, 'U') && scope == OPTIONS_TABLE_WINDOW) {
-		TAILQ_FOREACH(loop, &target->w->panes, entry) {
-			po = options_get_only(loop->options, name);
-			if (po == NULL)
-				continue;
-			if (options_remove_or_default(po, array_key,
-			    &cause) != 0) {
-				cmdq_error(item, "%s", cause);
-				free(cause);
-				goto fail;
-			}
-		}
-	}
-	if (args_has(args, 'u') || args_has(args, 'U')) {
+	if (args_has(args, 'u')) {
 		if (o == NULL)
 			goto out;
-		if (options_remove_or_default(o, array_key, &cause) != 0) {
+		if (idx == -1) {
+			if (*name == '@')
+				options_remove(o);
+			else if (oo == global_options ||
+			    oo == global_s_options ||
+			    oo == global_w_options)
+				options_default(oo, options_table_entry(o));
+			else
+				options_remove(o);
+		} else if (options_array_set(o, idx, NULL, 0, &cause) != 0) {
 			cmdq_error(item, "%s", cause);
 			free(cause);
 			goto fail;
@@ -345,17 +187,10 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 			goto fail;
 		}
 		options_set_string(oo, name, append, "%s", value);
-		if (cmd_get_entry(self) == &cmd_set_hook_entry)
-			hooks_add_event(name);
-	} else if (array_key == NULL && !options_is_array(parent)) {
-		error = options_from_string(oo, options_table_entry(parent),
-		    options_table_entry(parent)->name, value,
-		    args_has(args, 'a'), &cause);
-		if (error != 0) {
-			cmdq_error(item, "%s", cause);
-			free(cause);
+	} else if (idx == -1 && !options_isarray(parent)) {
+		error = cmd_set_option_set(self, item, oo, parent, value);
+		if (error != 0)
 			goto fail;
-		}
 	} else {
 		if (value == NULL) {
 			cmdq_error(item, "empty value");
@@ -363,7 +198,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 		}
 		if (o == NULL)
 			o = options_empty(oo, options_table_entry(parent));
-		if (array_key == NULL) {
+		if (idx == -1) {
 			if (!append)
 				options_array_clear(o);
 			if (options_array_assign(o, value, &cause) != 0) {
@@ -371,7 +206,7 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 				free(cause);
 				goto fail;
 			}
-		} else if (options_array_set(o, array_key, value, append,
+		} else if (options_array_set(o, idx, value, append,
 		    &cause) != 0) {
 			cmdq_error(item, "%s", cause);
 			free(cause);
@@ -379,19 +214,198 @@ cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 		}
 	}

-	options_push_changes(name);
+	/* Update timers and so on for various options. */
+	if (strcmp(name, "automatic-rename") == 0) {
+		RB_FOREACH(w, windows, &windows) {
+			if (w->active == NULL)
+				continue;
+			if (options_get_number(w->options, "automatic-rename"))
+				w->active->flags |= PANE_CHANGED;
+		}
+	}
+	if (strcmp(name, "key-table") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry)
+			server_client_set_key_table(loop, NULL);
+	}
+	if (strcmp(name, "user-keys") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry) {
+			if (loop->tty.flags & TTY_OPENED)
+				tty_keys_build(&loop->tty);
+		}
+	}
+	if (strcmp(name, "status-fg") == 0 || strcmp(name, "status-bg") == 0) {
+		sy = options_get_style(oo, "status-style");
+		sy->gc.fg = options_get_number(oo, "status-fg");
+		sy->gc.bg = options_get_number(oo, "status-bg");
+	}
+	if (strcmp(name, "status-style") == 0) {
+		sy = options_get_style(oo, "status-style");
+		options_set_number(oo, "status-fg", sy->gc.fg);
+		options_set_number(oo, "status-bg", sy->gc.bg);
+	}
+	if (strcmp(name, "status") == 0 ||
+	    strcmp(name, "status-interval") == 0)
+		status_timer_start_all();
+	if (strcmp(name, "monitor-silence") == 0)
+		alerts_reset_all();
+	if (strcmp(name, "window-style") == 0 ||
+	    strcmp(name, "window-active-style") == 0) {
+		RB_FOREACH(wp, window_pane_tree, &all_window_panes)
+			wp->flags |= PANE_STYLECHANGED;
+	}
+	if (strcmp(name, "pane-border-status") == 0) {
+		RB_FOREACH(w, windows, &windows)
+			layout_fix_panes(w);
+	}
+	RB_FOREACH(s, sessions, &sessions)
+		status_update_cache(s);
+
+	/*
+	 * Update sizes and redraw. May not always be necessary but do it
+	 * anyway.
+	 */
+	recalculate_sizes();
+	TAILQ_FOREACH(loop, &clients, entry) {
+		if (loop->session != NULL)
+			server_redraw_client(loop);
+	}

 out:
 	free(argument);
-	free(expanded);
+	free(value);
 	free(name);
-	free(array_key);
 	return (CMD_RETURN_NORMAL);

 fail:
 	free(argument);
-	free(expanded);
+	free(value);
 	free(name);
-	free(array_key);
 	return (CMD_RETURN_ERROR);
 }
+
+static int
+cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
+    struct options_entry *parent, const char *value)
+{
+	const struct options_table_entry	*oe;
+	struct args				*args = self->args;
+	int					 append = args_has(args, 'a');
+	struct options_entry			*o;
+	long long				 number;
+	const char				*errstr, *new;
+	char					*old;
+	key_code				 key;
+
+	oe = options_table_entry(parent);
+	if (value == NULL &&
+	    oe->type != OPTIONS_TABLE_FLAG &&
+	    oe->type != OPTIONS_TABLE_CHOICE) {
+		cmdq_error(item, "empty value");
+		return (-1);
+	}
+
+	switch (oe->type) {
+	case OPTIONS_TABLE_STRING:
+		old = xstrdup(options_get_string(oo, oe->name));
+		options_set_string(oo, oe->name, append, "%s", value);
+		new = options_get_string(oo, oe->name);
+		if (oe->pattern != NULL && fnmatch(oe->pattern, new, 0) != 0) {
+			options_set_string(oo, oe->name, 0, "%s", old);
+			free(old);
+			cmdq_error(item, "value is invalid: %s", value);
+			return (-1);
+		}
+		free(old);
+		return (0);
+	case OPTIONS_TABLE_NUMBER:
+		number = strtonum(value, oe->minimum, oe->maximum, &errstr);
+		if (errstr != NULL) {
+			cmdq_error(item, "value is %s: %s", errstr, value);
+			return (-1);
+		}
+		options_set_number(oo, oe->name, number);
+		return (0);
+	case OPTIONS_TABLE_KEY:
+		key = key_string_lookup_string(value);
+		if (key == KEYC_UNKNOWN) {
+			cmdq_error(item, "bad key: %s", value);
+			return (-1);
+		}
+		options_set_number(oo, oe->name, key);
+		return (0);
+	case OPTIONS_TABLE_COLOUR:
+		if ((number = colour_fromstring(value)) == -1) {
+			cmdq_error(item, "bad colour: %s", value);
+			return (-1);
+		}
+		options_set_number(oo, oe->name, number);
+		return (0);
+	case OPTIONS_TABLE_FLAG:
+		return (cmd_set_option_flag(item, oe, oo, value));
+	case OPTIONS_TABLE_CHOICE:
+		return (cmd_set_option_choice(item, oe, oo, value));
+	case OPTIONS_TABLE_STYLE:
+		o = options_set_style(oo, oe->name, append, value);
+		if (o == NULL) {
+			cmdq_error(item, "bad style: %s", value);
+			return (-1);
+		}
+		return (0);
+	case OPTIONS_TABLE_COMMAND:
+		break;
+	}
+	return (-1);
+}
+
+static int
+cmd_set_option_flag(struct cmdq_item *item,
+    const struct options_table_entry *oe, struct options *oo,
+    const char *value)
+{
+	int	flag;
+
+	if (value == NULL || *value == '\0')
+		flag = !options_get_number(oo, oe->name);
+	else if (strcmp(value, "1") == 0 ||
+	    strcasecmp(value, "on") == 0 ||
+	    strcasecmp(value, "yes") == 0)
+		flag = 1;
+	else if (strcmp(value, "0") == 0 ||
+	    strcasecmp(value, "off") == 0 ||
+	    strcasecmp(value, "no") == 0)
+		flag = 0;
+	else {
+		cmdq_error(item, "bad value: %s", value);
+		return (-1);
+	}
+	options_set_number(oo, oe->name, flag);
+	return (0);
+}
+
+static int
+cmd_set_option_choice(struct cmdq_item *item,
+    const struct options_table_entry *oe, struct options *oo,
+    const char *value)
+{
+	const char	**cp;
+	int		  n, choice = -1;
+
+	if (value == NULL) {
+		choice = options_get_number(oo, oe->name);
+		if (choice < 2)
+			choice = !choice;
+	} else {
+		n = 0;
+		for (cp = oe->choices; *cp != NULL; cp++) {
+			if (strcmp(*cp, value) == 0)
+				choice = n;
+			n++;
+		}
+		if (choice == -1) {
+			cmdq_error(item, "unknown value: %s", value);
+			return (-1);
+		}
+	}
+	options_set_number(oo, oe->name, choice);
+	return (0);
+}
--- a/cmd-show-environment.c
+++ b/cmd-show-environment.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-show-environment.c,v 1.29 2025/04/09 06:27:43 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -38,8 +38,8 @@ const struct cmd_entry cmd_show_environment_entry = {
 	.name = "show-environment",
 	.alias = "showenv",

-	.args = { "hgst:", 0, 1, NULL },
-	.usage = "[-hgs] " CMD_TARGET_SESSION_USAGE " [variable]",
+	.args = { "gst:", 0, 1 },
+	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",

 	.target = { 't', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

@@ -69,15 +69,9 @@ static void
 cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
    struct environ_entry *envent)
 {
-	struct args	*args = cmd_get_args(self);
-	char		*escaped;
+	char	*escaped;

-	if (!args_has(args, 'h') && (envent->flags & ENVIRON_HIDDEN))
-		return;
-	if (args_has(args, 'h') && (~envent->flags & ENVIRON_HIDDEN))
-		return;
-
-	if (!args_has(args, 's')) {
+	if (!args_has(self->args, 's')) {
 		if (envent->value != NULL)
 			cmdq_print(item, "%s=%s", envent->name, envent->value);
 		else
@@ -97,37 +91,36 @@ cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
 static enum cmd_retval
 cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct args		*args = self->args;
 	struct environ		*env;
 	struct environ_entry	*envent;
-	const char		*tflag, *name = args_string(args, 0);
+	const char		*target;

-	if ((tflag = args_get(args, 't')) != NULL) {
-		if (target->s == NULL) {
-			cmdq_error(item, "no such session: %s", tflag);
+	if ((target = args_get(args, 't')) != NULL) {
+		if (item->target.s == NULL) {
+			cmdq_error(item, "no such session: %s", target);
 			return (CMD_RETURN_ERROR);
 		}
 	}

-	if (args_has(args, 'g'))
+	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (target->s == NULL) {
-			tflag = args_get(args, 't');
-			if (tflag != NULL)
-				cmdq_error(item, "no such session: %s", tflag);
+		if (item->target.s == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
 			else
 				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = target->s->environ;
+		env = item->target.s->environ;
 	}

-	if (name != NULL) {
-		envent = environ_find(env, name);
+	if (args->argc != 0) {
+		envent = environ_find(env, args->argv[0]);
 		if (envent == NULL) {
-			cmdq_error(item, "unknown variable: %s", name);
+			cmdq_error(item, "unknown variable: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
 		cmd_show_environment_print(self, item, envent);
--- a/cmd-show-messages.c
+++ b/cmd-show-messages.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-show-messages.c,v 1.37 2025/11/18 08:37:54 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -18,19 +18,16 @@

 #include <sys/types.h>

-#include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include <unistd.h>

 #include "tmux.h"

 /*
- * Show message log.
+ * Show client message log.
 */

-#define SHOW_MESSAGES_TEMPLATE \
-	"#{t/p:message_time}: #{message_text}"
-
 static enum cmd_retval	cmd_show_messages_exec(struct cmd *,
 			    struct cmdq_item *);

@@ -38,31 +35,29 @@ const struct cmd_entry cmd_show_messages_entry = {
 	.name = "show-messages",
 	.alias = "showmsgs",

-	.args = { "JTt:", 0, 0, NULL },
+	.args = { "JTt:", 0, 0 },
 	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,

-	.flags = CMD_AFTERHOOK|CMD_CLIENT_TFLAG|CMD_CLIENT_CANFAIL,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_messages_exec
 };

+static int	cmd_show_messages_terminals(struct cmdq_item *, int);
+
 static int
-cmd_show_messages_terminals(struct cmd *self, struct cmdq_item *item, int blank)
+cmd_show_messages_terminals(struct cmdq_item *item, int blank)
 {
-	struct args	*args = cmd_get_args(self);
-	struct client	*tc = cmdq_get_target_client(item);
 	struct tty_term	*term;
 	u_int		 i, n;

 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
-		if (args_has(args, 't') && tc != NULL && term != tc->tty.term)
-			continue;
 		if (blank) {
 			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(item, "Terminal %u: %s for %s, flags=0x%x:", n,
-		    term->name, term->tty->client->name, term->flags);
+		cmdq_print(item, "Terminal %u: %s [references=%u, flags=0x%x]:",
+		    n, term->name, term->references, term->flags);
 		n++;
 		for (i = 0; i < tty_term_ncodes(); i++)
 			cmdq_print(item, "%s", tty_term_describe(term, i));
@@ -73,15 +68,18 @@ cmd_show_messages_terminals(struct cmd *self, struct cmdq_item *item, int blank)
 static enum cmd_retval
 cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
+	struct args		*args = self->args;
+	struct client		*c;
 	struct message_entry	*msg;
-	char			*s;
+	char			*tim;
 	int			 done, blank;
-	struct format_tree	*ft;
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);

 	done = blank = 0;
 	if (args_has(args, 'T')) {
-		blank = cmd_show_messages_terminals(self, item, blank);
+		blank = cmd_show_messages_terminals(item, blank);
 		done = 1;
 	}
 	if (args_has(args, 'J')) {
@@ -91,17 +89,12 @@ cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 	if (done)
 		return (CMD_RETURN_NORMAL);

-	ft = format_create_from_target(item);
-	TAILQ_FOREACH_REVERSE(msg, &message_log, message_list, entry) {
-		format_add(ft, "message_text", "%s", msg->msg);
-		format_add(ft, "message_number", "%u", msg->msg_num);
-		format_add_tv(ft, "message_time", &msg->msg_time);
+	TAILQ_FOREACH(msg, &c->message_log, entry) {
+		tim = ctime(&msg->msg_time);
+		*strchr(tim, '\n') = '\0';

-		s = format_expand(ft, SHOW_MESSAGES_TEMPLATE);
-		cmdq_print(item, "%s", s);
-		free(s);
+		cmdq_print(item, "%s %s", tim, msg->msg);
 	}
-	format_free(ft);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-show-options.c
+++ b/cmd-show-options.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-show-options.c,v 1.76 2026/07/27 19:15:58 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,23 +27,10 @@
 * Show options.
 */

-#define SHOW_OPTIONS_TEMPLATE						\
-	"#{?option_value_only,"						\
-	"#{option_value},"						\
-	"#{option_name}#{?option_has_array_key,"			\
-	"[#{option_array_key}],}"					\
-	"#{?option_is_parent,*,}"					\
-	"#{?option_has_value, "						\
-	"#{?option_is_string,#{q/a:option_value},#{option_value}},}}"
-#define SHOW_HOOKS_MONITOR_TEMPLATE					\
-	"#{option_name}:#{hook_monitor_target}:#{hook_monitor_format}"
-
 static enum cmd_retval	cmd_show_options_exec(struct cmd *, struct cmdq_item *);

 static void		cmd_show_options_print(struct cmd *, struct cmdq_item *,
-			    struct options_entry *, const char *, int);
-static void		cmd_show_hooks_print_monitor(struct cmd *,
-			    struct cmdq_item *, struct options_entry *);
+			    struct options_entry *, int, int);
 static enum cmd_retval	cmd_show_options_all(struct cmd *, struct cmdq_item *,
 			    int, struct options *);

@@ -51,8 +38,8 @@ const struct cmd_entry cmd_show_options_entry = {
 	.name = "show-options",
 	.alias = "show",

-	.args = { "AgF:Hpqst:vw", 0, 1, NULL },
-	.usage = "[-AgHpqsvw] [-F format] " CMD_TARGET_PANE_USAGE " [option]",
+	.args = { "AgHpqst:vw", 0, 1 },
+	.usage = "[-AgHpqsvw] " CMD_TARGET_PANE_USAGE " [option]",

 	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },

@@ -64,8 +51,8 @@ const struct cmd_entry cmd_show_window_options_entry = {
 	.name = "show-window-options",
 	.alias = "showw",

-	.args = { "F:gvt:", 0, 1, NULL },
-	.usage = "[-gv] [-F format] " CMD_TARGET_WINDOW_USAGE " [option]",
+	.args = { "gvt:", 0, 1 },
+	.usage = "[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",

 	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

@@ -77,10 +64,10 @@ const struct cmd_entry cmd_show_hooks_entry = {
 	.name = "show-hooks",
 	.alias = NULL,

-	.args = { "BF:gpt:w", 0, 1, NULL },
-	.usage = "[-Bgpw] [-F format] " CMD_TARGET_PANE_USAGE " [hook]",
+	.args = { "gt:", 0, 1 },
+	.usage = "[-g] " CMD_TARGET_SESSION_USAGE,

-	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
@@ -89,19 +76,20 @@ const struct cmd_entry cmd_show_hooks_entry = {
 static enum cmd_retval
 cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
-	struct cmd_find_state		*target = cmdq_get_target(item);
+	struct args			*args = self->args;
+	struct cmd_find_state		*fs = &item->target;
+	struct client			*c = cmd_find_client(item, NULL, 1);
+	struct session			*s = item->target.s;
+	struct winlink			*wl = item->target.wl;
 	struct options			*oo;
 	char				*argument, *name = NULL, *cause;
-	char				*array_key = NULL;
-	int				 window, ambiguous, parent, print_parent, scope;
+	int				 window, idx, ambiguous, parent, scope;
 	struct options_entry		*o;

-	window = (cmd_get_entry(self) == &cmd_show_window_options_entry);
+	window = (self->entry == &cmd_show_window_options_entry);

-	if (args_count(args) == 0) {
-		scope = options_scope_from_flags(args, window, target, &oo,
-		    &cause);
+	if (args->argc == 0) {
+		scope = options_scope_from_flags(args, window, fs, &oo, &cause);
 		if (scope == OPTIONS_TABLE_NONE) {
 			if (args_has(args, 'q'))
 				return (CMD_RETURN_NORMAL);
@@ -109,34 +97,24 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-		if (cmd_get_entry(self) == &cmd_show_hooks_entry &&
-		    args_has(args, 'B')) {
-			o = options_first(oo);
-			while (o != NULL) {
-				cmd_show_hooks_print_monitor(self, item, o);
-				o = options_next(o);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
 		return (cmd_show_options_all(self, item, scope, oo));
 	}
-	argument = format_single_from_target(item, args_string(args, 0));
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);

-	name = options_match(argument, &array_key, &ambiguous);
+	name = options_match(argument, &idx, &ambiguous);
 	if (name == NULL) {
 		if (args_has(args, 'q'))
-			goto out;
+			goto fail;
 		if (ambiguous)
 			cmdq_error(item, "ambiguous option: %s", argument);
 		else
 			cmdq_error(item, "invalid option: %s", argument);
 		goto fail;
 	}
-	scope = options_scope_from_name(args, window, name, target, &oo,
-	    &cause);
+	scope = options_scope_from_name(args, window, name, fs, &oo, &cause);
 	if (scope == OPTIONS_TABLE_NONE) {
 		if (args_has(args, 'q'))
-			goto out;
+			goto fail;
 		cmdq_error(item, "%s", cause);
 		free(cause);
 		goto fail;
@@ -147,240 +125,102 @@ cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 		parent = 1;
 	} else
 		parent = 0;
-	if (o != NULL) {
-		if (cmd_get_entry(self) == &cmd_show_hooks_entry &&
-		    args_has(args, 'B'))
-			cmd_show_hooks_print_monitor(self, item, o);
-		else {
-			print_parent = parent;
-			if (array_key == NULL && options_is_array(o) &&
-			    options_array_first(o) == NULL) {
-				print_parent = 0;
-			}
-			cmd_show_options_print(self, item, o, array_key,
-			    print_parent);
-		}
-	} else if (*name == '@') {
-		if (args_has(args, 'q'))
-			goto out;
-		cmdq_error(item, "invalid option: %s", argument);
-		goto fail;
-	}
+	if (o != NULL)
+		cmd_show_options_print(self, item, o, idx, parent);

-out:
 	free(name);
-	free(array_key);
 	free(argument);
 	return (CMD_RETURN_NORMAL);

 fail:
 	free(name);
-	free(array_key);
 	free(argument);
 	return (CMD_RETURN_ERROR);
 }

 static void
 cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
-    struct options_entry *o, const char *array_key, int parent)
+    struct options_entry *o, int idx, int parent)
 {
-	struct args			 *args = cmd_get_args(self);
-	struct options_array_item	 *a;
-	struct format_tree		 *ft;
-	const char			 *name = options_name(o);
-	const char			 *template = args_get(args, 'F');
-	char				 *value, *line;
-	struct timeval			  tv = { 0 };
-	u_int				  fire_count;
-	time_t				  fire_time;
-	int				  is_hook = 0, is_user = 0;
-	int				  has_value = 1;
-	const struct options_table_entry *oe = options_table_entry(o);
+	struct options_array_item	*a;
+	const char			*name = options_name(o);
+	char				*value, *tmp = NULL, *escaped;

-	if (array_key != NULL)
-		value = options_to_string(o, array_key, 0);
-	else if (options_is_array(o)) {
-		a = options_array_first(o);
-		if (a != NULL) {
+	if (idx != -1) {
+		xasprintf(&tmp, "%s[%d]", name, idx);
+		name = tmp;
+	} else {
+		if (options_isarray(o)) {
+			a = options_array_first(o);
+			if (a == NULL) {
+				if (!args_has(self->args, 'v'))
+					cmdq_print(item, "%s", name);
+				return;
+			}
 			while (a != NULL) {
-				array_key = options_array_item_key(a);
-				cmd_show_options_print(self, item, o, array_key,
+				idx = options_array_item_index(a);
+				cmd_show_options_print(self, item, o, idx,
 				    parent);
 				a = options_array_next(a);
 			}
 			return;
 		}
-		if (template == NULL && args_has(args, 'v'))
-			return;
-		value = xstrdup("");
-		has_value = 0;
-	} else
-		value = options_to_string(o, NULL, 0);
-
-	if (template == NULL)
-		template = SHOW_OPTIONS_TEMPLATE;
-
-	if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK))
-		is_hook = 1;
-	else if (oe == NULL)
-		is_user = 1;
-
-	ft = format_create_from_target(item);
-	format_add(ft, "option_name", "%s", name);
-	format_add(ft, "option_value", "%s", value);
-	format_add(ft, "option_value_only", "%d", args_has(args, 'v'));
-	format_add(ft, "option_is_parent", "%d", parent);
-	format_add(ft, "option_is_array", "%d", options_is_array(o));
-	format_add(ft, "option_is_string", "%d", options_is_string(o));
-	format_add(ft, "option_is_hook", "%d", is_hook);
-	format_add(ft, "option_is_user", "%d", is_user);
-	format_add(ft, "option_has_value", "%d", has_value);
-	if (cmd_get_entry(self) == &cmd_show_hooks_entry) {
-		fire_count = options_get_fire_count(o);
-		format_add(ft, "hook_fire_count", "%u", fire_count);
-
-		fire_time = options_get_fire_time(o);
-		if (fire_time != 0) {
-			tv.tv_sec = fire_time;
-			format_add_tv(ft, "hook_fire_time", &tv);
-		}
 	}
-	if (array_key != NULL) {
-		format_add(ft, "option_array_key", "%s", array_key);
-		format_add(ft, "option_has_array_key", "1");
+
+	value = options_tostring(o, idx, 0);
+	if (args_has(self->args, 'v'))
+		cmdq_print(item, "%s", value);
+	else if (options_isstring(o)) {
+		escaped = args_escape(value);
+		if (parent)
+			cmdq_print(item, "%s* %s", name, escaped);
+		else
+			cmdq_print(item, "%s %s", name, escaped);
+		free(escaped);
 	} else {
-		format_add(ft, "option_array_key", "%s", "");
-		format_add(ft, "option_has_array_key", "0");
+		if (parent)
+			cmdq_print(item, "%s* %s", name, value);
+		else
+			cmdq_print(item, "%s %s", name, value);
 	}
-	line = format_expand(ft, template);
-	format_free(ft);
-
-	cmdq_print(item, "%s", line);
-	free(line);
 	free(value);
-}

-static void
-cmd_show_hooks_print_monitor(struct cmd *self, struct cmdq_item *item,
-    struct options_entry *o)
-{
-	struct args		*args = cmd_get_args(self);
-	struct format_tree	*ft;
-	enum monitor_type	 type;
-	const char		*template = args_get(args, 'F'), *format;
-	char			*value, *target, *line;
-	struct timeval		 tv = { 0 };
-	u_int			 fire_count;
-	time_t			 fire_time;
-	int			 id;
-
-	value = hooks_monitor_to_string(o);
-	if (value == NULL)
-		return;
-	if (!hooks_monitor_get(o, &type, &id, &format)) {
-		free(value);
-		return;
-	}
-	if (template == NULL)
-		template = SHOW_HOOKS_MONITOR_TEMPLATE;
-
-	switch (type) {
-	case MONITOR_SESSION:
-		target = xstrdup("");
-		break;
-	case MONITOR_PANE:
-		xasprintf(&target, "%%%d", id);
-		break;
-	case MONITOR_ALL_PANES:
-		target = xstrdup("%*");
-		break;
-	case MONITOR_WINDOW:
-		xasprintf(&target, "@%d", id);
-		break;
-	case MONITOR_ALL_WINDOWS:
-		target = xstrdup("@*");
-		break;
-	}
-
-	ft = format_create_from_target(item);
-	format_add(ft, "option_name", "%s", options_name(o));
-	format_add(ft, "option_value", "%s", value);
-	format_add(ft, "option_value_only", "%d", 0);
-	format_add(ft, "option_is_parent", "%d", 0);
-	format_add(ft, "option_is_array", "%d", 0);
-	format_add(ft, "option_is_string", "%d", 1);
-	format_add(ft, "option_is_hook", "%d", 1);
-	format_add(ft, "option_is_user", "%d", 1);
-	format_add(ft, "option_has_value", "%d", 1);
-	format_add(ft, "option_array_key", "%s", "");
-	format_add(ft, "option_has_array_key", "0");
-
-	format_add(ft, "hook_monitor_target", "%s", target);
-	format_add(ft, "hook_monitor_format", "%s", format);
-
-	fire_count = hooks_monitor_get_fire_count(o);
-	format_add(ft, "hook_fire_count", "%u", fire_count);
-
-	fire_time = hooks_monitor_get_fire_time(o);
-	if (fire_time != 0) {
-		tv.tv_sec = fire_time;
-		format_add_tv(ft, "hook_fire_time", &tv);
-	}
-
-	line = format_expand(ft, template);
-	format_free(ft);
-
-	cmdq_print(item, "%s", line);
-	free(line);
-	free(target);
-	free(value);
+	free(tmp);
 }

 static enum cmd_retval
 cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
    struct options *oo)
 {
-	struct args				*args = cmd_get_args(self);
 	const struct options_table_entry	*oe;
 	struct options_entry			*o;
+	struct options_array_item		*a;
 	const char				*name;
-	int					 parent, is_user_hook;
+	u_int					 idx;
+	int					 parent;

 	o = options_first(oo);
 	while (o != NULL) {
-		if (options_table_entry(o) == NULL) {
-			name = options_name(o);
-			is_user_hook = 0;
-			if (*name == '@') {
-				if (hooks_is_event(name) ||
-				    options_get_monitor_data(o) != NULL) {
-					is_user_hook = 1;
-				}
-			}
-			if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
-				if (!is_user_hook || args_has(args, 'H')) {
-					cmd_show_options_print(self, item, o,
-					    NULL, 0);
-				}
-			} else if (is_user_hook)
-				cmd_show_options_print(self, item, o, NULL, 0);
-		}
+		if (options_table_entry(o) == NULL)
+			cmd_show_options_print(self, item, o, -1, 0);
 		o = options_next(o);
 	}
 	for (oe = options_table; oe->name != NULL; oe++) {
 		if (~oe->scope & scope)
 			continue;

-		if ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
-		    !args_has(args, 'H') &&
+		if ((self->entry != &cmd_show_hooks_entry &&
+		    !args_has(self->args, 'H') &&
+		    oe != NULL &&
 		    (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
-		    (cmd_get_entry(self) == &cmd_show_hooks_entry &&
-		    (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
+		    (self->entry == &cmd_show_hooks_entry &&
+		    (oe == NULL ||
+		    (~oe->flags & OPTIONS_TABLE_IS_HOOK))))
 			continue;

 		o = options_get_only(oo, oe->name);
 		if (o == NULL) {
-			if (!args_has(args, 'A'))
+			if (!args_has(self->args, 'A'))
 				continue;
 			o = options_get(oo, oe->name);
 			if (o == NULL)
@@ -389,7 +229,24 @@ cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
 		} else
 			parent = 0;

-		cmd_show_options_print(self, item, o, NULL, parent);
+		if (!options_isarray(o))
+			cmd_show_options_print(self, item, o, -1, parent);
+		else if ((a = options_array_first(o)) == NULL) {
+			if (!args_has(self->args, 'v')) {
+				name = options_name(o);
+				if (parent)
+					cmdq_print(item, "%s*", name);
+				else
+					cmdq_print(item, "%s", name);
+			}
+		} else {
+			while (a != NULL) {
+				idx = options_array_item_index(a);
+				cmd_show_options_print(self, item, o, idx,
+				    parent);
+				a = options_array_next(a);
+			}
+		}
 	}
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-show-prompt-history.c
+++ b/cmd-show-prompt-history.c
@@ -1,101 +0,0 @@
-/* $OpenBSD: cmd-show-prompt-history.c,v 1.5 2026/06/25 11:39:11 nicm Exp $ */
-
-/*
- * Copyright (c) 2021 Anindya Mukherjee <anindya49@hotmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "tmux.h"
-
-#include <stdlib.h>
-
-/*
- * Show or clear prompt history.
- */
-
-static enum cmd_retval	cmd_show_prompt_history_exec(struct cmd *,
-			    struct cmdq_item *);
-
-const struct cmd_entry cmd_show_prompt_history_entry = {
-	.name = "show-prompt-history",
-	.alias = "showphist",
-
-	.args = { "T:", 0, 0, NULL },
-	.usage = "[-T prompt-type]",
-
-	.flags = CMD_AFTERHOOK,
-	.exec = cmd_show_prompt_history_exec
-};
-
-const struct cmd_entry cmd_clear_prompt_history_entry = {
-	.name = "clear-prompt-history",
-	.alias = "clearphist",
-
-	.args = { "T:", 0, 0, NULL },
-	.usage = "[-T prompt-type]",
-
-	.flags = CMD_AFTERHOOK,
-	.exec = cmd_show_prompt_history_exec
-};
-
-static enum cmd_retval
-cmd_show_prompt_history_exec(struct cmd *self, struct cmdq_item *item)
-{
-	struct args		*args = cmd_get_args(self);
-	const char		*typestr = args_get(args, 'T');
-	enum prompt_type	 type;
-	u_int			 t, h;
-	const char		*v;
-
-	if (cmd_get_entry(self) == &cmd_clear_prompt_history_entry) {
-		if (typestr == NULL) {
-			for (t = 0; t < PROMPT_NTYPES; t++)
-				prompt_history_clear(t);
-		} else {
-			type = prompt_type(typestr);
-			if (type == PROMPT_TYPE_INVALID) {
-				cmdq_error(item, "invalid type: %s", typestr);
-				return (CMD_RETURN_ERROR);
-			}
-			prompt_history_clear(type);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	if (typestr == NULL) {
-		for (t = 0; t < PROMPT_NTYPES; t++) {
-			typestr = prompt_type_string(t);
-			cmdq_print(item, "History for %s:\n", typestr);
-			for (h = 0; h < prompt_history_size(t); h++) {
-				v = prompt_history_get(t, h);
-				cmdq_print(item, "%d: %s", h + 1, v);
-			}
-			cmdq_print(item, "%s", "");
-		}
-	} else {
-		type = prompt_type(typestr);
-		if (type == PROMPT_TYPE_INVALID) {
-			cmdq_error(item, "invalid type: %s", typestr);
-			return (CMD_RETURN_ERROR);
-		}
-		cmdq_print(item, "History for %s:\n", prompt_type_string(type));
-		for (h = 0; h < prompt_history_size(type); h++) {
-			v = prompt_history_get(type, h);
-			cmdq_print(item, "%d: %s", h + 1, v);
-		}
-		cmdq_print(item, "%s", "");
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-source-file.c
+++ b/cmd-source-file.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-source-file.c,v 1.63 2026/08/18 08:05:05 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2008 Tiago Cunha <me@tiagocunha.org>
@@ -18,7 +18,6 @@

 #include <sys/types.h>

-#include <ctype.h>
 #include <errno.h>
 #include <glob.h>
 #include <stdlib.h>
@@ -30,19 +29,14 @@
 * Sources a configuration file.
 */

-#define CMD_SOURCE_FILE_DEPTH_LIMIT 50
-static u_int cmd_source_file_depth;
-
 static enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_source_file_entry = {
 	.name = "source-file",
 	.alias = "source",

-	.args = { "t:Fnqv", 1, -1, NULL },
-	.usage = "[-Fnqv] " CMD_TARGET_PANE_USAGE " path ...",
-
-	.target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },
+	.args = { "nqv", 1, -1 },
+	.usage = "[-nqv] path ...",

 	.flags = 0,
 	.exec = cmd_source_file_exec
@@ -50,7 +44,6 @@ const struct cmd_entry cmd_source_file_entry = {

 struct cmd_source_file_data {
 	struct cmdq_item	 *item;
-	struct client		 *client;
 	int			  flags;

 	struct cmdq_item	 *after;
@@ -61,78 +54,48 @@ struct cmd_source_file_data {
 	u_int			  nfiles;
 };

-static void
-cmd_source_file_free_data(struct cmd_source_file_data *cdata)
-{
-	u_int	i;
-
-	for (i = 0; i < cdata->nfiles; i++)
-		free(cdata->files[i]);
-	free(cdata->files);
-	if (cdata->client != NULL)
-		server_client_unref(cdata->client);
-	free(cdata);
-}
-
 static enum cmd_retval
-cmd_source_file_complete_cb(struct cmdq_item *item, void *data)
+cmd_source_file_complete_cb(struct cmdq_item *item, __unused void *data)
 {
-	struct cmd_source_file_data	*cdata = data;
-	struct client			*c = cdata->client;
-
-	if (c == NULL) {
-		cmd_source_file_depth--;
-		log_debug("%s: depth now %u", __func__, cmd_source_file_depth);
-	} else {
-		c->source_file_depth--;
-		log_debug("%s: depth now %u", __func__, c->source_file_depth);
-	}
-
 	cfg_print_causes(item);
-	cmd_source_file_free_data(cdata);
 	return (CMD_RETURN_NORMAL);
 }

 static void
-cmd_source_file_complete(struct cmd_source_file_data *cdata)
+cmd_source_file_complete(struct client *c, struct cmd_source_file_data *cdata)
 {
-	struct client		*c = cdata->client;
 	struct cmdq_item	*new_item;

-	if (!cfg_finished) {
-		cmd_source_file_free_data(cdata);
-		return;
+	if (cfg_finished) {
+		if (cdata->retval == CMD_RETURN_ERROR && c->session == NULL)
+			c->retval = 1;
+		new_item = cmdq_get_callback(cmd_source_file_complete_cb, NULL);
+		cmdq_insert_after(cdata->after, new_item);
 	}

-	if (cdata->retval == CMD_RETURN_ERROR &&
-	    c != NULL &&
-	    c->session == NULL)
-		c->retval = 1;
-	new_item = cmdq_get_callback(cmd_source_file_complete_cb, cdata);
-	cmdq_insert_after(cdata->after, new_item);
+	free(cdata->files);
+	free(cdata);
 }

 static void
-cmd_source_file_done(__unused struct client *oc, const char *path,
-    int error, int closed, struct evbuffer *buffer, void *data)
+cmd_source_file_done(struct client *c, const char *path, int error,
+    int closed, struct evbuffer *buffer, void *data)
 {
 	struct cmd_source_file_data	*cdata = data;
 	struct cmdq_item		*item = cdata->item;
-	struct client			*c = cdata->client;
 	void				*bdata = EVBUFFER_DATA(buffer);
 	size_t				 bsize = EVBUFFER_LENGTH(buffer);
 	u_int				 n;
 	struct cmdq_item		*new_item;
-	struct cmd_find_state		*target = cmdq_get_target(item);

 	if (!closed)
 		return;

 	if (error != 0)
-		cmdq_error(item, "%s: %s", strerror(error), path);
+		cmdq_error(item, "%s: %s", path, strerror(error));
 	else if (bsize != 0) {
 		if (load_cfg_from_buffer(bdata, bsize, path, c, cdata->after,
-		    target, cdata->flags, &new_item) < 0)
+		    cdata->flags, &new_item) < 0)
 			cdata->retval = CMD_RETURN_ERROR;
 		else if (new_item != NULL)
 			cdata->after = new_item;
@@ -142,7 +105,7 @@ cmd_source_file_done(__unused struct client *oc, const char *path,
 	if (n < cdata->nfiles)
 		file_read(c, cdata->files[n], cmd_source_file_done, cdata);
 	else {
-		cmd_source_file_complete(cdata);
+		cmd_source_file_complete(c, cdata);
 		cmdq_continue(item);
 	}
 }
@@ -156,75 +119,33 @@ cmd_source_file_add(struct cmd_source_file_data *cdata, const char *path)
 	cdata->files[cdata->nfiles++] = xstrdup(path);
 }

-static char *
-cmd_source_file_quote_for_glob(const char *path)
-{
-	char		*quoted = xmalloc(2 * strlen(path) + 1), *q = quoted;
-	const char	*p = path;
-
-	while (*p != '\0') {
-		if ((u_char)*p < 128 && !isalnum((u_char)*p) && *p != '/')
-			*q++ = '\\';
-		*q++ = *p++;
-	}
-	*q = '\0';
-	return (quoted);
-}
-
 static enum cmd_retval
 cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args			*args = cmd_get_args(self);
+	struct args			*args = self->args;
 	struct cmd_source_file_data	*cdata;
-	struct client			*c = cmdq_get_client(item);
+	struct client			*c = item->client;
 	enum cmd_retval			 retval = CMD_RETURN_NORMAL;
-	char				*pattern, *cwd, *expanded = NULL;
+	char				*pattern, *cwd;
 	const char			*path, *error;
 	glob_t				 g;
-	int				 result, parse_flags;
-	u_int				 i, j;
-
-	if (c == NULL) {
-		if (cmd_source_file_depth >= CMD_SOURCE_FILE_DEPTH_LIMIT) {
-			cmdq_error(item, "too many nested files");
-			return (CMD_RETURN_ERROR);
-		}
-		cmd_source_file_depth++;
-		log_debug("%s: depth now %u", __func__, cmd_source_file_depth);
-	} else {
-		if (c->source_file_depth >= CMD_SOURCE_FILE_DEPTH_LIMIT) {
-			cmdq_error(item, "too many nested files");
-			return (CMD_RETURN_ERROR);
-		}
-		c->source_file_depth++;
-		log_debug("%s: depth now %u", __func__, c->source_file_depth);
-	}
+	int				 i, result;
+	u_int				 j;

 	cdata = xcalloc(1, sizeof *cdata);
 	cdata->item = item;
-	cdata->client = c;
-	if (c != NULL)
-		c->references++;

 	if (args_has(args, 'q'))
 		cdata->flags |= CMD_PARSE_QUIET;
 	if (args_has(args, 'n'))
 		cdata->flags |= CMD_PARSE_PARSEONLY;
-	if (c == NULL || ~c->flags & CLIENT_CONTROL) {
-		parse_flags = cmd_get_parse_flags(self);
-		if (args_has(args, 'v') || (parse_flags & CMD_PARSE_VERBOSE))
-			cdata->flags |= CMD_PARSE_VERBOSE;
-	}
+	if (args_has(args, 'v'))
+		cdata->flags |= CMD_PARSE_VERBOSE;

-	cwd = cmd_source_file_quote_for_glob(server_client_get_cwd(c, NULL));
+	utf8_stravis(&cwd, server_client_get_cwd(c, NULL), VIS_GLOB);

-	for (i = 0; i < args_count(args); i++) {
-		path = args_string(args, i);
-		if (args_has(args, 'F')) {
-			free(expanded);
-			expanded = format_single_from_target(item, path);
-			path = expanded;
-		}
+	for (i = 0; i < args->argc; i++) {
+		path = args->argv[i];
 		if (strcmp(path, "-") == 0) {
 			cmd_source_file_add(cdata, "-");
 			continue;
@@ -245,10 +166,9 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 					error = strerror(ENOMEM);
 				else
 					error = strerror(EINVAL);
-				cmdq_error(item, "%s: %s", error, path);
+				cmdq_error(item, "%s: %s", path, error);
 				retval = CMD_RETURN_ERROR;
 			}
-			globfree(&g);
 			free(pattern);
 			continue;
 		}
@@ -256,9 +176,7 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)

 		for (j = 0; j < g.gl_pathc; j++)
 			cmd_source_file_add(cdata, g.gl_pathv[j]);
-		globfree(&g);
 	}
-	free(expanded);

 	cdata->after = item;
 	cdata->retval = retval;
@@ -267,7 +185,7 @@ cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 		file_read(c, cdata->files[0], cmd_source_file_done, cdata);
 		retval = CMD_RETURN_WAIT;
 	} else
-		cmd_source_file_complete(cdata);
+		cmd_source_file_complete(c, cdata);

 	free(cwd);
 	return (retval);
--- a/cmd-split-window.c
+++ b/cmd-split-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-split-window.c,v 1.150 2026/08/20 09:19:24 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -27,44 +27,21 @@
 #include "tmux.h"

 /*
- * Create a new pane.
+ * Split a window (add a new pane).
 */

 #define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"

-static enum cmd_retval	cmd_split_window_exec(struct cmd *, struct cmdq_item *);
-static void		cmd_split_window_mouse_resize(struct client *,
-			    struct mouse_event *);
-
-const struct cmd_entry cmd_new_pane_entry = {
-	.name = "new-pane",
-	.alias = "newp",
-
-	.args = { "AbB:Cc:de:EfF:hIkl:KLMm:Op:PR:s:S:t:T:vWx:X:y:Y:Z", 0, -1, NULL },
-	.usage = "[-AbCdefhIkKLMOPvWZ] [-B border-lines] "
-		 "[-c start-directory] [-e environment] "
-		 "[-F format] [-l size] [-m message] [-p percentage] "
-		 "[-s style] [-S active-border-style] "
-		 "[-R inactive-border-style] [-T title] [-x width] [-y height] "
-		 "[-X x-position] [-Y y-position] " CMD_TARGET_PANE_USAGE " "
-		 "[shell-command [argument ...]]",
-
-	.target = { 't', CMD_FIND_PANE, 0 },
-
-	.flags = 0,
-	.exec = cmd_split_window_exec
-};
+static enum cmd_retval	cmd_split_window_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_split_window_entry = {
 	.name = "split-window",
 	.alias = "splitw",

-	.args = { "bB:c:de:EfF:hIkl:m:p:PR:s:S:t:T:vWZ", 0, -1, NULL },
-	.usage = "[-bdefhIklPvWZ] [-B border-lines] [-c start-directory] "
-		 "[-e environment] [-F format] [-l size] [-m message] "
-		 "[-p percentage] [-s style] [-S active-border-style] "
-		 "[-R inactive-border-style] [-T title] "
-	         CMD_TARGET_PANE_USAGE " [shell-command [argument ...]]",
+	.args = { "bc:de:fF:hIl:p:Pt:v", 0, -1 },
+	.usage = "[-bdefhIPv] [-c start-directory] [-e environment] "
+		 "[-F format] [-l size] " CMD_TARGET_PANE_USAGE " [command]",

 	.target = { 't', CMD_FIND_PANE, 0 },

@@ -75,116 +52,81 @@ const struct cmd_entry cmd_split_window_entry = {
 static enum cmd_retval
 cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct spawn_context	 sc = { 0 };
-	struct client		*tc = cmdq_get_target_client(item);
-	struct session		*s = target->s;
-	struct winlink		*wl = target->wl;
-	struct window		*w = wl->window;
-	struct window_pane	*wp = target->wp, *new_wp = NULL;
-	struct layout_cell	*lc = NULL;
-	struct event_payload	*ep;
+	struct args		*args = self->args;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct spawn_context	 sc;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*wp = item->target.wp, *new_wp;
+	enum layout_type	 type;
+	struct layout_cell	*lc;
 	struct cmd_find_state	 fs;
-	struct key_event	*event = cmdq_get_event(item);
-	int			 input, empty, is_floating, flags = 0;
-	int			 restore_zoom = 0;
-	const char		*template, *style, *value;
-	char			*cause = NULL, *cp, *title;
-	const struct options_table_entry *oe;
-	struct args_value	*av;
-	enum pane_lines		 lines;
-	u_int			 count = args_count(args);
+	int			 size, percentage, flags, input;
+	const char		*template, *add, *errstr, *p;
+	char			*cause, *cp, *copy;
+	size_t			 plen;
+	struct args_value	*value;

-	if (window_active_pane_is_over_zoom(w))
-		restore_zoom = 1;
-
-	if (cmd_get_entry(self) == &cmd_new_pane_entry)
-		is_floating = !args_has(args, 'L');
-	else {
-		if (!window_pane_is_visible(wp))
-			restore_zoom = 0;
-		if (!restore_zoom)
-			window_unzoom(w, 1);
-		is_floating = window_pane_is_floating(wp);
-		flags |= SPAWN_SPLIT;
-	}
-
-	if (args_has(args, 'O')) {
-		if (!is_floating) {
-			cmdq_error(item, "modal pane must be floating");
-			return (CMD_RETURN_ERROR);
-		}
-		if (w->modal != NULL) {
-			cmdq_error(item, "window already has a modal pane");
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	if (args_has(args, 'M') && is_floating) {
-		if (event == NULL || !event->m.valid || tc == NULL)
-			return (CMD_RETURN_NORMAL);
-	}
-
-	if (is_floating)
-		flags |= SPAWN_FLOATING;
 	if (args_has(args, 'h'))
-		flags |= SPAWN_HORIZONTAL;
+		type = LAYOUT_LEFTRIGHT;
+	else
+		type = LAYOUT_TOPBOTTOM;
+	if ((p = args_get(args, 'l')) != NULL) {
+		plen = strlen(p);
+		if (p[plen - 1] == '%') {
+			copy = xstrdup(p);
+			copy[plen - 1] = '\0';
+			percentage = strtonum(copy, 0, INT_MAX, &errstr);
+			free(copy);
+			if (errstr != NULL) {
+				cmdq_error(item, "percentage %s", errstr);
+				return (CMD_RETURN_ERROR);
+			}
+			if (type == LAYOUT_TOPBOTTOM)
+				size = (wp->sy * percentage) / 100;
+			else
+				size = (wp->sx * percentage) / 100;
+		} else {
+			size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
+			if (cause != NULL) {
+				cmdq_error(item, "lines %s", cause);
+				free(cause);
+				return (CMD_RETURN_ERROR);
+			}
+		}
+	} else if (args_has(args, 'p')) {
+		percentage = args_strtonum(args, 'p', 0, INT_MAX, &cause);
+		if (cause != NULL) {
+			cmdq_error(item, "create pane failed: -p %s", cause);
+			free(cause);
+			return (CMD_RETURN_ERROR);
+		}
+		if (type == LAYOUT_TOPBOTTOM)
+			size = (wp->sy * percentage) / 100;
+		else
+			size = (wp->sx * percentage) / 100;
+	} else
+		size = -1;
+
+	server_unzoom_window(wp->window);
+	input = (args_has(args, 'I') && args->argc == 0);
+
+	flags = 0;
 	if (args_has(args, 'b'))
 		flags |= SPAWN_BEFORE;
 	if (args_has(args, 'f'))
 		flags |= SPAWN_FULLSIZE;
-	if (args_has(args, 'd'))
-		flags |= SPAWN_DETACHED;
-	if (args_has(args, 'Z'))
-		flags |= SPAWN_ZOOM;
-	if (args_has(args, 'O'))
-		flags |= SPAWN_MODAL|SPAWN_FLOATOVERZOOM;
-	if (is_floating && args_has(args, 'A'))
-		flags |= SPAWN_FLOATOVERZOOM;
-	if ((w->flags & WINDOW_ZOOMED) && (flags & SPAWN_FLOATOVERZOOM))
-		restore_zoom = 1;
-
-	input = args_has(args, 'I');
-	if (input || (count == 1 && *args_string(args, 0) == '\0'))
-		empty = 1;
-	else
-		empty = args_has(args, 'E');
-	if (empty &&
-	    count != 0 &&
-	    (count != 1 || *args_string(args, 0) != '\0')) {
-		cmdq_error(item, "command cannot be given for empty pane");
-		return (CMD_RETURN_ERROR);
-	}
-	if (empty)
+	if (input || (args->argc == 1 && *args->argv[0] == '\0'))
 		flags |= SPAWN_EMPTY;

-	if ((value = args_get(args, 'B')) == NULL)
-		lines = window_get_pane_lines(w);
-	else {
-		oe = options_search("pane-border-lines");
-		lines = options_find_choice(oe, value, &cause);
-		if (cause != NULL) {
-			cmdq_error(item, "pane-border-lines %s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
-	if (flags & SPAWN_FLOATING) {
-		lc = layout_get_floating_cell(item, args, lines, w, wp, flags,
-		    &cause);
-	} else
-		lc = layout_get_tiled_cell(item, args, w, wp, flags, &cause);
-	if (cause != NULL) {
-		cmdq_error(item, "%s", cause);
-		free(cause);
-		if (restore_zoom)
-			window_pop_zoom(w);
+	lc = layout_split_pane(wp, type, size, flags);
+	if (lc == NULL) {
+		cmdq_error(item, "no space for new pane");
 		return (CMD_RETURN_ERROR);
 	}

+	memset(&sc, 0, sizeof sc);
 	sc.item = item;
 	sc.s = s;
 	sc.wl = wl;
@@ -192,119 +134,45 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	sc.wp0 = wp;
 	sc.lc = lc;

-	args_to_vector(args, &sc.argc, &sc.argv);
+	sc.name = NULL;
+	sc.argc = args->argc;
+	sc.argv = args->argv;
 	sc.environ = environ_create();

-	av = args_first_value(args, 'e');
-	while (av != NULL) {
-		environ_put(sc.environ, av->string, 0);
-		av = args_next_value(av);
+	add = args_first_value(args, 'e', &value);
+	while (add != NULL) {
+		environ_put(sc.environ, add);
+		add = args_next_value(&value);
 	}

 	sc.idx = -1;
 	sc.cwd = args_get(args, 'c');
+
 	sc.flags = flags;
+	if (args_has(args, 'd'))
+		sc.flags |= SPAWN_DETACHED;

 	if ((new_wp = spawn_pane(&sc, &cause)) == NULL) {
 		cmdq_error(item, "create pane failed: %s", cause);
 		free(cause);
-		/*
-		 * spawn_pane has already torn the half-built pane down (its
-		 * fork-failure path removes the pane and destroys the layout
-		 * cell), so new_wp is NULL and there is nothing for fail to do.
-		 */
-		goto fail;
+		return (CMD_RETURN_ERROR);
 	}
-	if (args_has(args, 'K') && args_has(args, 'O'))
-		new_wp->flags |= PANE_CAPTUREALLKEYS;
-	if (args_has(args, 'C') && args_has(args, 'O'))
-		new_wp->flags |= PANE_CLOSEONCLICK;
-
-	style = args_get(args, 's');
-	if (style != NULL) {
-		if (options_set_string(new_wp->options, "window-style", 0,
-		    "%s", style) == NULL) {
-			cmdq_error(item, "bad style: %s", style);
-			goto fail;
-		}
-		options_set_string(new_wp->options, "window-active-style", 0,
-		    "%s", style);
-		new_wp->flags |= (PANE_REDRAW|PANE_STYLECHANGED|
-		    PANE_THEMECHANGED);
+	if (input && window_pane_start_input(new_wp, item, &cause) != 0) {
+		layout_close_pane(new_wp);
+		window_remove_pane(wp->window, new_wp);
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
 	}
-	style = args_get(args, 'S');
-	if (style != NULL) {
-		if (options_set_string(new_wp->options,
-		    "pane-active-border-style", 0, "%s", style) == NULL) {
-			cmdq_error(item, "bad active border style: %s", style);
-			goto fail;
-		}
-	}
-	style = args_get(args, 'R');
-	if (style != NULL) {
-		if (options_set_string(new_wp->options, "pane-border-style", 0,
-		    "%s", style) == NULL) {
-			cmdq_error(item, "bad inactive border style: %s",
-			    style);
-			goto fail;
-		}
-	}
-	if (args_has(args, 'B'))
-		options_set_number(new_wp->options, "pane-border-lines", lines);
-	if (args_has(args, 'k') || args_has(args, 'm')) {
-		options_set_number(new_wp->options, "remain-on-exit", 3);
-		if (args_has(args, 'm')) {
-			options_set_string(new_wp->options,
-			    "remain-on-exit-format", 0, "%s",
-			    args_get(args, 'm'));
-		}
-	}
-	if (args_has(args, 'T')) {
-		title = format_single_from_target(item, args_get(args, 'T'));
-		screen_set_title(&new_wp->base, title, 0);
-		ep = event_payload_create();
-		cmd_find_from_pane(&fs, new_wp, 0);
-		event_payload_set_target(ep, &fs);
-		event_payload_set_pane(ep, "pane", new_wp);
-		event_payload_set_window(ep, "window", new_wp->window);
-		event_payload_set_string(ep, "new_title", "%s", title);
-		events_fire("pane-title-changed", ep);
-		free(title);
-	}
-
-	if (input) {
-		switch (window_pane_start_input(new_wp, item, &cause)) {
-		case -1:
-			cmdq_error(item, "%s", cause);
-			free(cause);
-			goto fail;
-		case 1:
-			input = 0;
-			break;
-		}
-	}
-	if (~flags & SPAWN_DETACHED)
+	if (!args_has(args, 'd'))
 		cmd_find_from_winlink_pane(current, wl, new_wp, 0);
-
-	if (restore_zoom) {
-		window_pop_zoom(wp->window);
-		server_redraw_window(wp->window);
-	} else if ((~flags & SPAWN_FLOATING) && !args_has(args, 'O')) {
-		window_pop_zoom(wp->window);
-		server_redraw_window(wp->window);
-	}
-	server_redraw_session(s);
-
-	if (args_has(args, 'M') && is_floating) {
-		tc->tty.mouse_last_pane = new_wp->id;
-		tc->tty.mouse_drag_update = cmd_split_window_mouse_resize;
-		cmd_split_window_mouse_resize(tc, &event->m);
-	}
+	server_redraw_window(wp->window);
+	server_status_session(s);

 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = SPLIT_WINDOW_TEMPLATE;
-		cp = format_single(item, template, tc, s, wl, new_wp);
+		cp = format_single(item, template, c, s, wl, new_wp);
 		cmdq_print(item, "%s", cp);
 		free(cp);
 	}
@@ -312,119 +180,8 @@ cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
 	cmdq_insert_hook(s, item, &fs, "after-split-window");

-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
 	environ_free(sc.environ);
 	if (input)
 		return (CMD_RETURN_WAIT);
-
-	if (args_has(args, 'W')) {
-		/*
-		 * With -W, block this command queue item until the pane's
-		 * command exits; window_pane_wait_finish will be called to
-		 * continue it.
-		 */
-		new_wp->wait_item = item;
-		return (CMD_RETURN_WAIT);
-	}
 	return (CMD_RETURN_NORMAL);
-
-fail:
-	/*
-	 * If the pane was spawned before we failed, tear it down here; this
-	 * also destroys its layout cell. spawn_pane's own failure path has
-	 * already done this, so new_wp is NULL in that case.
-	 */
-	if (new_wp != NULL) {
-		server_client_remove_pane(new_wp);
-		if (!is_floating)
-			layout_close_pane(new_wp);
-		window_remove_pane(wp->window, new_wp);
-	}
-	if (restore_zoom || (~flags & SPAWN_FLOATING))
-		window_pop_zoom(wp->window);
-	if (sc.argv != NULL)
-		cmd_free_argv(sc.argc, sc.argv);
-	environ_free(sc.environ);
-
-	return (CMD_RETURN_ERROR);
-
-}
-
-static void
-cmd_split_window_mouse_resize(struct client *c, struct mouse_event *m)
-{
-	struct window_pane	*wp;
-	struct window		*w;
-	struct layout_cell	*lc;
-	enum pane_lines		 lines;
-	u_int			 sx, sy;
-	int			 x, y, xoff, yoff, border;
-	int			 old_xoff, old_yoff, old_sx, old_sy;
-
-	if (c->tty.mouse_last_pane == -1)
-		return;
-	wp = window_pane_find_by_id(c->tty.mouse_last_pane);
-	if (wp == NULL || !window_pane_is_floating(wp)) {
-		c->tty.mouse_drag_update = NULL;
-		return;
-	}
-	w = wp->window;
-	lc = wp->layout_cell;
-
-	x = m->x + m->ox;
-	y = m->y + m->oy;
-	if (m->statusat == 0 && y >= (int)m->statuslines)
-		y -= m->statuslines;
-	else if (m->statusat > 0 && y >= m->statusat)
-		y = m->statusat - 1;
-
-	lines = window_pane_get_pane_lines(wp);
-	border = (lines != PANE_LINES_NONE);
-
-	if (x >= (int)c->tty.mouse_drag_x) {
-		xoff = c->tty.mouse_drag_x + border;
-		sx = x - c->tty.mouse_drag_x + 1;
-	} else {
-		sx = c->tty.mouse_drag_x - x + 1;
-		xoff = c->tty.mouse_drag_x - sx + 1;
-		if (border)
-			xoff++;
-	}
-	if (y >= (int)c->tty.mouse_drag_y) {
-		yoff = c->tty.mouse_drag_y + border;
-		sy = y - c->tty.mouse_drag_y + 1;
-	} else {
-		sy = c->tty.mouse_drag_y - y + 1;
-		yoff = c->tty.mouse_drag_y - sy + 1;
-		if (border)
-			yoff++;
-	}
-
-	if (border) {
-		if (sx <= 2)
-			sx = PANE_MINIMUM;
-		else
-			sx -= 2;
-		if (sy <= 2)
-			sy = PANE_MINIMUM;
-		else
-			sy -= 2;
-	}
-	if (sx < PANE_MINIMUM)
-		sx = PANE_MINIMUM;
-	if (sy < PANE_MINIMUM)
-		sy = PANE_MINIMUM;
-
-	old_xoff = wp->xoff;
-	old_yoff = wp->yoff;
-	old_sx = wp->sx;
-	old_sy = wp->sy;
-
-	layout_set_size(lc, sx, sy, xoff, yoff);
-	layout_fix_panes(w, NULL);
-
-	window_pane_redraw_floating(w, wp, old_xoff, old_yoff, old_sx,
-	    old_sy);
-	server_redraw_window_borders(w);
 }
--- a/cmd-swap-pane.c
+++ b/cmd-swap-pane.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-swap-pane.c,v 1.55 2026/07/15 13:02:33 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -32,7 +32,7 @@ const struct cmd_entry cmd_swap_pane_entry = {
 	.name = "swap-pane",
 	.alias = "swapp",

-	.args = { "dDs:t:UZ", 0, 0, NULL },
+	.args = { "dDs:t:UZ", 0, 0 },
 	.usage = "[-dDUZ] " CMD_SRCDST_PANE_USAGE,

 	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
@@ -42,84 +42,41 @@ const struct cmd_entry cmd_swap_pane_entry = {
 	.exec = cmd_swap_pane_exec
 };

-static struct window_pane *
-cmd_swap_pane_next_tiled_pane(struct window_pane *wp)
-{
-	while (wp != NULL && !layout_cell_is_tiled(wp->layout_cell))
-		wp = TAILQ_NEXT(wp, entry);
-	return (wp);
-}
-
-static struct window_pane *
-cmd_swap_pane_prev_tiled_pane(struct window_pane *wp)
-{
-	while (wp != NULL && !layout_cell_is_tiled(wp->layout_cell))
-		wp = TAILQ_PREV(wp, window_panes, entry);
-	return (wp);
-}
-
 static enum cmd_retval
 cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
+	struct args		*args = self->args;
 	struct window		*src_w, *dst_w;
 	struct window_pane	*tmp_wp, *src_wp, *dst_wp;
 	struct layout_cell	*src_lc, *dst_lc;
 	u_int			 sx, sy, xoff, yoff;
-	int			 src_idx, dst_idx;

-	dst_w = target->wl->window;
-	dst_wp = target->wp;
-	dst_idx = target->wl->idx;
-	src_w = source->wl->window;
-	src_wp = source->wp;
-	src_idx = source->wl->idx;
+	dst_w = item->target.wl->window;
+	dst_wp = item->target.wp;
+	src_w = item->source.wl->window;
+	src_wp = item->source.wp;

-	if (src_wp == src_w->modal || dst_wp == dst_w->modal) {
-		cmdq_error(item, "pane is modal");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (window_push_zoom(dst_w, 0, args_has(args, 'Z')))
+	if (window_push_zoom(dst_w, args_has(args, 'Z')))
 		server_redraw_window(dst_w);

 	if (args_has(args, 'D')) {
-		if (window_pane_is_floating(dst_wp)) {
-			cmdq_error(item, "cannot swap down on floating pane");
-			return (CMD_RETURN_ERROR);
-		}
 		src_w = dst_w;
 		src_wp = TAILQ_NEXT(dst_wp, entry);
-		src_wp = cmd_swap_pane_next_tiled_pane(src_wp);
-		if (src_wp == NULL) {
+		if (src_wp == NULL)
 			src_wp = TAILQ_FIRST(&dst_w->panes);
-			src_wp = cmd_swap_pane_next_tiled_pane(src_wp);
-		}
 	} else if (args_has(args, 'U')) {
-		if (window_pane_is_floating(dst_wp)) {
-			cmdq_error(item, "cannot swap up on floating pane");
-			return (CMD_RETURN_ERROR);
-		}
 		src_w = dst_w;
 		src_wp = TAILQ_PREV(dst_wp, window_panes, entry);
-		src_wp = cmd_swap_pane_prev_tiled_pane(src_wp);
-		if (src_wp == NULL) {
+		if (src_wp == NULL)
 			src_wp = TAILQ_LAST(&dst_w->panes, window_panes);
-			src_wp = cmd_swap_pane_prev_tiled_pane(src_wp);
-		}
 	}

-	if (src_w != dst_w && window_push_zoom(src_w, 0, args_has(args, 'Z')))
+	if (src_w != dst_w && window_push_zoom(src_w, args_has(args, 'Z')))
 		server_redraw_window(src_w);

 	if (src_wp == dst_wp)
 		goto out;

-	server_client_remove_pane(src_wp);
-	server_client_remove_pane(dst_wp);
-
 	tmp_wp = TAILQ_PREV(dst_wp, window_panes, entry);
 	TAILQ_REMOVE(&dst_w->panes, dst_wp, entry);
 	TAILQ_REPLACE(&src_w->panes, src_wp, dst_wp, entry);
@@ -130,16 +87,6 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 	else
 		TAILQ_INSERT_AFTER(&dst_w->panes, tmp_wp, src_wp, entry);

-	tmp_wp = TAILQ_PREV(dst_wp, window_panes, zentry);
-	TAILQ_REMOVE(&dst_w->z_index, dst_wp, zentry);
-	TAILQ_REPLACE(&src_w->z_index, src_wp, dst_wp, zentry);
-	if (tmp_wp == src_wp)
-		tmp_wp = dst_wp;
-	if (tmp_wp == NULL)
-		TAILQ_INSERT_HEAD(&dst_w->z_index, src_wp, zentry);
-	else
-		TAILQ_INSERT_AFTER(&dst_w->z_index, tmp_wp, src_wp, zentry);
-
 	src_lc = src_wp->layout_cell;
 	dst_lc = dst_wp->layout_cell;
 	src_lc->wp = dst_wp;
@@ -149,10 +96,10 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)

 	src_wp->window = dst_w;
 	options_set_parent(src_wp->options, dst_w->options);
-	src_wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
+	src_wp->flags |= PANE_STYLECHANGED;
 	dst_wp->window = src_w;
 	options_set_parent(dst_wp->options, src_w->options);
-	dst_wp->flags |= (PANE_STYLECHANGED|PANE_THEMECHANGED);
+	dst_wp->flags |= PANE_STYLECHANGED;

 	sx = src_wp->sx; sy = src_wp->sy;
 	xoff = src_wp->xoff; yoff = src_wp->yoff;
@@ -176,26 +123,14 @@ cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 			window_set_active_pane(dst_w, src_wp, 1);
 	}
 	if (src_w != dst_w) {
-		window_pane_stack_remove(&src_w->last_panes, src_wp);
-		window_pane_stack_remove(&dst_w->last_panes, dst_wp);
-		colour_palette_from_option(&src_wp->palette, src_wp->options);
-		colour_palette_from_option(&dst_wp->palette, dst_wp->options);
-		layout_fix_panes(src_w, NULL);
-		redraw_invalidate_scene(src_w);
-		server_redraw_window(src_w);
+		if (src_w->last == src_wp)
+			src_w->last = NULL;
+		if (dst_w->last == dst_wp)
+			dst_w->last = NULL;
 	}
-	layout_fix_panes(dst_w, NULL);
-	redraw_invalidate_scene(dst_w);
+	server_redraw_window(src_w);
 	server_redraw_window(dst_w);

-	if (src_w != dst_w) {
-		window_fire_pane_moved(src_wp, src_w, src_idx, dst_w, dst_idx);
-		window_fire_pane_moved(dst_wp, dst_w, dst_idx, src_w, src_idx);
-	}
-	events_fire_window("window-layout-changed", src_w);
-	if (src_w != dst_w)
-		events_fire_window("window-layout-changed", dst_w);
-
 out:
 	if (window_pop_zoom(src_w))
 		server_redraw_window(src_w);
--- a/cmd-swap-window.c
+++ b/cmd-swap-window.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-swap-window.c,v 1.30 2026/07/27 08:03:01 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -32,33 +32,33 @@ const struct cmd_entry cmd_swap_window_entry = {
 	.name = "swap-window",
 	.alias = "swapw",

-	.args = { "ds:t:", 0, 0, NULL },
+	.args = { "ds:t:", 0, 0 },
 	.usage = "[-d] " CMD_SRCDST_WINDOW_USAGE,

 	.source = { 's', CMD_FIND_WINDOW, CMD_FIND_DEFAULT_MARKED },
 	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = CMD_AFTERHOOK,
+	.flags = 0,
 	.exec = cmd_swap_window_exec
 };

 static enum cmd_retval
 cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*source = cmdq_get_source(item);
-	struct cmd_find_state	*target = cmdq_get_target(item);
-	struct session		*src = source->s, *dst = target->s;
+	struct session		*src, *dst;
 	struct session_group	*sg_src, *sg_dst;
-	struct winlink		*wl_src = source->wl, *wl_dst = target->wl;
+	struct winlink		*wl_src, *wl_dst;
 	struct window		*w_src, *w_dst;

+	wl_src = item->source.wl;
+	src = item->source.s;
 	sg_src = session_group_contains(src);
+
+	wl_dst = item->target.wl;
+	dst = item->target.s;
 	sg_dst = session_group_contains(dst);

-	if (src != dst &&
-	    sg_src != NULL &&
-	    sg_dst != NULL &&
+	if (src != dst && sg_src != NULL && sg_dst != NULL &&
 	    sg_src == sg_dst) {
 		cmdq_error(item, "can't move window, sessions are grouped");
 		return (CMD_RETURN_ERROR);
@@ -77,9 +77,7 @@ cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 	wl_src->window = w_dst;
 	TAILQ_INSERT_TAIL(&w_dst->winlinks, wl_src, wentry);

-	if (marked_pane.wl == wl_src)
-		marked_pane.wl = wl_dst;
-	if (args_has(args, 'd')) {
+	if (args_has(self->args, 'd')) {
 		session_select(dst, wl_dst->idx);
 		if (src != dst)
 			session_select(src, wl_src->idx);
--- a/cmd-switch-client.c
+++ b/cmd-switch-client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-switch-client.c,v 1.75 2026/08/20 09:19:24 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -20,7 +20,6 @@

 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>

 #include "tmux.h"

@@ -35,63 +34,50 @@ const struct cmd_entry cmd_switch_client_entry = {
 	.name = "switch-client",
 	.alias = "switchc",

-	.args = { "c:EFlnO:pt:rT:Z", 0, 0, NULL },
+	.args = { "lc:Enpt:rT:Z", 0, 0 },
 	.usage = "[-ElnprZ] [-c target-client] [-t target-session] "
-		 "[-T key-table] [-O order]",
+		 "[-T key-table]",

 	/* -t is special */

-	.flags = CMD_READONLY|CMD_CLIENT_CFLAG,
+	.flags = CMD_READONLY,
 	.exec = cmd_switch_client_exec
 };

 static enum cmd_retval
 cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	struct cmd_find_state	*current = cmdq_get_current(item);
-	struct cmd_find_state	 target;
+	struct args		*args = self->args;
 	const char		*tflag = args_get(args, 't');
 	enum cmd_find_type	 type;
-	int			 flags, visible, Zflag = args_has(args, 'Z');
-	struct client		*c = cmdq_get_client(item);
-	struct client		*tc = cmdq_get_target_client(item);
+	int			 flags;
+	struct client		*c;
 	struct session		*s;
 	struct winlink		*wl;
 	struct window		*w;
 	struct window_pane	*wp;
 	const char		*tablename;
 	struct key_table	*table;
-	struct sort_criteria	 sort_crit;
-	uid_t			 uid;

-	if (tflag != NULL &&
-	    (tflag[strcspn(tflag, ":.%")] != '\0' || strcmp(tflag, "=") == 0)) {
+	if ((c = cmd_find_client(item, args_get(args, 'c'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	if (tflag != NULL && tflag[strcspn(tflag, ":.%")] != '\0') {
 		type = CMD_FIND_PANE;
 		flags = 0;
 	} else {
 		type = CMD_FIND_SESSION;
 		flags = CMD_FIND_PREFER_UNATTACHED;
 	}
-	if (cmd_find_target(&target, item, tflag, type, flags) != 0)
+	if (cmd_find_target(&item->target, item, tflag, type, flags) != 0)
 		return (CMD_RETURN_ERROR);
-	s = target.s;
-	wl = target.wl;
-	wp = target.wp;
+	s = item->target.s;
+	wl = item->target.wl;
+	w = wl->window;
+	wp = item->target.wp;

-	if (args_has(args, 'r')) {
-		if (tc->flags & CLIENT_READONLY) {
-			uid = proc_get_peer_uid(c->peer);
-			if (uid != getuid()) {
-				cmdq_error(item, "client is read-only");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		if (tc->flags & CLIENT_READONLY)
-			tc->flags &= ~(CLIENT_READONLY|CLIENT_IGNORESIZE);
-		else
-			tc->flags |= (CLIENT_READONLY|CLIENT_IGNORESIZE);
-	}
+	if (args_has(args, 'r'))
+		c->flags ^= CLIENT_READONLY;

 	tablename = args_get(args, 'T');
 	if (tablename != NULL) {
@@ -101,33 +87,24 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_ERROR);
 		}
 		table->references++;
-		key_bindings_unref_table(tc->keytable);
-		tc->keytable = table;
+		key_bindings_unref_table(c->keytable);
+		c->keytable = table;
 		return (CMD_RETURN_NORMAL);
 	}

-	sort_crit.order = sort_order_from_string(args_get(args, 'O'));
-	if (sort_crit.order == SORT_END && args_has(args, 'O')) {
-		cmdq_error(item, "invalid sort order");
-		return (CMD_RETURN_ERROR);
-	}
-	sort_crit.reversed = args_has(args, 'r');
-
 	if (args_has(args, 'n')) {
-		s = session_next_session(tc->session, &sort_crit);
-		if (s == NULL) {
+		if ((s = session_next_session(c->session)) == NULL) {
 			cmdq_error(item, "can't find next session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'p')) {
-		s = session_previous_session(tc->session, &sort_crit);
-		if (s == NULL) {
+		if ((s = session_previous_session(c->session)) == NULL) {
 			cmdq_error(item, "can't find previous session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'l')) {
-		if (tc->last_session != NULL && session_alive(tc->last_session))
-			s = tc->last_session;
+		if (c->last_session != NULL && session_alive(c->last_session))
+			s = c->last_session;
 		else
 			s = NULL;
 		if (s == NULL) {
@@ -135,33 +112,42 @@ cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
-		if (cmdq_get_client(item) == NULL)
+		if (item->client == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (wl != NULL && wp != NULL && wp != wl->window->active) {
-			w = wl->window;
-			if (w->modal != NULL && wp != w->modal)
-				visible = 1;
-			else
-				visible = window_pane_is_visible(wp);
-			if (!visible && window_push_zoom(w, 0, Zflag))
+		if (wl != NULL && wp != NULL) {
+			if (window_push_zoom(w, args_has(self->args, 'Z')))
 				server_redraw_window(w);
 			window_redraw_active_switch(w, wp);
 			window_set_active_pane(w, wp, 1);
-			if (!visible && window_pop_zoom(w))
+			if (window_pop_zoom(w))
 				server_redraw_window(w);
 		}
 		if (wl != NULL) {
 			session_set_current(s, wl);
-			cmd_find_from_session(current, s, 0);
+			cmd_find_from_session(&item->shared->current, s, 0);
 		}
 	}

 	if (!args_has(args, 'E'))
-		environ_update(s->options, tc->environ, s->environ);
+		environ_update(s->options, c->environ, s->environ);

-	server_client_set_session(tc, s);
-	if (~cmdq_get_flags(item) & CMDQ_STATE_REPEAT)
-		server_client_set_key_table(tc, NULL);
+	if (c->session != NULL && c->session != s)
+		c->last_session = c->session;
+	c->session = s;
+	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		server_client_set_key_table(c, NULL);
+	tty_update_client_offset(c);
+	status_timer_start(c);
+	notify_client("client-session-changed", c);
+	session_update_activity(s, NULL);
+	gettimeofday(&s->last_attached_time, NULL);
+
+	server_check_unattached();
+	server_redraw_client(c);
+	s->curw->flags &= ~WINLINK_ALERTFLAGS;
+	s->curw->window->latest = c;
+	recalculate_sizes();
+	alerts_check_session(s);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-unbind-key.c
+++ b/cmd-unbind-key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-unbind-key.c,v 1.34 2021/08/21 10:22:39 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -32,8 +32,8 @@ const struct cmd_entry cmd_unbind_key_entry = {
 	.name = "unbind-key",
 	.alias = "unbind",

-	.args = { "anqT:", 0, 1, NULL },
-	.usage = "[-anq] [-T key-table] key",
+	.args = { "anT:", 0, 1 },
+	.usage = "[-an] [-T key-table] key",

 	.flags = CMD_AFTERHOOK,
 	.exec = cmd_unbind_key_exec
@@ -42,57 +42,47 @@ const struct cmd_entry cmd_unbind_key_entry = {
 static enum cmd_retval
 cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = cmd_get_args(self);
+	struct args	*args = self->args;
 	key_code	 key;
-	const char	*tablename, *keystr = args_string(args, 0);
-	int		 quiet = args_has(args, 'q');
+	const char	*tablename;

-	if (args_has(args, 'a')) {
-		if (keystr != NULL) {
-			if (!quiet)
-				cmdq_error(item, "key given with -a");
+	if (!args_has(args, 'a')) {
+		if (args->argc != 1) {
+			cmdq_error(item, "missing key");
 			return (CMD_RETURN_ERROR);
 		}
+		key = key_string_lookup_string(args->argv[0]);
+		if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
+			cmdq_error(item, "unknown key: %s", args->argv[0]);
+			return (CMD_RETURN_ERROR);
+		}
+	} else {
+		if (args->argc != 0) {
+			cmdq_error(item, "key given with -a");
+			return (CMD_RETURN_ERROR);
+		}
+		key = KEYC_UNKNOWN;
+	}

+	if (key == KEYC_UNKNOWN) {
 		tablename = args_get(args, 'T');
 		if (tablename == NULL) {
-			if (args_has(args, 'n'))
-				tablename = "root";
-			else
-				tablename = "prefix";
+			key_bindings_remove_table("root");
+			key_bindings_remove_table("prefix");
+			return (CMD_RETURN_NORMAL);
 		}
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			if (!quiet) {
-				cmdq_error(item, "table %s doesn't exist" ,
-				    tablename);
-			}
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
-
 		key_bindings_remove_table(tablename);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (keystr == NULL) {
-		if (!quiet)
-			cmdq_error(item, "missing key");
-		return (CMD_RETURN_ERROR);
-	}
-
-	key = key_string_lookup_string(keystr);
-	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-		if (!quiet)
-			cmdq_error(item, "unknown key: %s", keystr);
-		return (CMD_RETURN_ERROR);
-	}
-
 	if (args_has(args, 'T')) {
 		tablename = args_get(args, 'T');
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			if (!quiet) {
-				cmdq_error(item, "table %s doesn't exist" ,
-				    tablename);
-			}
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'n'))
--- a/cmd-wait-for.c
+++ b/cmd-wait-for.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd-wait-for.c,v 1.23 2026/07/10 13:38:45 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -34,8 +34,8 @@ const struct cmd_entry cmd_wait_for_entry = {
 	.name = "wait-for",
 	.alias = "wait",

-	.args = { "EF:LSUlvw:", 1, 1, NULL },
-	.usage = "[-ELSUlv] [-F format] [-w waiter] name",
+	.args = { "LSU", 1, 1 },
+	.usage = "[-L|-S|-U] channel",

 	.flags = 0,
 	.exec = cmd_wait_for_exec
@@ -46,17 +46,6 @@ struct wait_item {
 	TAILQ_ENTRY(wait_item)	 entry;
 };

-struct wait_event_item {
-	struct cmdq_item		*item;
-	struct events_sink		*sink;
-	char				*name;
-	char				*filter;
-	int				 verbose;
-	TAILQ_ENTRY(wait_event_item)	 entry;
-};
-static TAILQ_HEAD(, wait_event_item) wait_event_items =
-    TAILQ_HEAD_INITIALIZER(wait_event_items);
-
 struct wait_channel {
 	const char	       *name;
 	int			locked;
@@ -87,28 +76,9 @@ static enum cmd_retval	cmd_wait_for_lock(struct cmdq_item *, const char *,
 			    struct wait_channel *);
 static enum cmd_retval	cmd_wait_for_unlock(struct cmdq_item *, const char *,
 			    struct wait_channel *);
-static enum cmd_retval	cmd_wait_for_event(struct cmdq_item *, const char *,
-			    struct args *);
-static void		cmd_wait_for_event_cb(const char *,
-			    struct event_payload *, void *);
-static void		cmd_wait_for_event_free(struct wait_event_item *);
-static enum cmd_retval	cmd_wait_for_event_list(struct cmdq_item *,
-			    const char *);
-static enum cmd_retval	cmd_wait_for_event_wake(struct cmdq_item *,
-			    const char *, struct args *);
-static enum cmd_retval	cmd_wait_for_list(struct cmdq_item *,
-			    struct wait_channel *);
-static enum cmd_retval	cmd_wait_for_wake(struct cmdq_item *, const char *,
-			    struct args *, struct wait_channel *);

 static struct wait_channel	*cmd_wait_for_add(const char *);
 static void			 cmd_wait_for_remove(struct wait_channel *);
-static void			 cmd_wait_for_remove_empty(
-				    struct wait_channel *);
-static const char		*cmd_wait_for_item_client_name(
-				    struct cmdq_item *);
-static const char		*cmd_wait_for_client_name(
-				    struct wait_event_item *);

 static struct wait_channel *
 cmd_wait_for_add(const char *name)
@@ -147,53 +117,16 @@ cmd_wait_for_remove(struct wait_channel *wc)
 	free(wc);
 }

-static void
-cmd_wait_for_remove_empty(struct wait_channel *wc)
-{
-	if (wc->locked || wc->woken)
-		return;
-	if (!TAILQ_EMPTY(&wc->waiters) || !TAILQ_EMPTY(&wc->lockers))
-		return;
-
-	log_debug("remove empty wait channel %s", wc->name);
-
-	RB_REMOVE(wait_channels, &wait_channels, wc);
-
-	free((void *)wc->name);
-	free(wc);
-}
-
-static const char *
-cmd_wait_for_item_client_name(struct cmdq_item *item)
-{
-	struct client	*c = cmdq_get_client(item);
-
-	if (c == NULL || c->name == NULL)
-		return ("");
-	return (c->name);
-}
-
-static const char *
-cmd_wait_for_client_name(struct wait_event_item *wei)
-{
-	return (cmd_wait_for_item_client_name(wei->item));
-}
-
 static enum cmd_retval
 cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args		*args = cmd_get_args(self);
-	const char		*name = args_string(args, 0);
-	struct wait_channel	*wc, find = { .name = name };
+	struct args     	*args = self->args;
+	const char		*name = args->argv[0];
+	struct wait_channel	*wc, wc0;

-	if (args_has(args, 'E'))
-		return (cmd_wait_for_event(item, name, args));
+	wc0.name = name;
+	wc = RB_FIND(wait_channels, &wait_channels, &wc0);

-	wc = RB_FIND(wait_channels, &wait_channels, &find);
-	if (args_has(args, 'l'))
-		return (cmd_wait_for_list(item, wc));
-	if (args_has(args, 'w'))
-		return (cmd_wait_for_wake(item, name, args, wc));
 	if (args_has(args, 'S'))
 		return (cmd_wait_for_signal(item, name, wc));
 	if (args_has(args, 'L'))
@@ -203,179 +136,6 @@ cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 	return (cmd_wait_for_wait(item, name, wc));
 }

-static void
-cmd_wait_for_event_print(struct wait_event_item *wei, struct event_payload *ep)
-{
-	struct event_payload_item	*epi;
-	const char			*key;
-	char				*value;
-
-	epi = event_payload_first(ep);
-	while (epi != NULL) {
-		key = event_payload_item_name(epi);
-		if (*key != '_') {
-			value = event_payload_item_print(epi);
-			cmdq_print(wei->item, "%s=%s", key, value);
-			free(value);
-		}
-		epi = event_payload_next(epi);
-	}
-}
-
-static void
-cmd_wait_for_event_cb(__unused const char *name, struct event_payload *ep,
-    void *item_data)
-{
-	struct wait_event_item	*wei = item_data;
-	struct format_tree	*ft;
-	char			*expanded;
-	int			 flag;
-
-	if (wei->verbose)
-		cmd_wait_for_event_print(wei, ep);
-
-	if (wei->filter != NULL) {
-		ft = format_create(cmdq_get_client(wei->item), wei->item,
-		    FORMAT_NONE, FORMAT_NOJOBS);
-		event_payload_add_formats(ep, ft, NULL);
-		expanded = format_expand(ft, wei->filter);
-		flag = format_true(expanded);
-		free(expanded);
-		format_free(ft);
-
-		if (!flag)
-			return;
-	}
-
-	TAILQ_REMOVE(&wait_event_items, wei, entry);
-	cmdq_continue(wei->item);
-	cmd_wait_for_event_free(wei);
-}
-
-static void
-cmd_wait_for_event_free(struct wait_event_item *wei)
-{
-	events_remove_sink(wei->sink);
-	free(wei->name);
-	free(wei->filter);
-	free(wei);
-}
-
-static enum cmd_retval
-cmd_wait_for_event(struct cmdq_item *item, const char *name, struct args *args)
-{
-	struct wait_event_item	*wei;
-	const char		*filter = args_get(args, 'F');
-
-	if (!hooks_valid_event_name(name)) {
-		cmdq_error(item, "invalid event: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (args_has(args, 'l'))
-		return (cmd_wait_for_event_list(item, name));
-	if (args_has(args, 'w'))
-		return (cmd_wait_for_event_wake(item, name, args));
-
-	if (cmdq_get_client(item) == NULL) {
-		cmdq_error(item, "not able to wait");
-		return (CMD_RETURN_ERROR);
-	}
-
-	wei = xcalloc(1, sizeof *wei);
-	wei->item = item;
-	wei->name = xstrdup(name);
-	wei->filter = (filter != NULL ? xstrdup(filter) : NULL);
-	wei->verbose = args_has(args, 'v');
-	wei->sink = events_add_sink(name, cmd_wait_for_event_cb, wei);
-	TAILQ_INSERT_TAIL(&wait_event_items, wei, entry);
-
-	return (CMD_RETURN_WAIT);
-}
-
-static enum cmd_retval
-cmd_wait_for_event_list(struct cmdq_item *item, const char *name)
-{
-	struct wait_event_item	*wei;
-
-	TAILQ_FOREACH(wei, &wait_event_items, entry) {
-		if (strcmp(wei->name, name) == 0)
-			cmdq_print(item, "%s", cmd_wait_for_client_name(wei));
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_wait_for_event_wake(struct cmdq_item *item, const char *name,
-    struct args *args)
-{
-	struct wait_event_item	*wei, *wei1;
-	const char		*client_name = args_get(args, 'w');
-
-	TAILQ_FOREACH_SAFE(wei, &wait_event_items, entry, wei1) {
-		if (strcmp(wei->name, name) != 0)
-			continue;
-		if (strcmp(cmd_wait_for_client_name(wei), client_name) != 0)
-			continue;
-
-		TAILQ_REMOVE(&wait_event_items, wei, entry);
-		cmdq_continue(wei->item);
-		cmd_wait_for_event_free(wei);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	cmdq_error(item, "waiter %s not found", client_name);
-	return (CMD_RETURN_ERROR);
-}
-
-static enum cmd_retval
-cmd_wait_for_list(struct cmdq_item *item, struct wait_channel *wc)
-{
-	struct wait_item	*wi;
-
-	if (wc == NULL)
-		return (CMD_RETURN_NORMAL);
-
-	TAILQ_FOREACH(wi, &wc->waiters, entry)
-		cmdq_print(item, "%s", cmd_wait_for_item_client_name(wi->item));
-	TAILQ_FOREACH(wi, &wc->lockers, entry)
-		cmdq_print(item, "%s", cmd_wait_for_item_client_name(wi->item));
-
-	return (CMD_RETURN_NORMAL);
-}
-
-static enum cmd_retval
-cmd_wait_for_wake(__unused struct cmdq_item *item, const char *name,
-    struct args *args, struct wait_channel *wc)
-{
-	struct wait_item	*wi, *wi1;
-	const char		*client_name = args_get(args, 'w');
-
-	if (wc != NULL) {
-		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
-			name = cmd_wait_for_item_client_name(wi->item);
-			if (strcmp(name, client_name) != 0)
-				continue;
-			cmdq_continue(wi->item);
-			TAILQ_REMOVE(&wc->waiters, wi, entry);
-			free(wi);
-			cmd_wait_for_remove_empty(wc);
-			return (CMD_RETURN_NORMAL);
-		}
-		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
-			name = cmd_wait_for_item_client_name(wi->item);
-			if (strcmp(name, client_name) != 0)
-				continue;
-			cmdq_continue(wi->item);
-			TAILQ_REMOVE(&wc->lockers, wi, entry);
-			free(wi);
-			cmd_wait_for_remove_empty(wc);
-			return (CMD_RETURN_NORMAL);
-		}
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
 static enum cmd_retval
 cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
@@ -407,7 +167,7 @@ static enum cmd_retval
 cmd_wait_for_wait(struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
 {
-	struct client		*c = cmdq_get_client(item);
+	struct client		*c = item->client;
 	struct wait_item	*wi;

 	if (c == NULL) {
@@ -438,7 +198,7 @@ cmd_wait_for_lock(struct cmdq_item *item, const char *name,
 {
 	struct wait_item	*wi;

-	if (cmdq_get_client(item) == NULL) {
+	if (item->client == NULL) {
 		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}
@@ -485,13 +245,6 @@ cmd_wait_for_flush(void)
 {
 	struct wait_channel	*wc, *wc1;
 	struct wait_item	*wi, *wi1;
-	struct wait_event_item	*wei, *wei1;
-
-	TAILQ_FOREACH_SAFE(wei, &wait_event_items, entry, wei1) {
-		TAILQ_REMOVE(&wait_event_items, wei, entry);
-		cmdq_continue(wei->item);
-		cmd_wait_for_event_free(wei);
-	}

 	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
 		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
--- a/cmd.c
+++ b/cmd.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: cmd.c,v 1.189 2026/07/17 08:29:34 nicm Exp $ */
+/* $OpenBSD$ */

 /*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
@@ -35,18 +35,16 @@ extern const struct cmd_entry cmd_choose_buffer_entry;
 extern const struct cmd_entry cmd_choose_client_entry;
 extern const struct cmd_entry cmd_choose_tree_entry;
 extern const struct cmd_entry cmd_clear_history_entry;
-extern const struct cmd_entry cmd_clear_prompt_history_entry;
 extern const struct cmd_entry cmd_clock_mode_entry;
 extern const struct cmd_entry cmd_command_prompt_entry;
 extern const struct cmd_entry cmd_confirm_before_entry;
 extern const struct cmd_entry cmd_copy_mode_entry;
-extern const struct cmd_entry cmd_customize_mode_entry;
 extern const struct cmd_entry cmd_delete_buffer_entry;
 extern const struct cmd_entry cmd_detach_client_entry;
 extern const struct cmd_entry cmd_display_menu_entry;
 extern const struct cmd_entry cmd_display_message_entry;
-extern const struct cmd_entry cmd_display_popup_entry;
 extern const struct cmd_entry cmd_display_panes_entry;
+extern const struct cmd_entry cmd_down_pane_entry;
 extern const struct cmd_entry cmd_find_window_entry;
 extern const struct cmd_entry cmd_has_session_entry;
 extern const struct cmd_entry cmd_if_shell_entry;
@@ -71,7 +69,6 @@ extern const struct cmd_entry cmd_lock_server_entry;
 extern const struct cmd_entry cmd_lock_session_entry;
 extern const struct cmd_entry cmd_move_pane_entry;
 extern const struct cmd_entry cmd_move_window_entry;
-extern const struct cmd_entry cmd_new_pane_entry;
 extern const struct cmd_entry cmd_new_session_entry;
 extern const struct cmd_entry cmd_new_window_entry;
 extern const struct cmd_entry cmd_next_layout_entry;
@@ -95,7 +92,6 @@ extern const struct cmd_entry cmd_select_pane_entry;
 extern const struct cmd_entry cmd_select_window_entry;
 extern const struct cmd_entry cmd_send_keys_entry;
 extern const struct cmd_entry cmd_send_prefix_entry;
-extern const struct cmd_entry cmd_server_access_entry;
 extern const struct cmd_entry cmd_set_buffer_entry;
 extern const struct cmd_entry cmd_set_environment_entry;
 extern const struct cmd_entry cmd_set_hook_entry;
@@ -106,7 +102,6 @@ extern const struct cmd_entry cmd_show_environment_entry;
 extern const struct cmd_entry cmd_show_hooks_entry;
 extern const struct cmd_entry cmd_show_messages_entry;
 extern const struct cmd_entry cmd_show_options_entry;
-extern const struct cmd_entry cmd_show_prompt_history_entry;
 extern const struct cmd_entry cmd_show_window_options_entry;
 extern const struct cmd_entry cmd_source_file_entry;
 extern const struct cmd_entry cmd_split_window_entry;
@@ -115,9 +110,9 @@ extern const struct cmd_entry cmd_suspend_client_entry;
 extern const struct cmd_entry cmd_swap_pane_entry;
 extern const struct cmd_entry cmd_swap_window_entry;
 extern const struct cmd_entry cmd_switch_client_entry;
-extern const struct cmd_entry cmd_switch_mode_entry;
 extern const struct cmd_entry cmd_unbind_key_entry;
 extern const struct cmd_entry cmd_unlink_window_entry;
+extern const struct cmd_entry cmd_up_pane_entry;
 extern const struct cmd_entry cmd_wait_for_entry;

 const struct cmd_entry *cmd_table[] = {
@@ -129,17 +124,14 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_choose_client_entry,
 	&cmd_choose_tree_entry,
 	&cmd_clear_history_entry,
-	&cmd_clear_prompt_history_entry,
 	&cmd_clock_mode_entry,
 	&cmd_command_prompt_entry,
 	&cmd_confirm_before_entry,
 	&cmd_copy_mode_entry,
-	&cmd_customize_mode_entry,
 	&cmd_delete_buffer_entry,
 	&cmd_detach_client_entry,
 	&cmd_display_menu_entry,
 	&cmd_display_message_entry,
-	&cmd_display_popup_entry,
 	&cmd_display_panes_entry,
 	&cmd_find_window_entry,
 	&cmd_has_session_entry,
@@ -165,7 +157,6 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_lock_session_entry,
 	&cmd_move_pane_entry,
 	&cmd_move_window_entry,
-	&cmd_new_pane_entry,
 	&cmd_new_session_entry,
 	&cmd_new_window_entry,
 	&cmd_next_layout_entry,
@@ -189,7 +180,6 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_select_window_entry,
 	&cmd_send_keys_entry,
 	&cmd_send_prefix_entry,
-	&cmd_server_access_entry,
 	&cmd_set_buffer_entry,
 	&cmd_set_environment_entry,
 	&cmd_set_hook_entry,
@@ -200,7 +190,6 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_show_hooks_entry,
 	&cmd_show_messages_entry,
 	&cmd_show_options_entry,
-	&cmd_show_prompt_history_entry,
 	&cmd_show_window_options_entry,
 	&cmd_source_file_entry,
 	&cmd_split_window_entry,
@@ -209,31 +198,14 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_swap_pane_entry,
 	&cmd_swap_window_entry,
 	&cmd_switch_client_entry,
-	&cmd_switch_mode_entry,
 	&cmd_unbind_key_entry,
 	&cmd_unlink_window_entry,
 	&cmd_wait_for_entry,
 	NULL
 };

-/* Instance of a command. */
-struct cmd {
-	const struct cmd_entry	 *entry;
-	struct args		 *args;
-	u_int			  group;
-
-	char			 *file;
-	u_int			  line;
-	int			  parse_flags;
-
-	TAILQ_ENTRY(cmd)	  qentry;
-};
-TAILQ_HEAD(cmds, cmd);
-
-/* Next group number for new command list. */
 static u_int cmd_list_next_group = 1;

-/* Log an argument vector. */
 void printflike(3, 4)
 cmd_log_argv(int argc, char **argv, const char *fmt, ...)
 {
@@ -250,9 +222,8 @@ cmd_log_argv(int argc, char **argv, const char *fmt, ...)
 	free(prefix);
 }

-/* Prepend to an argument vector. */
 void
-cmd_prepend_argv(int *argc, char ***argv, const char *arg)
+cmd_prepend_argv(int *argc, char ***argv, char *arg)
 {
 	char	**new_argv;
 	int	  i;
@@ -267,15 +238,13 @@ cmd_prepend_argv(int *argc, char ***argv, const char *arg)
 	(*argc)++;
 }

-/* Append to an argument vector. */
 void
-cmd_append_argv(int *argc, char ***argv, const char *arg)
+cmd_append_argv(int *argc, char ***argv, char *arg)
 {
 	*argv = xreallocarray(*argv, (*argc) + 1, sizeof **argv);
 	(*argv)[(*argc)++] = xstrdup(arg);
 }

-/* Pack an argument vector up into a buffer. */
 int
 cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 {
@@ -298,7 +267,6 @@ cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
 	return (0);
 }

-/* Unpack an argument vector from a packed buffer. */
 int
 cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 {
@@ -307,8 +275,6 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)

 	if (argc == 0)
 		return (0);
-	if (argc < 0 || argc > 1000)
-		return (-1);
 	*argv = xcalloc(argc, sizeof **argv);

 	buf[len - 1] = '\0';
@@ -329,7 +295,6 @@ cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
 	return (0);
 }

-/* Copy an argument vector, ensuring it is terminated by NULL. */
 char **
 cmd_copy_argv(int argc, char **argv)
 {
@@ -346,7 +311,6 @@ cmd_copy_argv(int argc, char **argv)
 	return (new_argv);
 }

-/* Free an argument vector. */
 void
 cmd_free_argv(int argc, char **argv)
 {
@@ -359,74 +323,32 @@ cmd_free_argv(int argc, char **argv)
 	free(argv);
 }

-/* Convert argument vector to a string. */
 char *
 cmd_stringify_argv(int argc, char **argv)
 {
-	char	*buf = NULL, *s;
-	size_t	 len = 0;
+	char	*buf;
 	int	 i;
+	size_t	 len;

 	if (argc == 0)
 		return (xstrdup(""));

-	for (i = 0; i < argc; i++) {
-		s = args_escape(argv[i]);
-		log_debug("%s: %u %s = %s", __func__, i, argv[i], s);
+	len = 0;
+	buf = NULL;

-		len += strlen(s) + 1;
+	for (i = 0; i < argc; i++) {
+		len += strlen(argv[i]) + 1;
 		buf = xrealloc(buf, len);

 		if (i == 0)
 			*buf = '\0';
 		else
 			strlcat(buf, " ", len);
-		strlcat(buf, s, len);
-
-		free(s);
+		strlcat(buf, argv[i], len);
 	}
 	return (buf);
 }

-/* Get entry for command. */
-const struct cmd_entry *
-cmd_get_entry(struct cmd *cmd)
-{
-	return (cmd->entry);
-}
-
-/* Get arguments for command. */
-struct args *
-cmd_get_args(struct cmd *cmd)
-{
-	return (cmd->args);
-}
-
-/* Get group for command. */
-u_int
-cmd_get_group(struct cmd *cmd)
-{
-	return (cmd->group);
-}
-
-/* Get file and line for command. */
-void
-cmd_get_source(struct cmd *cmd, const char **file, u_int *line)
-{
-	if (file != NULL)
-		*file = cmd->file;
-	if (line != NULL)
-		*line = cmd->line;
-}
-
-/* Get parse flags for command. */
-int
-cmd_get_parse_flags(struct cmd *cmd)
-{
-	return (cmd->parse_flags);
-}
-
-/* Look for an alias for a command. */
 char *
 cmd_get_alias(const char *name)
 {
@@ -457,8 +379,7 @@ cmd_get_alias(const char *name)
 	return (NULL);
 }

-/* Look up a command entry by name. */
-const struct cmd_entry *
+static const struct cmd_entry *
 cmd_find(const char *name, char **cause)
 {
 	const struct cmd_entry	**loop, *entry, *found = NULL;
@@ -507,75 +428,66 @@ ambiguous:
 	return (NULL);
 }

-/* Parse a single command from an argument vector. */
 struct cmd *
-cmd_parse(struct args_value *values, u_int count, const char *file, u_int line,
-    int parse_flags, char **cause)
+cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 {
 	const struct cmd_entry	*entry;
+	const char		*name;
 	struct cmd		*cmd;
 	struct args		*args;
-	char			*error = NULL;

-	if (count == 0 || values[0].type != ARGS_STRING) {
+	if (argc == 0) {
 		xasprintf(cause, "no command");
 		return (NULL);
 	}
-	entry = cmd_find(values[0].string, cause);
+	name = argv[0];
+
+	entry = cmd_find(name, cause);
 	if (entry == NULL)
 		return (NULL);
+	cmd_log_argv(argc, argv, "%s: %s", __func__, entry->name);

-	args = args_parse(&entry->args, values, count, &error);
-	if (args == NULL && error == NULL) {
-		xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
-		return (NULL);
-	}
-	if (args == NULL) {
-		xasprintf(cause, "command %s: %s", entry->name, error);
-		free(error);
-		return (NULL);
-	}
+	args = args_parse(entry->args.template, argc, argv);
+	if (args == NULL)
+		goto usage;
+	if (entry->args.lower != -1 && args->argc < entry->args.lower)
+		goto usage;
+	if (entry->args.upper != -1 && args->argc > entry->args.upper)
+		goto usage;

 	cmd = xcalloc(1, sizeof *cmd);
 	cmd->entry = entry;
 	cmd->args = args;
-	cmd->parse_flags = parse_flags;

 	if (file != NULL)
 		cmd->file = xstrdup(file);
 	cmd->line = line;

+	cmd->alias = NULL;
+	cmd->argc = argc;
+	cmd->argv = cmd_copy_argv(argc, argv);
+
 	return (cmd);
+
+usage:
+	if (args != NULL)
+		args_free(args);
+	xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
+	return (NULL);
 }

-/* Free a command. */
 void
 cmd_free(struct cmd *cmd)
 {
+	free(cmd->alias);
+	cmd_free_argv(cmd->argc, cmd->argv);
+
 	free(cmd->file);

 	args_free(cmd->args);
 	free(cmd);
 }

-/* Copy a command. */
-struct cmd *
-cmd_copy(struct cmd *cmd, int argc, char **argv)
-{
-	struct cmd	*new_cmd;
-
-	new_cmd = xcalloc(1, sizeof *new_cmd);
-	new_cmd->entry = cmd->entry;
-	new_cmd->args = args_copy(cmd->args, argc, argv);
-
-	if (cmd->file != NULL)
-		new_cmd->file = xstrdup(cmd->file);
-	new_cmd->line = cmd->line;
-
-	return (new_cmd);
-}
-
-/* Get a command as a string. */
 char *
 cmd_print(struct cmd *cmd)
 {
@@ -591,7 +503,6 @@ cmd_print(struct cmd *cmd)
 	return (out);
 }

-/* Create a new command list. */
 struct cmd_list *
 cmd_list_new(void)
 {
@@ -600,39 +511,29 @@ cmd_list_new(void)
 	cmdlist = xcalloc(1, sizeof *cmdlist);
 	cmdlist->references = 1;
 	cmdlist->group = cmd_list_next_group++;
-	cmdlist->list = xcalloc(1, sizeof *cmdlist->list);
-	TAILQ_INIT(cmdlist->list);
+	TAILQ_INIT(&cmdlist->list);
 	return (cmdlist);
 }

-/* Append a command to a command list. */
 void
 cmd_list_append(struct cmd_list *cmdlist, struct cmd *cmd)
 {
 	cmd->group = cmdlist->group;
-	TAILQ_INSERT_TAIL(cmdlist->list, cmd, qentry);
+	TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
 }

-/* Append all commands from one list to another.  */
-void
-cmd_list_append_all(struct cmd_list *cmdlist, struct cmd_list *from)
-{
-	struct cmd	*cmd;
-
-	TAILQ_FOREACH(cmd, from->list, qentry)
-		cmd->group = cmdlist->group;
-	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
-}
-
-/* Move all commands from one command list to another. */
 void
 cmd_list_move(struct cmd_list *cmdlist, struct cmd_list *from)
 {
-	TAILQ_CONCAT(cmdlist->list, from->list, qentry);
+	struct cmd	*cmd, *cmd1;
+
+	TAILQ_FOREACH_SAFE(cmd, &from->list, qentry, cmd1) {
+		TAILQ_REMOVE(&from->list, cmd, qentry);
+		TAILQ_INSERT_TAIL(&cmdlist->list, cmd, qentry);
+	}
 	cmdlist->group = cmd_list_next_group++;
 }

-/* Free a command list. */
 void
 cmd_list_free(struct cmd_list *cmdlist)
 {
@@ -641,76 +542,36 @@ cmd_list_free(struct cmd_list *cmdlist)
 	if (--cmdlist->references != 0)
 		return;

-	TAILQ_FOREACH_SAFE(cmd, cmdlist->list, qentry, cmd1) {
-		TAILQ_REMOVE(cmdlist->list, cmd, qentry);
+	TAILQ_FOREACH_SAFE(cmd, &cmdlist->list, qentry, cmd1) {
+		TAILQ_REMOVE(&cmdlist->list, cmd, qentry);
 		cmd_free(cmd);
 	}
-	free(cmdlist->list);
+
 	free(cmdlist);
 }

-/* Copy a command list, expanding %s in arguments. */
-struct cmd_list *
-cmd_list_copy(const struct cmd_list *cmdlist, int argc, char **argv)
+char *
+cmd_list_print(struct cmd_list *cmdlist, int escaped)
 {
 	struct cmd	*cmd;
-	struct cmd_list	*new_cmdlist;
-	struct cmd	*new_cmd;
-	u_int		 group = cmdlist->group;
-	char		*s;
-
-	s = cmd_list_print(cmdlist, 0);
-	log_debug("%s: %s", __func__, s);
-	free(s);
-
-	new_cmdlist = cmd_list_new();
-	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
-		if (cmd->group != group) {
-			new_cmdlist->group = cmd_list_next_group++;
-			group = cmd->group;
-		}
-		new_cmd = cmd_copy(cmd, argc, argv);
-		cmd_list_append(new_cmdlist, new_cmd);
-	}
-
-	s = cmd_list_print(new_cmdlist, 0);
-	log_debug("%s: %s", __func__, s);
-	free(s);
-
-	return (new_cmdlist);
-}
-
-/* Get a command list as a string. */
-char *
-cmd_list_print(const struct cmd_list *cmdlist, int flags)
-{
-	struct cmd	*cmd, *next;
 	char		*buf, *this;
 	size_t		 len;
-	const char	*separator;
-	int		 escaped = flags & CMD_LIST_PRINT_ESCAPED;
-	int		 no_groups = flags & CMD_LIST_PRINT_NO_GROUPS;
-	const char	*single_separator = escaped ? " \\; " : " ; ";
-	const char	*double_separator = escaped ? " \\;\\; " : " ;; ";

 	len = 1;
 	buf = xcalloc(1, len);

-	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
 		this = cmd_print(cmd);

-		len += strlen(this) + 6;
+		len += strlen(this) + 4;
 		buf = xrealloc(buf, len);

 		strlcat(buf, this, len);
-
-		next = TAILQ_NEXT(cmd, qentry);
-		if (next != NULL) {
-			if (!no_groups && cmd->group != next->group)
-				separator = double_separator;
+		if (TAILQ_NEXT(cmd, qentry) != NULL) {
+			if (escaped)
+				strlcat(buf, " \\; ", len);
 			else
-				separator = single_separator;
-			strlcat(buf, separator, len);
+				strlcat(buf, " ; ", len);
 		}

 		free(this);
@@ -719,46 +580,6 @@ cmd_list_print(const struct cmd_list *cmdlist, int flags)
 	return (buf);
 }

-/* Get first command in list. */
-struct cmd *
-cmd_list_first(struct cmd_list *cmdlist)
-{
-	return (TAILQ_FIRST(cmdlist->list));
-}
-
-/* Get next command in list. */
-struct cmd *
-cmd_list_next(struct cmd *cmd)
-{
-	return (TAILQ_NEXT(cmd, qentry));
-}
-
-/* Do all of the commands in this command list have this flag? */
-int
-cmd_list_all_have(struct cmd_list *cmdlist, int flag)
-{
-	struct cmd	*cmd;
-
-	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
-		if (~cmd->entry->flags & flag)
-			return (0);
-	}
-	return (1);
-}
-
-/* Do any of the commands in this command list have this flag? */
-int
-cmd_list_any_have(struct cmd_list *cmdlist, int flag)
-{
-	struct cmd	*cmd;
-
-	TAILQ_FOREACH(cmd, cmdlist->list, qentry) {
-		if (cmd->entry->flags & flag)
-			return (1);
-	}
-	return (0);
-}
-
 /* Adjust current mouse position for a pane. */
 int
 cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
@@ -778,9 +599,9 @@ cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
 	if (m->statusat == 0 && y >= m->statuslines)
 		y -= m->statuslines;

-	if ((int)x < wp->xoff || (int)x >= wp->xoff + (int)wp->sx)
+	if (x < wp->xoff || x >= wp->xoff + wp->sx)
 		return (-1);
-	if ((int)y < wp->yoff || (int)y >= wp->yoff + (int)wp->sy)
+	if (y < wp->yoff || y >= wp->yoff + wp->sy)
 		return (-1);

 	if (xp != NULL)
@@ -824,15 +645,9 @@ cmd_mouse_pane(struct mouse_event *m, struct session **sp,

 	if ((wl = cmd_mouse_window(m, sp)) == NULL)
 		return (NULL);
-	if (m->wp == -1)
-		wp = wl->window->active;
-	else {
-		if ((wp = window_pane_find_by_id(m->wp)) == NULL)
-			return (NULL);
-		if (!window_has_pane(wl->window, wp))
-			return (NULL);
-	}
-	if (wl->window->modal != NULL && wp != wl->window->modal)
+	if ((wp = window_pane_find_by_id(m->wp)) == NULL)
+		return (NULL);
+	if (!window_has_pane(wl->window, wp))
 		return (NULL);

 	if (wlp != NULL)
@@ -840,19 +655,14 @@ cmd_mouse_pane(struct mouse_event *m, struct session **sp,
 	return (wp);
 }

-/*
- * Replace the first %% or any %idx in template by s. %% is intended for use in
- * single quotes, so ' is escaped. %%% and %idx% are for double quotes, so a
- * list of special characters is escaped. %idx is left unescaped.
- */
+/* Replace the first %% or %idx in template by s. */
 char *
 cmd_template_replace(const char *template, const char *s, int idx)
 {
-	char			 ch, *buf;
-	const char		*ptr, *cp, dquote[] = "\"\\$;~";
-	int			 replaced;
-	size_t			 len, slen;
-	enum { NQ, SQ, DQ }	 quote;
+	char		 ch, *buf;
+	const char	*ptr, *cp, quote[] = "\"\\$;~";
+	int		 replaced, quoted;
+	size_t		 len;

 	if (strchr(template, '%') == NULL)
 		return (xstrdup(template));
@@ -866,52 +676,30 @@ cmd_template_replace(const char *template, const char *s, int idx)
 	while (*ptr != '\0') {
 		switch (ch = *ptr++) {
 		case '%':
-			if (*ptr >= '1' && *ptr <= '9' && *ptr - '0' == idx) {
-				ptr++;
-				quote = NQ;
-				if (*ptr == '%') {
-					quote = DQ;
-					ptr++;
-				}
-			} else {
+			if (*ptr < '1' || *ptr > '9' || *ptr - '0' != idx) {
 				if (*ptr != '%' || replaced)
 					break;
 				replaced = 1;
-				ptr++;
-				quote = SQ;
-				if (*ptr == '%') {
-					quote = DQ;
-					ptr++;
-				}
 			}
+			ptr++;

-			slen = strlen(s);
-			if (slen >= SIZE_MAX / 4 ||
-			    len > SIZE_MAX - (slen * 4) - 1)
-				fatalx("argument too long");
-			buf = xrealloc(buf, len + (slen * 4) + 1);
+			quoted = (*ptr == '%');
+			if (quoted)
+				ptr++;
+
+			buf = xrealloc(buf, len + (strlen(s) * 3) + 1);
 			for (cp = s; *cp != '\0'; cp++) {
-				if (quote == SQ && *cp == '\'') {
-					buf[len++] = '\'';
-					buf[len++] = '\\';
-					buf[len++] = '\'';
-					buf[len++] = '\'';
-					continue;
-				}
-				if (quote == DQ && strchr(dquote, *cp) != NULL)
+				if (quoted && strchr(quote, *cp) != NULL)
 					buf[len++] = '\\';
 				buf[len++] = *cp;
 			}
 			buf[len] = '\0';
 			continue;
 		}
-		if (len > SIZE_MAX - 2)
-			fatalx("argument too long");
 		buf = xrealloc(buf, len + 2);
 		buf[len++] = ch;
 		buf[len] = '\0';
 	}

-	log_debug("%s: %s -> %s", __func__, template, buf);
 	return (buf);
 }
--- a/colour.c
+++ b/colour.c
--- a/compat.h
+++ b/compat.h
@@ -27,43 +27,10 @@
 #include <termios.h>
 #include <wchar.h>

-#ifdef HAVE_EVENT2_EVENT_H
-#include <event2/event.h>
-#include <event2/event_compat.h>
-#include <event2/event_struct.h>
-#include <event2/buffer.h>
-#include <event2/buffer_compat.h>
-#include <event2/bufferevent.h>
-#include <event2/bufferevent_struct.h>
-#include <event2/bufferevent_compat.h>
-#else
-#include <event.h>
-#ifndef EVBUFFER_EOL_LF
-/*
- * This doesn't really work because evbuffer_readline is broken, but gets us to
- * build with very old (older than 1.4.14) libevent.
- */
-#define EVBUFFER_EOL_LF
-#define evbuffer_readln(a, b, c) evbuffer_readline(a)
-#endif
-#endif
-
-#ifdef HAVE_MALLOC_TRIM
-#include <malloc.h>
-#endif
-
-#ifdef HAVE_UTF8PROC
-#include <utf8proc.h>
-#endif
-
 #ifndef __GNUC__
 #define __attribute__(a)
 #endif

-#ifdef BROKEN___DEAD
-#undef __dead
-#endif
-
 #ifndef __unused
 #define __unused __attribute__ ((__unused__))
 #endif
@@ -73,9 +40,6 @@
 #ifndef __packed
 #define __packed __attribute__ ((__packed__))
 #endif
-#ifndef __weak
-#define __weak __attribute__ ((__weak__))
-#endif

 #ifndef ECHOPRT
 #define ECHOPRT 0
@@ -126,18 +90,10 @@ void	warnx(const char *, ...);
 #define _PATH_DEFPATH	"/usr/bin:/bin"
 #endif

-#ifndef _PATH_VI
-#define _PATH_VI	"/usr/bin/vi"
-#endif
-
 #ifndef __OpenBSD__
 #define pledge(s, p) (0)
 #endif

-#ifndef IMAXBEL
-#define IMAXBEL 0
-#endif
-
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #else
@@ -273,13 +229,6 @@ void	warnx(const char *, ...);
 #define HOST_NAME_MAX 255
 #endif

-#ifndef CLOCK_REALTIME
-#define CLOCK_REALTIME 0
-#endif
-#ifndef CLOCK_MONOTONIC
-#define CLOCK_MONOTONIC CLOCK_REALTIME
-#endif
-
 #ifndef HAVE_FLOCK
 #define LOCK_SH 0
 #define LOCK_EX 0
@@ -297,11 +246,6 @@ void		 explicit_bzero(void *, size_t);
 int		 getdtablecount(void);
 #endif

-#ifndef HAVE_GETDTABLESIZE
-/* getdtablesize.c */
-int		 getdtablesize(void);
-#endif
-
 #ifndef HAVE_CLOSEFROM
 /* closefrom.c */
 void		 closefrom(int);
@@ -347,23 +291,6 @@ char		*strndup(const char *, size_t);
 void		*memmem(const void *, size_t, const void *, size_t);
 #endif

-#ifndef HAVE_HTONLL
-/* htonll.c */
-#undef htonll
-uint64_t	 htonll(uint64_t);
-#endif
-
-#ifndef HAVE_NTOHLL
-/* ntohll.c */
-#undef ntohll
-uint64_t	 ntohll(uint64_t);
-#endif
-
-#ifndef HAVE_GETPEEREID
-/* getpeereid.c */
-int		getpeereid(int, uid_t *, gid_t *);
-#endif
-
 #ifndef HAVE_DAEMON
 /* daemon.c */
 int	 	 daemon(int, int);
@@ -379,16 +306,11 @@ const char	*getprogname(void);
 void		 setproctitle(const char *, ...);
 #endif

-#ifndef HAVE_CLOCK_GETTIME
-/* clock_gettime.c */
-int		 clock_gettime(int, struct timespec *);
-#endif
-
 #ifndef HAVE_B64_NTOP
 /* base64.c */
 #undef b64_ntop
 #undef b64_pton
-int		 b64_ntop(const u_char *, size_t, char *, size_t);
+int		 b64_ntop(const char *, size_t, char *, size_t);
 int		 b64_pton(const char *, u_char *, size_t);
 #endif

@@ -410,9 +332,9 @@ int		 asprintf(char **, const char *, ...);
 int		 vasprintf(char **, const char *, va_list);
 #endif

-#ifndef HAVE_GETLINE
-/* getline.c */
-ssize_t		 getline(char **, size_t *, FILE *);
+#ifndef HAVE_FGETLN
+/* fgetln.c */
+char		*fgetln(FILE *, size_t *);
 #endif

 #ifndef HAVE_SETENV
@@ -441,13 +363,6 @@ void		*reallocarray(void *, size_t, size_t);
 void		*recallocarray(void *, size_t, size_t, size_t);
 #endif

-#ifdef HAVE_SYSTEMD
-/* systemd.c */
-int		 systemd_activated(void);
-int		 systemd_create_socket(int, char **);
-int		 systemd_move_to_new_cgroup(char **);
-#endif
-
 #ifdef HAVE_UTF8PROC
 /* utf8proc.c */
 int		 utf8proc_wcwidth(wchar_t);
@@ -455,20 +370,12 @@ int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
 int		 utf8proc_wctomb(char *, wchar_t);
 #endif

-#ifdef NEED_FUZZING
-/* tmux.c */
-#define main __weak main
-#define regcomp(preg, pattern, cflags) (0)
-#define regexec(preg, string, nmatch, pmatch, eflags) (REG_NOMATCH)
-#define regfree(preg) ((void)0)
-#endif
-
 /* getopt.c */
-extern int	 BSDopterr;
-extern int	 BSDoptind;
-extern int	 BSDoptopt;
-extern int	 BSDoptreset;
-extern char	*BSDoptarg;
+extern int	BSDopterr;
+extern int	BSDoptind;
+extern int	BSDoptopt;
+extern int	BSDoptreset;
+extern char    *BSDoptarg;
 int	BSDgetopt(int, char *const *, const char *);
 #define getopt(ac, av, o)  BSDgetopt(ac, av, o)
 #define opterr             BSDopterr
--- a/compat/base64.c
+++ b/compat/base64.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: base64.c,v 1.15 2021/10/25 14:41:09 jca Exp $	*/
+/*	$OpenBSD: base64.c,v 1.8 2015/01/16 16:48:51 deraadt Exp $	*/

 /*
 * Copyright (c) 1996 by Internet Software Consortium.
@@ -46,15 +46,15 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <arpa/nameser.h>

 #include <ctype.h>
 #include <resolv.h>
+#include <stdio.h>

 #include <stdlib.h>
 #include <string.h>

-#include "compat.h"
-
 static const char Base64[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const char Pad64 = '=';
@@ -107,9 +107,9 @@ static const char Pad64 = '=';
   end of the data is performed using the '=' character.

   Since all base64 input is an integral number of octets, only the
-         -------------------------------------------------
+         -------------------------------------------------                       
   following cases can arise:
-
+   
       (1) the final quantum of encoding input is an integral
           multiple of 24 bits; here, the final unit of encoded
 	   output will be an integral multiple of 4 characters
@@ -123,12 +123,15 @@ static const char Pad64 = '=';
   */

 int
-b64_ntop(unsigned char const *src, size_t srclength, char *target,
-    size_t targsize)
+b64_ntop(src, srclength, target, targsize)
+	u_char const *src;
+	size_t srclength;
+	char *target;
+	size_t targsize;
 {
 	size_t datalength = 0;
-	unsigned char input[3];
-	unsigned char output[4];
+	u_char input[3];
+	u_char output[4];
 	int i;

 	while (2 < srclength) {
@@ -149,14 +152,14 @@ b64_ntop(unsigned char const *src, size_t srclength, char *target,
 		target[datalength++] = Base64[output[2]];
 		target[datalength++] = Base64[output[3]];
 	}
-
+    
 	/* Now we worry about padding. */
 	if (0 != srclength) {
 		/* Get what's left. */
 		input[0] = input[1] = input[2] = '\0';
 		for (i = 0; i < srclength; i++)
 			input[i] = *src++;
-
+	
 		output[0] = input[0] >> 2;
 		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
@@ -184,10 +187,13 @@ b64_ntop(unsigned char const *src, size_t srclength, char *target,
 */

 int
-b64_pton(char const *src, unsigned char *target, size_t targsize)
+b64_pton(src, target, targsize)
+	char const *src;
+	u_char *target;
+	size_t targsize;
 {
 	int tarindex, state, ch;
-	unsigned char nextbyte;
+	u_char nextbyte;
 	char *pos;

 	state = 0;
@@ -201,7 +207,7 @@ b64_pton(char const *src, unsigned char *target, size_t targsize)
 			break;

 		pos = strchr(Base64, ch);
-		if (pos == 0)		/* A non-base64 character. */
+		if (pos == 0) 		/* A non-base64 character. */
 			return (-1);

 		switch (state) {
--- a/compat/clock_gettime.c
+++ b/compat/clock_gettime.c
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2021 Nicholas Marriott <nicholas.marriott@gmail.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
- * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include <sys/types.h>
-#include <sys/time.h>
-
-#include "compat.h"
-
-#ifndef TIMEVAL_TO_TIMESPEC
-#define TIMEVAL_TO_TIMESPEC(tv, ts) do {	\
-	(ts)->tv_sec = (tv)->tv_sec;		\
-	(ts)->tv_nsec = (tv)->tv_usec * 1000;	\
-} while (0)
-#endif
-
-int
-clock_gettime(__unused int clock, struct timespec *ts)
-{
-	struct timeval	tv;
-
-	gettimeofday(&tv, NULL);
-	TIMEVAL_TO_TIMESPEC(&tv, ts);
-	return 0;
-}
--- a/compat/closefrom.c
+++ b/compat/closefrom.c
@@ -44,9 +44,6 @@
 #  include <ndir.h>
 # endif
 #endif
-#if defined(HAVE_LIBPROC_H)
-# include <libproc.h>
-#endif

 #include "compat.h"

@@ -58,15 +55,39 @@
 __unused static const char rcsid[] = "$Sudo: closefrom.c,v 1.11 2006/08/17 15:26:54 millert Exp $";
 #endif /* lint */

-#ifndef HAVE_FCNTL_CLOSEM
 /*
 * Close all file descriptors greater than or equal to lowfd.
 */
-static void
-closefrom_fallback(int lowfd)
+#ifdef HAVE_FCNTL_CLOSEM
+void
+closefrom(int lowfd)
 {
-	long fd, maxfd;
+    (void) fcntl(lowfd, F_CLOSEM, 0);
+}
+#else
+void
+closefrom(int lowfd)
+{
+    long fd, maxfd;
+#if defined(HAVE_DIRFD) && defined(HAVE_PROC_PID)
+    char fdpath[PATH_MAX], *endp;
+    struct dirent *dent;
+    DIR *dirp;
+    int len;

+    /* Check for a /proc/$$/fd directory. */
+    len = snprintf(fdpath, sizeof(fdpath), "/proc/%ld/fd", (long)getpid());
+    if (len > 0 && (size_t)len <= sizeof(fdpath) && (dirp = opendir(fdpath))) {
+	while ((dent = readdir(dirp)) != NULL) {
+	    fd = strtol(dent->d_name, &endp, 10);
+	    if (dent->d_name != endp && *endp == '\0' &&
+		fd >= 0 && fd < INT_MAX && fd >= lowfd && fd != dirfd(dirp))
+		(void) close((int) fd);
+	}
+	(void) closedir(dirp);
+    } else
+#endif
+    {
 	/*
 	 * Fall back on sysconf() or getdtablesize().  We avoid checking
 	 * resource limits since it is possible to open a file descriptor
@@ -78,78 +99,11 @@ closefrom_fallback(int lowfd)
 	maxfd = getdtablesize();
 #endif /* HAVE_SYSCONF */
 	if (maxfd < 0)
-		maxfd = OPEN_MAX;
+	    maxfd = OPEN_MAX;

 	for (fd = lowfd; fd < maxfd; fd++)
-		(void) close((int) fd);
-}
-#endif /* HAVE_FCNTL_CLOSEM */
-
-#ifdef HAVE_FCNTL_CLOSEM
-void
-closefrom(int lowfd)
-{
-    (void) fcntl(lowfd, F_CLOSEM, 0);
-}
-#elif defined(HAVE_LIBPROC_H) && defined(HAVE_PROC_PIDINFO)
-void
-closefrom(int lowfd)
-{
-	int i, r, sz;
-	pid_t pid = getpid();
-	struct proc_fdinfo *fdinfo_buf = NULL;
-
-	sz = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
-	if (sz == 0)
-		return; /* no fds, really? */
-	else if (sz == -1)
-		goto fallback;
-	if ((fdinfo_buf = malloc(sz)) == NULL)
-		goto fallback;
-	r = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fdinfo_buf, sz);
-	if (r < 0 || r > sz)
-		goto fallback;
-	for (i = 0; i < r / (int)PROC_PIDLISTFD_SIZE; i++) {
-		if (fdinfo_buf[i].proc_fd >= lowfd)
-			close(fdinfo_buf[i].proc_fd);
-	}
-	free(fdinfo_buf);
-	return;
- fallback:
-	free(fdinfo_buf);
-	closefrom_fallback(lowfd);
-	return;
-}
-#elif defined(HAVE_DIRFD) && defined(HAVE_PROC_PID)
-void
-closefrom(int lowfd)
-{
-    long fd;
-    char fdpath[PATH_MAX], *endp;
-    struct dirent *dent;
-    DIR *dirp;
-    int len;
-
-    /* Check for a /proc/$$/fd directory. */
-    len = snprintf(fdpath, sizeof(fdpath), "/proc/%ld/fd", (long)getpid());
-    if (len > 0 && (size_t)len < sizeof(fdpath) && (dirp = opendir(fdpath))) {
-	while ((dent = readdir(dirp)) != NULL) {
-	    fd = strtol(dent->d_name, &endp, 10);
-	    if (dent->d_name != endp && *endp == '\0' &&
-		fd >= 0 && fd < INT_MAX && fd >= lowfd && fd != dirfd(dirp))
-		(void) close((int) fd);
-	}
-	(void) closedir(dirp);
-	return;
+	    (void) close((int) fd);
    }
-    /* /proc/$$/fd strategy failed, fall back to brute force closure */
-    closefrom_fallback(lowfd);
-}
-#else
-void
-closefrom(int lowfd)
-{
-	closefrom_fallback(lowfd);
 }
 #endif /* !HAVE_FCNTL_CLOSEM */
 #endif /* HAVE_CLOSEFROM */
--- a/compat/daemon-darwin.c
+++ b/compat/daemon-darwin.c
@@ -49,12 +49,12 @@

 #include <mach/mach.h>

-#include <AvailabilityMacros.h>
+#include <Availability.h>
 #include <unistd.h>

 void daemon_darwin(void);

-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
+#ifdef __MAC_10_10

 extern kern_return_t	bootstrap_look_up_per_user(mach_port_t, const char *,
 			    uid_t, mach_port_t *);
--- a/compat/fgetln.c
+++ b/compat/fgetln.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015 Joerg Jung <jung@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * portable fgetln() version, NOT reentrant
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "compat.h"
+
+char *
+fgetln(FILE *fp, size_t *len)
+{
+	static char *buf = NULL;
+	static size_t bufsz = 0;
+	size_t r = 0;
+	char *p;
+	int c, e;
+
+	if (!fp || !len) {
+		errno = EINVAL;
+		return NULL;
+	}
+	if (!buf) {
+		if (!(buf = calloc(1, BUFSIZ)))
+			return NULL;
+		bufsz = BUFSIZ;
+	}
+	while ((c = getc(fp)) != EOF) {
+		buf[r++] = c;
+		if (r == bufsz) {
+			if (!(p = reallocarray(buf, 2, bufsz))) {
+				e = errno;
+				free(buf);
+				errno = e;
+				buf = NULL, bufsz = 0;
+				return NULL;
+			}
+			buf = p, bufsz = 2 * bufsz;
+		}
+		if (c == '\n')
+			break;
+	}
+	return (*len = r) ? buf : NULL;
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nicholas Marriott	25cae5d86f	3.1c.	2020-10-30 12:11:02 +00:00
nicm	d0ad34e94d	Do not write after the end of the array and overwrite the stack when colon-separated SGR sequences contain empty arguments. Reported by Sergey Nizovtsev.	2020-10-30 12:09:52 +00:00
				`@@ -1 +0,0 @@`
				`Please report security issues to nicholas.marriott@gmail.com.`