2.6.

Initialize alerts timer event where it is used, avoids crash with new windows.
2.6-rc3.
2026-03-12 03:25:45 +00:00 · 2017-10-05 14:31:23 +01:00 · 2017-09-22 17:58:30 +01:00 · 2017-09-11 10:08:28 +01:00 · 2017-09-11 10:08:15 +01:00 · 2017-09-11 10:01:11 +01:00
196 changed files with 18663 additions and 12647 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -17,3 +17,4 @@ Makefile
 Makefile.in
 configure
 tmux.1.*
+*.dSYM
--- a/.mailmap
+++ b/.mailmap
@@ -22,6 +22,7 @@ Pierre-Yves Ritschard	<pyr@openbsd.org> pyr <pyr>
 Ray Lai			<ray@openbsd.org> ray <ray>
 Ryan McBride		<mcbride@openbsd.org> mcbride <mcbride>
 Sebastian Benoit	<benno@openbsd.org> benno <benno>
+Sebastien Marie		<semarie@openbsd.org> semarie <semarie>
 Stefan Sperling		<stsp@openbsd.org> stsp <stsp>
 Stuart Henderson	<sthen@openbsd.org> sthen <sthen>
 Ted Unangst		<tedu@openbsd.org> tedu <tedu>
--- a/324
+++ b/324
@@ -1,4 +1,301 @@
-CHANGES FROM 2.1 to 2.2 10 April 2016
+CHANGES FROM 2.5 TO 2.6, 05 October 2017
+
+* Add select-pane -T to set pane title.
+
+* Fix memory leak when lines with BCE are removed from history.
+
+* Fix (again) the "prefer unattached" behaviour of attach-session.
+
+* Reorder how keys are checked to allow keys to be specified that have a
+  leading escape. GitHub issue 1048.
+
+* Support REP escape sequence (\033[b).
+
+* Run alert hooks based on options rather than always, and allow further bells
+  even if there is an existing bell.
+
+* Add -d flag to display-panes to override display-panes-time.
+
+* Add selection_present format when in copy mode (allows key bindings that do
+  something different if there is a selection).
+
+* Add pane_at_left, pane_at_right, pane_at_top and pane_at_bottom formats.
+
+* Make bell, activity and silence alerting more consistent by: removing the
+  bell-on-alert option; adding activity-action and silence-action options with
+  the same possible values as the existing bell-action; adding a "both" value
+  for the visual-bell, visual-activity and visual-silence options to trigger
+  both a bell and a message.
+
+* Add a pane_pipe format to show if pipe-pane is active.
+
+* Block signals between forking and resetting signal handlers so that the
+  libevent signal handler doesn't get called in the child and incorrectly write
+  into the signal pipe that it still shares with the parent. GitHub issue 1001.
+
+* Allow punctuation in pane_current_command.
+
+* Add -c for respawn-pane and respawn-window.
+
+* Wait for any remaining data to flush when a pane is closed while pipe-pane is
+  in use.
+
+* Fix working out current client with no target. GitHub issue 995.
+
+* Try to fallback to C.UTF-8 as well as en_US.UTF-8 when looking for a UTF-8
+  locale.
+
+* Add user-keys option for user-defined key escape sequences (mapped to User0
+  to User999 keys).
+
+* Add pane-set-clipboard hook.
+
+* FAQ file has moved out of repository to online.
+
+* Fix problem with high CPU usage when a client dies unexpectedly. GitHub issue
+  941.
+
+* Do a dance on OS X 10.10 and above to return tmux to the user namespace,
+  allowing access to the clipboard.
+
+* Do not allow escape sequences which expect a specific terminator (APC, DSC,
+  OSC) to wait for forever - use a small timeout. This reduces the chance of
+  the pane locking up completely when sent garbage (cat /dev/random or
+  similar).
+
+* Support SIGUSR2 to toggle logging on a running server, also generate the
+  "out" log file with -vv not -vvvv.
+
+* Make set-clipboard a three state option: on (tmux both sends to outside
+  terminal and accepts from applications inside); external (tmux sends outside
+  but does not accept inside); and off.
+
+* Fix OSC 4 palette setting for bright foreground colours. GitHub issue 954.
+
+* Use setrgbf and setrgbb terminfo(5) capabilities to set RGB colours, if they
+  are available. (Tc is still supported as well.)
+
+* Fix redrawing panes when they are resized several times but end up with the
+  size unchanged (for example, splitw/resizep -Z/breakp).
+
+* Major rewrite of choose mode. Now includes preview, sorting, searching and
+  tagging; commands that can be executed directly from the mode (for example,
+  to delete one or more buffers); and filtering in tree mode.
+
+* choose-window and choose-session are now aliases of choose-tree (in the
+  command-alias option).
+
+* Support OSC 10 and OSC 11 to set foreground and background colours.
+
+* Check the U8 capability to determine whether to use UTF-8 line drawing
+  characters for ACS.
+
+* Some missing notifications for layout changes.
+
+* Control mode clients now do not affect session sizes until they issue
+  refresh-client -C. new-session -x and -y works with control clients even if
+  the session is not detached.
+
+* All new sessions that are unattached (whether with -d or started with no
+  terminal) are now created with size 80 x 24. Whether the status line is on or
+  off does not affect the size of new sessions until they are attached.
+
+* Expand formats in option names and add -F flag to expand them in option values.
+
+* Remember the search string for a pane even if copy mode is exited and entered
+  again.
+
+* Some further BCE fixes (scroll up, reverse index).
+
+* Improvements to how terminals are cleared (entirely or partially).
+
+CHANGES FROM 2.4 TO 2.5, 09 May 2017
+
+* Reset updated flag when restarting #() command so that new output is properly
+  recognised. GitHub issue 922.
+
+* Fix ECH with a background colour.
+
+* Do not rely on the terminal not moving the cursor after DL or EL.
+
+* Fix send-keys and send-prefix in copy-mode (so C-b C-b works). GitHub issue
+  905.
+
+* Set the current pane for rotate-window so it works in command sequences.
+
+* Add pane_mode format.
+
+* Differentiate M-Up from Escape+Up when possible (that is, in terminals with
+  xterm(1) style function keys). GitHub issue 907.
+
+* Add session_stack and window_stack_index formats.
+
+* Some new control mode notifications and corresponding hooks:
+  pane-mode-changed, window-pane-changed, client-session-changed,
+  session-window-changed.
+
+* Format pane_search_string for last search term while in copy mode (useful
+  with command-prompt -I).
+
+* Fix a problem with high CPU usage and multiple clients with #(). GitHub issue
+  889.
+
+* Fix UTF-8 combining characters in column 0.
+
+* Fix reference counting so that panes are properly destroyed and their
+  processes killed.
+
+* Clamp SU (CSI S) parameter to work around a bug in Konsole.
+
+* Tweak line wrapping in full width panes to play more nicely with terminal
+  copy and paste.
+
+* Fix when we emit SGR 0 in capture-pane -e.
+
+* Do not change TERM until after config file parsing has finished, so that
+  commands run inside the config file can use it to make decisions (typically
+  about default-terminal).
+
+* Make the initial client wait until config file parsing has finished to avoid
+  racing with commands.
+
+* Fix core when if-shell fails.
+
+* Only use ED to clear screen if the pane is at the bottom.
+
+* Fix multibyte UTF-8 output.
+
+* Code improvements around target (-t) resolution.
+
+* Change how the default target (for commands without -t) is managed across
+  command sequences: now it is set up at the start and commands are required
+  to update it if needed. Fixes binding command sequences to mouse keys.
+
+* Make if-shell from the config file work correctly.
+
+* Change to always check the root key table if no binding is found in the
+  current table (prefix table or copy-mode table or whatever). This means that
+  root key bindings will take effect even in copy mode, if not overridden by a
+  copy mode key binding.
+
+* Fix so that the history file works again.
+
+* Run config file without a client rather than using the first client, restores
+  previous behaviour.
+
+* If a #() command doesn't exit, continue to read from it and use its last full
+  line of output.
+
+* Handle slow terminals and fast output better: when the amount of data
+  outstanding gets too large, discard output until it is drained and we are
+  able to do a full redraw. Prevents tmux sitting on a huge buffer that the
+  terminal will take forever to consume.
+
+* Do not redraw a client unless we realistically think it can accept the data -
+  defer redraws until the client has nothing else waiting to write.
+ 
+CHANGES FROM 2.3 TO 2.4, 20 April 2017
+
+Incompatible Changes
+====================
+
+* Key tables have undergone major changes. Mode key tables are no longer
+  separate from the main key tables. All mode key tables have been removed,
+  together with the -t flag to bind-key and unbind-key.
+
+  The emacs-edit, vi-edit, emacs-choose and vi-choose tables have been replaced
+  by fixed key bindings in the command prompt and choose modes. The mode-keys
+  and status-keys options remain.
+
+  The emacs-copy and vi-copy tables have been replaced by the copy-mode and
+  copy-mode-vi tables. Commands are sent using the -X and -N flags to
+  send-keys. So the following:
+
+    bind -temacs-copy C-Up scroll-up
+    bind -temacs-copy -R5 WheelUpPane scroll-up
+
+  Becomes:
+
+    bind -Tcopy-mode C-Up send -X scroll-up
+    bind -Tcopy-mode WheelUpPane send -N5 -X scroll-up
+
+  These changes allows the full command parser (including command sequences) and
+  command set to be used - for example, the normal command prompt with editing
+  and history is now used for searching, jumping, and so on instead of a custom
+  one. The default C-r binding is now:
+
+    bind -Tcopy-mode C-r command-prompt -i -p'search up' "send -X search-backward-incremental '%%'"
+
+  There are also some new commmands available with send -X, such as
+  copy-pipe-and-cancel.
+* set-remain-on-exit has gone -- can be achieved with hooks instead.
+* Hooks: before hooks have been removed and only a selection of commands now
+  have after hooks (they are no longer automatic). Additional hooks have been
+  added.
+* The xterm-keys option now defaults to on.
+
+Normal Changes
+==============
+
+* Support for mouse double and triple clicks.
+* BCE (Background Colour Erase) is now supported.
+* All occurrences of a search string in copy mode are now highlighted;
+  additionally, the number of search results is displayed. The highlighting
+  updates interactively with the default emacs key bindings (incremental
+  search).
+* source-file now understands glob patterns.
+* Formats now have simple comparisons:
+
+    #{==:a,b}
+    #{!=:a,b}
+
+* There are the following new formats:
+
+  - #{version} -- the tmux server version;
+  - #{client_termtype} -- the terminal type of the client;
+  - #{client_name} -- the name of a client;
+  - #{client_written} -- the number of bytes written to the client.
+
+* The configuration file now accepts %if/%endif conditional blocks which are
+  processed when it is parsed; the argument is a format string (useful with the
+  new format comparison options).
+* detach-client now has -E to execute a command replacing the client instead of
+  exiting.
+* Add support for custom command aliases, this is an array option which
+  contains items of the form "alias=command". This is consulted when an
+  unknown command is parsed.
+* break-pane now has -n to specify the new window name.
+* OSC 52 support has been added for programs inside tmux to set a tmux buffer.
+* The mouse "all event" mode (1003) is now supported.
+* Palette setting is now possible (OSC 4 and 104).
+* Strikethrough support (a recent terminfo is required).
+* Grouped sessions can now be named (new -t).
+* terminal-overrides and update-environment are now array options (the previous
+  set -ag syntax should work without change).
+* There have been substantial performance improvements.
+
+CHANGES FROM 2.2 TO 2.3, 29 September 2016
+
+Incompatible Changes
+====================
+
+None.
+
+Normal Changes
+==============
+
+* New option 'pane-border-status' to add text in the pane borders.
+* Support for hooks on commands: 'after' and 'before' hooks.
+* 'source-file' understands '-q' to suppress errors for nonexistent files.
+* Lots of UTF8 improvements, especially on MacOS.
+* 'window-status-separator' understands #[] expansions.
+* 'split-window' understands '-f' for performing a full-width split.
+* Allow report count to be specified when using 'bind-key -R'.
+* 'set -a' for appending to user options (@foo) is now supported.
+* 'display-panes' can now accept a command to run, rather than always
+  selecting the pane.
+
+CHANGES FROM 2.1 TO 2.2, 10 April 2016

 Incompatible Changes
 ====================
@@ -10,7 +307,7 @@ Incompatible Changes
 can be used.

 * Support for TMPDIR has been removed.  Use TMUX_TMPDIR instead.
-* UTF8 detection how happens automatically if the client supports it, hence
+* UTF8 detection now happens automatically if the client supports it, hence
  the:

  mouse-utf8
@@ -63,8 +360,7 @@ Normal Changes
 * RGB (24bit) colour support.  The 'Tc' flag must be set in the external TERM
  entry (using terminal-overrides or a custom terminfo entry).

-
-CHANGES FROM 2.0 to 2.1 18 October 2015
+CHANGES FROM 2.0 TO 2.1, 18 October 2015

 Incompatible Changes
 ====================
@@ -115,7 +411,7 @@ Normal Changes
 * Copy mode is exited if the history is cleared whilst in copy-mode.
 * 'copy-mode' learned '-e' to exit copy-mode when scrolling to end.

-CHANGES FROM 1.9a to 2.0 6 March 2015
+CHANGES FROM 1.9a TO 2.0, 06 March 2015

 Incompatible Changes
 ====================
@@ -174,9 +470,9 @@ Normal Changes
 * 'split-window' and 'join-window' understand -b to create the pane to the left
  or above the target pane.

-CHANGES FROM 1.9 to 1.9a 22 February 2014
+CHANGES FROM 1.9 TO 1.9a, 22 February 2014

-NOTE:  This is a bug-fix release to address some important bugs which just
+NOTE: This is a bug-fix release to address some important bugs which just
 missed the 1.9 deadline, but were found afterwards.

 Normal Changes
@@ -185,7 +481,7 @@ Normal Changes
 * Fix crash due to uninitialized lastwp member of layout_cell
 * Fix -fg/-bg/-style with 256 colour terminals.  

-CHANGES FROM 1.8 to 1.9, 20 February 2014
+CHANGES FROM 1.8 TO 1.9, 20 February 2014

 NOTE:  This release has bumped the tmux protocol version.  It is therefore
 advised that the prior tmux server is restarted when this version of tmux is
@@ -217,8 +513,8 @@ Normal Changes
 * A new environment variable TMUX_TMPDIR is now honoured, allowing the
  socket directory to be set outside of TMPDIR (/tmp/ if not set).
 * If -s not given to swap-pane the current pane is assumed.
-* A #{pane_syncronized} format specifier has been added to be a conditional
-  format if a pane is in a syncronised mode (c.f. syncronize-panes)
+* A #{pane_synchronized} format specifier has been added to be a conditional
+  format if a pane is in a synchronised mode (c.f. synchronize-panes)
 * Tmux now runs under Cygwin natively.
 * Formats can now be nested within each other and expanded accordingly.
 * Added 'automatic-rename-format' option to allow the automatic rename
@@ -240,7 +536,7 @@ Normal Changes
 * tmux now supports 256 colours running under fbterm.
 * Many bug fixes!

-CHANGES FROM 1.7 to 1.8, 26 March 2013
+CHANGES FROM 1.7 TO 1.8, 26 March 2013

 Incompatible Changes
 ====================
@@ -291,7 +587,7 @@ Normal Changes
 * Lots and lots of bug fixes, fixing memory-leaks, etc.
 * Various manpage improvements.

-CHANGES FROM 1.6 to 1.7, 13 October 2012
+CHANGES FROM 1.6 TO 1.7, 13 October 2012

 * tmux configuration files now support line-continuation with a "\" at the
  end of a line.
@@ -682,7 +978,7 @@ CHANGES FROM 1.0 TO 1.1, 05 November 2009
 * xterm-keys rewrite.
 * Additional code reduction, and bug fixes.

-CHANGES FROM 0.9 TO 1.0, 20 Sept 2009
+CHANGES FROM 0.9 TO 1.0, 20 September 2009

 * Option to alter the format of the window title set by tmux.
 * Backoff for a while after multiple incorrect password attempts.
@@ -1018,7 +1314,7 @@ The list of older changes is below.
 * -u flag to scroll-mode and copy-mode to start scrolled one page
  up. scroll-mode -u is bound to prefix,page-up (ppage) by default.
 * Allow status, mode and message attributes to be changed by three new options:
-  status-attr, mode-attr, message-attr. A comma-separataed list is accepted
+  status-attr, mode-attr, message-attr. A comma-separated list is accepted
  containing: bright, dim, underscore, blink, reverse, hidden, italics, for
  example:

--- a/33
+++ b/33
@@ -0,0 +1,33 @@
+When reporting issues:
+
+YOU MUST INCLUDE THE TMUX VERSION
+
+DO NOT OPEN AN ISSUE THAT DOES NOT MENTION THE TMUX VERSION
+
+Please also include:
+
+- your platform (Linux, OS X, or whatever);
+- a brief description of the problem with steps to reproduce;
+- a minimal tmux config, if you can't reproduce without a config;
+- your terminal, and $TERM inside and outside of tmux;
+- logs from tmux (see below);
+- at most one or two screenshots, if helpful.
+
+This should include at least the output of:
+
+    $ uname -sp && tmux -V && echo $TERM
+
+Please do not report bugs (crashes, incorrect behaviour) without reproducing on
+a tmux built from Git master.
+
+Note that TERM inside tmux must be a variant of screen or tmux (for example:
+screen or screen-256color, tmux or tmux-256color). Please ensure this is the
+case before opening an issue.
+
+To run tmux without a config and get logs, run:
+
+    tmux -Ltest kill-server
+    tmux -vv -Ltest -f/dev/null new
+
+Then reproduce the problem, exit tmux, and attach the tmux-server-*.log file
+from the current directory to the issue.
--- a/454
+++ b/454
@@ -1,454 +0,0 @@
-tmux frequently asked questions
-
-******************************************************************************
-* PLEASE NOTE: most display problems are due to incorrect TERM! Before       *
-* reporting problems make SURE that TERM settings are correct inside and     *
-* outside tmux.                                                              *
-*                                                                            *
-* Inside tmux TERM must be "screen" or similar (such as "screen-256color").  *
-* Don't bother reporting problems where it isn't!                            *
-*                                                                            *
-* Outside, it must match your terminal: particularly, use "rxvt" for rxvt    *
-* and derivatives.                                                           *
-******************************************************************************
-
-* How is tmux different from GNU screen?
-
-tmux and GNU screen have many similarities. Some of the main differences I am
-aware of are (bearing in mind I haven't used screen for a few years now):
-
- tmux uses a client-server model. Each server has single Unix domain socket in
-  /tmp and within one server there are multiple sessions which may be attached
-  to multiple clients (terminals).
-
-  This has advantages, notably: windows may be linked simultaneously to
-  multiple sessions; windows may be moved freely between sessions; and a client
-  may be switched between sessions easily (C-b D). There is one major
-  disadvantage: if the server crashes, game over, all sessions die. In
-  practice, however, tmux is quite stable and gets more so as people report any
-  bugs they hit :-).
-
-  This model is different from screen, where typically each new screen instance
-  is independent. tmux supports the same behaviour by using multiple servers
-  with the -L option but it is not typically recommended.
-
- Different command interfaces. One of the goals of tmux is that the shell
-  should be easily usable as a scripting language - almost all tmux commands
-  can be used from the shell and behave identically whether used from the
-  shell, from a key binding or from the command prompt. Personally I also find
-  tmux's command interface much more consistent and clearer, but this is
-  subjective.
-
- tmux calls window names (what you see in the status line) "names", screen
-  calls them "titles".
-
- tmux has a multiple paste buffers. Not a major one but comes in handy quite a
-  lot.
-
- tmux supports automatically renaming windows to the running application
-  without gross hacks using escape sequences. Its even on by default.
-
- tmux has a choice of vi or emacs key layouts. Again, not major, but I use
-  emacs so if tmux did support only one key set it would be emacs and then all
-  the vi users would get humpy. Key bindings may be completely reconfigured in
-  any case.
-
- tmux has an option to limit the window size.
-
- tmux has search in windows (C-b f).
-
- The window split (pane) model is different. tmux has two objects, windows and
-  panes; screen has just windows. This difference has several implications:
-
-  * In screen you can have a window appear in several layouts, in tmux a pane
-  can only be in one window (fixing this is a big todo item but quite
-  invasive).
-
-  * tmux layouts are immutable and do not get changed unless you modify them.
-
-  * In tmux, all panes are closed when you kill a window.
-
-  * tmux panes do not have individual names, titles and so on.
-
-  I think tmux's model is much easier to manage and navigate within a window,
-  but breaking panes off from and joining them to windows is more clumsy.
-
-  tmux also has support for preset pane layouts.
-
- tmux's status line syntax is more readable and easier to use. I think it'd be
-  hard for anyone to argue with this. tmux doesn't support running a command
-  constantly and always using the last line of its output, commands must be run
-  again each time.
-
- tmux has modern, easily extended code. Again hard to argue screen is better
-  if you have looked at the code.
-
- tmux depends on libevent. I don't see this as a disadvantage: libevent is
-  small and portable, and on modern systems with current package management
-  systems dependencies are not an issue. libevent brings advantages in code
-  simplicity and performance.
-
- screen allows the window to be bigger than the terminal and can pan around
-  it. tmux limits the size to the largest attached client. This is a big todo
-  item for tmux but it is not trivial.
-
- screen has builtin serial and telnet support; this is bloat and is unlikely
-  to be added to tmux.
-
- Environment handling is different.
-
- tmux tends to be more demanding on the terminal so tends to show up terminal
-  and application bugs which screen does not.
-
- screen has wider platform support, for example IRIX, and for odd terminals.
-
-* I found a bug! What do I do?
-
-Check the latest version of tmux from Git to see if the problem is still
-reproducible.  Sometimes the length of time between releases means a lot of
-fixes can be sitting in Git and the problem might already be fixed.
-
-Please send bug reports by email to nicholas.marriott@gmail.com or
-tmux-users@googlegroups.com. Please include as much of the following
-information as possible:
-
- the version of tmux you are running;
- the operating system you are using and its version;
- the terminal emulator you are using and the TERM setting when tmux was
-  started;
- a description of the problem;
- if the problem is repeatable, the steps to repeat the problem;
- for screen corruption issues, a screenshot and the output of "infocmp $TERM"
-  from outside tmux are often very useful.
-
-* Why doesn't tmux do $x?
-
-Please send feature requests by email to tmux-users@googlegroups.com.
-
-* Why do you use the screen terminal description inside tmux? It sucks.
-
-It is already widely available. It is planned to change to something else such
-as xterm-xfree86 at some point, if possible.
-
-* I don't see any colour in my terminal! Help!
-
-On some platforms, common terminal descriptions such as xterm do not include
-colour. screen ignores this, tmux does not. If the terminal emulator in use
-supports colour, use a value for TERM which correctly lists this, such as
-xterm-color.
-
-* tmux freezes my terminal when I attach to a session. I even have to kill -9
-  the shell it was started from to recover!
-
-Some consoles really really don't like attempts to set the window title. Tell
-tmux not to do this by turning off the "set-titles" option (you can do this
-in .tmux.conf):
-
-     set -g set-titles off
-
-If this doesn't fix it, send a bug report.
-
-* Why is C-b the prefix key? How do I change it?
-
-The default key is C-b because the prototype of tmux was originally developed
-inside screen and C-b was chosen not to clash with the screen meta key. It
-also has the advantage of not interfering with the use of C-a for start-of-line
-in emacs and the shell (although it does interfere with previous-character).
-
-Changing is simple: change the "prefix-key" option, and - if required - move
-the binding of the "send-prefix" command from C-b (C-b C-b sends C-b by
-default) to the new key. For example:
-
-	set -g prefix C-a
-	unbind C-b
-	bind C-a send-prefix
-
-* How do I use UTF-8?
-
-When running tmux in a UTF-8 capable terminal, UTF-8 must be turned on in tmux;
-as of release 0.9, tmux attempts to autodetect a UTF-8-capable terminal by
-checking the LC_ALL, LC_CTYPE and LANG environment variables. list-clients may
-be used to check if this is detected correctly; if not, the -u command-line
-flag may be specified when creating or attaching a client to a tmux session:
-
-	$ tmux -u new
-
-Since the 1.0 release, tmux will turn on UTF-8 related options automatically
-(ie status-utf8, and utf8) if the above conditions are met.
-
-* How do I use a 256 colour terminal?
-
-Provided the underlying terminal supports 256 colours, it is usually sufficient
-to add the following to ~/.tmux.conf:
-
-	set -g default-terminal "screen-256color"
-
-Note that some platforms do not support "screen-256color" ("infocmp
-screen-256color" will return an error) - in this case see the next entry in
-this FAQ.
-
-tmux attempts to detect a 256 colour terminal both by looking at the colors
-terminfo entry and by looking for the string "256col" in the TERM environment
-variable.
-
-If both these methods fail, the -2 flag may be passed to tmux when attaching
-to a session to indicate the terminal supports 256 colours.
-
-* vim or $otherprogram doesn't display 256 colours. What's up?
-
-Some programs attempt to detect the number of colours a terminal is capable of
-by checking the colors terminfo or Co termcap entry. However, this is not
-reliable, and in any case is missing from the "screen" terminal description
-used inside tmux.
-
-There are two options (aside from using "screen-256color") to allow programs to
-recognise they are running on a 256-colour terminal inside tmux:
-
- Manually force the application to use 256 colours always or if TERM is set to
-  screen. For vim, you can do this by overriding the t_Co option, see
-  http://vim.wikia.com/wiki/256_colors_in_vim.
- Creating a custom terminfo file that includes colors#256 in ~/.terminfo and
-  using it instead. These may be compiled with tic(1).
-
-* How do I make Ctrl-PgUp and Ctrl-PgDn work in vim?
-
-tmux supports passing through ctrl (and where supported by the client terminal,
-alt and shift) modifiers to function keys using xterm(1)-style key sequences.
-This may be enabled per window, or globally with the tmux command:
-
-	setw -g xterm-keys on
-
-Because the TERM variable inside tmux must be set to "screen", vim will not
-automatically detect these keys are available; however, the appropriate key
-sequences can be overridden in .vimrc using the following:
-
-	if &term == "screen"
-	set t_kN=^[[6;*~
-	set t_kP=^[[5;*~
-	endif
-
-And similarly for any other keys for which modifiers are desired.
-
-Please note that the "xterm-keys" setting may affect other programs, in the
-same way as running them in a standard xterm; for example most shells do not
-expect to receive xterm(1)-style key sequences so this setting may prevent keys
-such as ctrl-left and ctrl-right working correctly. tmux also passes through
-the ctrl (bit 5 set, for example ^[[5~ to ^[[5^) modifier in non-xterm(1) mode;
-it may be possible to configure vim to accept these, an example of how to do so
-would be welcome.
-
-vim users may also want to set the "ttyfast" option inside tmux.
-
-* How do I make ctrl and shift arrow keys work in emacs?
-
-The terminal-init-screen function in term/screen.el is called for new frames,
-but it doesn't configure any function keys.
-
-If the tmux xterm-keys option is on, it is enough to define the same keys as
-xterm. Add the following to init.el or .emacs to do this:
-
-(defadvice terminal-init-screen
-  ;; The advice is named `tmux', and is run before `terminal-init-screen' runs.
-  (before tmux activate)
-  ;; Docstring.  This describes the advice and is made available inside emacs;
-  ;; for example when doing C-h f terminal-init-screen RET
-  "Apply xterm keymap, allowing use of keys passed through tmux."
-  ;; This is the elisp code that is run before `terminal-init-screen'.
-  (if (getenv "TMUX")
-    (let ((map (copy-keymap xterm-function-map)))
-    (set-keymap-parent map (keymap-parent input-decode-map))
-    (set-keymap-parent input-decode-map map))))
-
-And ensure .tmux.conf contains "set -g xterm-keys on".
-
-Alternatively, the screen.el file can be copied to the load path and
-customized.
-
-* Why doesn't elinks set the window title inside tmux?
-
-There isn't a way to detect if a terminal supports setting the window title, so
-elinks attempts to guess by looking at the environment. Rather than looking for
-TERM=screen, it uses the STY variable to detect if it is running in screen;
-tmux does not use this so the check fails. A workaround is to set STY before
-running elinks.
-
-The following shell function does this, and also clears the window title on
-exit (elinks, for some strange reason, sets it to the value of TERM):
-
-	elinks() {
-        	STY= `which elinks` $*
-	        echo -ne \\033]0\;\\007;
-	}
-
-* What is the proper way to escape characters with #(command)?
-
-When using the #(command) construction to include the output from a command in
-the status line, the command will be parsed twice. First, when it's read by the
-configuration file or the command-prompt parser, and second when the status
-line is being drawn and the command is passed to the shell. For example, to
-echo the string "(test)" to the status line, either single or double quotes
-could be used:
-
-	set -g status-right "#(echo \\\\(test\\\\))"
-	set -g status-right '#(echo \\\(test\\\))'
-
-In both cases, the status-right option will be set to the string "#(echo
-\\(test\\))" and the command executed will be "echo \(test\)".
-
-* tmux uses too much CPU. What do I do?
-
-Automatic window renaming may use a lot of CPU, particularly on slow computers:
-if this is a problem, turn it off with "setw -g automatic-rename off". If this
-doesn't fix it, please report the problem.
-
-* I use PuTTY and my tmux window pane separators are all qqqqqqqqq's! 
-
-PuTTY is using a character set translation that doesn't support ACS line
-drawing. With a Unicode font, try setting PuTTY to use a different translation
-on the Window -> Translation configuration page. For example, change UTF-8 to
-ISO-8859-1 or CP437. It may also be necessary to adjust the way PuTTY treats
-line drawing characters in the lower part of the same configuration page.
-
-* What is the best way to display the load average? Why no #L?
-
-It isn't possible to get the load average portably in code and it is preferable
-not to add portability goop. The following works on at least Linux, *BSD and OS
-X:
-
-uptime|awk '{split(substr($0, index($0, "load")), a, ":"); print a[2]}'
-
-* How do I attach the same session to multiple clients but with a different
-  current window, like screen -x?
-
-One or more of the windows can be linked into multiple sessions manually with
-link-window, or a grouped session with all the windows can be created with
-new-session -t.
-
-* Ctrl and arrow keys doesn't work in putty! What do I do?
-
-putty inverts the sense of the cursor key mode on ctrl, which is a bit hard for
-tmux to detect properly. To get ctrl keys right, change the terminfo settings
-so kUP5 (Ctrl-Up etc) are the adjusted versions, and disable smkx/rmkx so tmux
-doesn't change the mode. For example with this line in .tmux.conf (assuming you
-have TERM set to xterm):
-
-set -g terminal-overrides "xterm*:kLFT5=\eOD:kRIT5=\eOC:kUP5=\eOA:kDN5=\eOB:smkx@:rmkx@"
-
-Note that this will only work in tmux 1.2 and above.
-
-* How can I blank the tmux window?
-
-GNU screen has a feature whereby it will blank the screen after a period of
-inactivity. To do the same thing in tmux, use the lock-command setting, for
-example (with GNU bash):
-
-set -g lock-command 'tput civis && read -s -n1'
-
-This will remove the cursor and tell the shell to quit once a key has been
-pressed. For zsh, use "read -s -k1".
-
-In addition, it's possible to have both blanking and locking (for instance via
-lock(1) or vlock(1)) by using the following:
-
-bind x set lock-command '/usr/bin/vlock' \; lock-client \; set lock-command 'tput civis && read -s -n1'
-
-* I don't see italics! Or less and vim show italics and reverse the wrong way round!
-
-GNU screen does not support italics and the "screen" terminfo description uses
-the italics escape sequence incorrectly.
-
-As of tmux 2.1, if default-terminal is set to "screen" or matches "screen-*",
-tmux will behave like screen and italics will be disabled.
-
-To enable italics, create a new terminfo entry called "tmux" (some platforms
-may already have this, you can check with "infocmp tmux"):
-
-	$ cat <<EOF|tic -x -
-	tmux|tmux terminal multiplexer,
-		ritm=\E[23m, rmso=\E[27m, sitm=\E[3m, smso=\E[7m, Ms@,
-		use=xterm+tmux, use=screen,
-
-	tmux-256color|tmux with 256 colors,
-		use=xterm+256setaf, use=tmux,
-	EOF
-	$
-
-And tell tmux to use it in ~/.tmux.conf:
-	
-	set -g default-terminal "tmux"
-
-If using urxvt, make sure you have an italics capable font enabled. for
-example, add to ~/.Xdefaults:
-
-	urxvt.italicFont: xft:Bitstream Vera Sans Mono:italic:autohint=true
-
-* How can I make tmux use my terminal's scrollback buffer?
-
-Normally, tmux enables the terminal's "alternate screen". Most terminals (such
-as xterm) do not save scrollback for the alternate screen. You might prefer
-tmux to use the normal screen, so it uses your terminal's scrollback
-buffer. This way, you can access the scrollback buffer as usual, for example
-using the mouse wheel - although there is no guarantee output inside tmux will
-always (or ever) be added to the scrollback.
-
-You can make tmux use the normal screen by telling it that your terminal does
-not have an alternate screen. Put the following in ~/.tmux.conf:
-
-        set -ga terminal-overrides ',xterm*:smcup@:rmcup@'
-
-Adjust if your $TERM does not start with xterm.
-
-tmux will still emulate the alternate screen for applications run under tmux,
-so you don't really lose anything with this setting. The only disadvantage is
-that when you exit tmux, it will not restore whatever was there before you
-started.
-
-* How do I see the default configuration?
-
-Show the default session options by starting a new tmux server with no
-configuration file:
-
-        $ tmux -Lfoo -f/dev/null start\; show -g
-
-Or the default window options:
-
-        $ tmux -Lfoo -f/dev/null start\; show -gw
-
-* How do I copy a selection from tmux to the system's clipboard?
-
-When running in xterm(1), tmux can automatically send copied text to the
-clipboard. This is controlled by the set-clipboard option and also needs this
-X resource to be set:
-
-	XTerm*disallowedWindowOps: 20,21,SetXprop
-
-For rxvt-unicode (urxvt), there is an unofficial Perl extension here:
-
-        http://anti.teamidiot.de/static/nei/*/Code/urxvt/
-
-Otherwise a key binding for copy mode using xclip (or xsel) works:
-
-	bind -temacs-copy C-y copy-pipe "xclip -i >/dev/null"
-
-Or for inside and outside copy mode with the prefix key:
-
-        bind C-y run -b "tmux save-buffer - | xclip -i"
-
-On OS X, reattach-to-usernamespace lets pbcopy/pbpaste work:
-
-        https://github.com/ChrisJohnsen/tmux-MacOSX-pasteboard
- 
-* Why do I see dots around a session when I attach to it?
-
-tmux limits the size of the window to the smallest attached session. If
-it didn't do this then it would be impossible to see the entire window.
-The dots mark the size of the window tmux can display.
-
-To avoid this, detach all other clients when attaching:
-
-	$ tmux attach -d
-
-Or from inside tmux by detaching individual clients with C-b D or all
-using:
-
-	C-b : attach -d
--- a/1
+++ b/1
@@ -0,0 +1 @@
+Please read https://raw.githubusercontent.com/tmux/tmux/master/CONTRIBUTING
--- a/Makefile.am
+++ b/Makefile.am
@@ -6,57 +6,53 @@ CLEANFILES = tmux.1.mdoc tmux.1.man

 # Distribution tarball options.
 EXTRA_DIST = \
-	CHANGES FAQ README TODO COPYING example_tmux.conf compat/*.[ch] \
-	array.h compat.h tmux.h osdep-*.c xmalloc.h mdoc2man.awk tmux.1
-dist-hook:
-	make clean
-	grep "^#found_debug=" configure
+	CHANGES README COPYING example_tmux.conf compat/*.[ch] \
+	osdep-*.c mdoc2man.awk tmux.1

 # Preprocessor flags.
-CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""
+AM_CPPFLAGS += @XOPEN_DEFINES@ -DTMUX_CONF="\"$(sysconfdir)/tmux.conf\""

-# glibc as usual does things ass-backwards and hides useful things by default,
-# so everyone has to add this.
-if IS_GLIBC
-CFLAGS += -D_GNU_SOURCE
-endif
+# Additional object files.
+LDADD = $(LIBOBJS)

 # Set flags for gcc.
 if IS_GCC
-CFLAGS += -std=gnu99 -O2
+AM_CFLAGS += -std=gnu99 -O2
 if IS_DEBUG
-CFLAGS += -g
-CFLAGS += -Wno-long-long -Wall -W -Wnested-externs -Wformat=2
-CFLAGS += -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations
-CFLAGS += -Wwrite-strings -Wshadow -Wpointer-arith -Wsign-compare
-CFLAGS += -Wundef -Wbad-function-cast -Winline -Wcast-align
-CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
-CPPFLAGS += -DDEBUG
+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 -Wcast-align
+AM_CFLAGS += -Wdeclaration-after-statement -Wno-pointer-sign -Wno-attributes
+AM_CFLAGS += -Wno-unused-result
+AM_CPPFLAGS += -DDEBUG
 endif
-if IS_COVERAGE
-CFLAGS += -g -O0 --coverage
-LDFLAGS += --coverage
-endif
-CPPFLAGS += -iquote.
+AM_CPPFLAGS += -iquote.
 endif

 # Set flags for Solaris.
 if IS_SUNOS
 if IS_GCC
-CPPFLAGS += -D_XPG6 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG6
 else
-CPPFLAGS += -D_XPG4_2 -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS
+AM_CPPFLAGS += -D_XPG4_2
 endif
 endif

 # Set flags for Sun CC.
 if IS_SUNCC
-CFLAGS += -erroff=E_EMPTY_DECLARATION
+AM_CFLAGS += -erroff=E_EMPTY_DECLARATION
 endif

 # Set _LINUX_SOURCE_COMPAT for AIX for malloc(0).
 if IS_AIX
-DEFS += -D_LINUX_SOURCE_COMPAT=1
+AM_CPPFLAGS += -D_LINUX_SOURCE_COMPAT=1
+endif
+
+# Set flags for NetBSD.
+if IS_NETBSD
+AM_CPPFLAGS += -D_OPENBSD_SOURCE
 endif

 # List of sources.
@@ -70,18 +66,15 @@ dist_tmux_SOURCES = \
 	cmd-bind-key.c \
 	cmd-break-pane.c \
 	cmd-capture-pane.c \
-	cmd-choose-buffer.c \
-	cmd-choose-client.c \
 	cmd-choose-tree.c \
-	cmd-clear-history.c \
 	cmd-command-prompt.c \
 	cmd-confirm-before.c \
 	cmd-copy-mode.c \
 	cmd-detach-client.c \
 	cmd-display-message.c \
 	cmd-display-panes.c \
-	cmd-find.c \
 	cmd-find-window.c \
+	cmd-find.c \
 	cmd-if-shell.c \
 	cmd-join-pane.c \
 	cmd-kill-pane.c \
@@ -133,8 +126,9 @@ dist_tmux_SOURCES = \
 	cmd-wait-for.c \
 	cmd.c \
 	colour.c \
-	control.c \
+	compat.h \
 	control-notify.c \
+	control.c \
 	environ.c \
 	format.c \
 	grid-view.c \
@@ -149,7 +143,7 @@ dist_tmux_SOURCES = \
 	layout-set.c \
 	layout.c \
 	log.c \
-	mode-key.c \
+	mode-tree.c \
 	names.c \
 	notify.c \
 	options-table.c \
@@ -164,80 +158,34 @@ dist_tmux_SOURCES = \
 	server-fn.c \
 	server.c \
 	session.c \
-	signal.c \
 	status.c \
 	style.c \
 	tmux.c \
+	tmux.h \
 	tty-acs.c \
 	tty-keys.c \
 	tty-term.c \
 	tty.c \
 	utf8.c \
-	window-choose.c \
+	window-buffer.c \
+	window-client.c \
 	window-clock.c \
 	window-copy.c \
+	window-tree.c \
 	window.c \
 	xmalloc.c \
+	xmalloc.h \
 	xterm-keys.c
 nodist_tmux_SOURCES = osdep-@PLATFORM@.c

-# Pile in all the compat/ stuff that is needed.
-if NO_FORKPTY
+# Add compat file for forkpty.
+if NEED_FORKPTY
 nodist_tmux_SOURCES += compat/forkpty-@PLATFORM@.c
 endif
-if NO_IMSG
-nodist_tmux_SOURCES += compat/imsg.c compat/imsg-buffer.c
-endif
-if NO_CLOSEFROM
-nodist_tmux_SOURCES += compat/closefrom.c
-endif
-if NO_DAEMON
-nodist_tmux_SOURCES += compat/daemon.c
-endif
-if NO_SETENV
-nodist_tmux_SOURCES += compat/setenv.c
-endif
-if NO_STRLCAT
-nodist_tmux_SOURCES += compat/strlcat.c
-endif
-if NO_STRLCPY
-nodist_tmux_SOURCES += compat/strlcpy.c
-endif
-if NO_ASPRINTF
-nodist_tmux_SOURCES += compat/asprintf.c
-endif
-if NO_FGETLN
-nodist_tmux_SOURCES += compat/fgetln.c
-endif
-if NO_FPARSELN
-nodist_tmux_SOURCES += compat/fparseln.c
-endif
-if NO_GETOPT
-nodist_tmux_SOURCES += compat/getopt.c
-endif
-if NO_STRCASESTR
-nodist_tmux_SOURCES += compat/strcasestr.c
-endif
-if NO_STRSEP
-nodist_tmux_SOURCES += compat/strsep.c
-endif
-if NO_VIS
-nodist_tmux_SOURCES += compat/vis.c compat/unvis.c
-endif
-if NO_STRTONUM
-nodist_tmux_SOURCES += compat/strtonum.c
-endif
-if NO_B64_NTOP
-nodist_tmux_SOURCES += compat/b64_ntop.c
-endif
-if NO_CFMAKERAW
-nodist_tmux_SOURCES += compat/cfmakeraw.c
-endif
-if NO_OPENAT
-nodist_tmux_SOURCES += compat/openat.c
-endif
-if NO_REALLOCARRAY
-nodist_tmux_SOURCES += compat/reallocarray.c
+
+# Add compat file for utf8proc.
+if HAVE_UTF8PROC
+nodist_tmux_SOURCES += compat/utf8proc.c
 endif

 # Install tmux.1 in the right format.
--- a/29
+++ b/29
@@ -10,13 +10,17 @@ tmux depends on libevent 2.x. Download it from:

 	http://libevent.org

-To build tmux from a release tarball, do:
+It also depends on ncurses, available from:
+
+	http://invisible-island.net/ncurses/
+
+To build and install tmux from a release tarball, use:

 	$ ./configure && make
 	$ sudo make install

-By default, tmux will use the utempter library to update utmp(5), if it is
-installed. Run configure with --disable-utempter to disable this.
+tmux can use the utempter library to update utmp(5), if it is installed - run
+configure with --enable-utempter to enable this.

 To get and build the latest from version control:

@@ -25,27 +29,28 @@ To get and build the latest from version control:
 	$ sh autogen.sh
 	$ ./configure && make

+(Note that this requires at least a working C compiler, make, autoconf,
+automake, pkg-config as well as libevent and ncurses libraries and headers.)
+
 For more information see http://git-scm.com. Patches should be sent by email to
-the mailing list at tmux-users@googlegroups.com.
+the mailing list at tmux-users@googlegroups.com or submitted through GitHub at
+https://github.com/tmux/tmux/issues.

 For documentation on using tmux, see the tmux.1 manpage. It can be viewed from
 the source tree with:

 	$ nroff -mdoc tmux.1|less

-Some common questions are answered in the FAQ file and a more extensive (but
-slightly out of date) guide is available in the OpenBSD FAQ at
-http://www.openbsd.org/faq/faq7.html#tmux. A rough todo list is in the TODO
-file and an example configuration in example_tmux.conf.
+A small example configuration in example_tmux.conf.

 A vim(1) syntax file is available at:

-   https://github.com/keith/tmux.vim
-   https://raw.githubusercontent.com/keith/tmux.vim/master/syntax/tmux.vim
+	https://github.com/ericpruitt/tmux.vim
+	https://raw.githubusercontent.com/ericpruitt/tmux.vim/master/vim/syntax/tmux.vim

 And a bash(1) completion file at:

-   https://github.com/przepompownia/tmux-bash-completion
+	https://github.com/imomaliev/tmux-bash-completion

 For debugging, running tmux with -v or -vv will generate server and client log
 files in the current directory.
@@ -58,6 +63,8 @@ And for Git commit emails:

 	https://groups.google.com/forum/#!forum/tmux-git

+Subscribe by sending an email to <tmux-users+subscribe@googlegroups.com>.
+
 Bug reports, feature suggestions and especially code contributions are most
 welcome. Please send by email to:

--- a/21
+++ b/21
@@ -115,7 +115,7 @@ From there, merge the result in, fixing up any conflicts which might arise.

 % git merge obsd-master

-Then ensure things look correct by BULDING the result of that sync:
+Then ensure things look correct by BUILDING the result of that sync:

 % make clean && ./autogen.sh && ./configure && make

@@ -140,15 +140,13 @@ to compat/ as and when appropriate.
 Release tmux for next version
 =============================

-1. Comment the "found_debug=yes" line in configure.ac, since releases
-   don't have debugging enabled, otherwise make(1) aborts when
-   preparing the distribution.
-
-2. Update and commit README and CHANGES.  The former should be checked for
+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
@@ -157,7 +155,7 @@ Release tmux for next version

   Push the tag out with:

-   % git push 2.X
+   % git push --tags

 4. Build the tarball with 'make dist'.

@@ -168,9 +166,8 @@ Release tmux for next version
   Click the "Add release notes", upload the tarball and add a link in the
   description field to the CHANGES file.

-7. Clone the tmux.github.io repository, and change the RELEASE version in
-   the Makefile.  Commit it, and run 'make' to replace %%VERSION%%.  Push
-   the result out.
+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.

-8. Bump version in tmu/tmux.git configure.ac and uncomment "found_debug=yes" to
-   create a debug build by default.
+7. Change version back to master in configure.ac.
--- a/93
+++ b/93
@@ -1,38 +1,28 @@
 - command bits and pieces:
 	* allow multiple targets: fnmatch for -t/-c, for example detach all
 	  clients with -t*
-	* add -c for new-session like new-window
 	* ' and " should be parsed the same (eg "\e" vs '\e') in config
 	  and command prompt
 	* last-pane across sessions
-	* list-keys should quote output so that bindings can just be used in
-          config file as-is
+	* resize-pane -p to match split-window -p
+	* flag to wait-for to have a timeout and/or to stop waiting when the
+	  client gets a signal

 - make command sequences more usable
 	* don't require space after ;
 	* options for error handling: && and ||?

 - options bits and pieces:
-	* set-remain-on-exit is a complete hack
 	* way to set socket path from config file

 - format improvements:
 	* option to quote format (#{q:session_name})
-	* formats need conditions for >0 (for #P)
 	* some way to pad # stuff with spaces
 	* formats to show if a window is linked into multiple sessions, into
 	  multiple attached sessions, and is the active window in multiple
 	  attached sessions?
-
- choose mode improvements:
-	* choose-pane command (augment choose-tree to do this?)
-	* choose-mode and copy-mode are very similar, make choose-mode a subset?
-	* flag to choose-* for sort order
-	* choose mode would be better per client than per window?
-	* two choices (first one then second, for swap-pane and join-pane)
-	* choose modes should ditch the key bindings and just have fixed keys, and
-          be more customized to their purpose (d to delete a buffer for choose-buffer,
-          a preview of buffer contents, etc)
+	* comparison operators like < and > (for #{version}?)
+	* %else statement in config file

 - improve monitor-*:
 	* straighten out rules for multiple clients
@@ -44,38 +34,21 @@
 	* bind commands to mouse in different areas? 
 	* commands executed when clicking on a pattern (URL)

- hooks!
-
 - warts on current naming:
 	* display-time but message-fg/bg/attr
 	* list-* vs show-*
-	* split-window -> split-pane?
-
- better UTF-8 support:
-	* message display
-	* prompt input
-	* searching in copy mode

 - copy/paste improvements:
-	* incremental searching
 	* paste w/o trailing whitespace
 	* command to toggle selection not to move it in copy-mode
 	* regex searching
-	* copy-pipe should have -x as well
-	* copy mode key bindings should just be a standard key table, using
-          something like "copy-mode start-selection"; it could use
-          command-prompt for search, goto, etc:
-
-              bind -Temacs command-prompt -p'Search Up: ' 'copy-mode search-up %%'
-
-          it'd need a separate lookup, because modes are per-pane, perhaps a
-          table() cb to give the table name ("vi" or "emacs"). anything in the
-          table fires the command, anything not in the table is injected as a
-          key
-	* searching in copy mode should unwrap lines, so if you seach for "foobar"
-          then it should be found even if it is now "foo\nbar" (if the WRAP flag
-          is set on the line)
-	* {} to go to next/previous blank line in copy mode
+	* searching in copy mode should unwrap lines, so if you search for "foobar"
+	  then it should be found even if it is now "foo\nbar" (if the WRAP flag
+	  is set on the line)
+	* capture-pane option to preserve spaces but not join lines
+	* improve word and line selection in copy mode (for example when
+	  dragging it should select by word. compare how xterm works. GitHub
+	  issue 682)

 - layout stuff
 	* way to tag a layout as a number/name
@@ -90,19 +63,19 @@
 	* panning over window (window larger than visible)
 	* a mode where one application can cross two panes (ie x|y, width =
 	  COLUMNS/2 but height = ROWS * 2)
-	* general key to space cells out evenly (horiz or vert) within their
-	  parent cell (could replace even-vert/even-horiz layouts)
 	* separate active panes for different clients
-
- terminfo bits
-	* use a better termcap internally instead of screen, perhaps xterm
-	* use screen-256color when started on 256 colour terminal?
+	* way to choose where the freed space goes when a pane is killed:
+	  option to kill-pane? GitHub issue 918

 - code cleanup
 	* instead of separate window and session options, just one master
 	  options list with each option having a type (window or session), then
 	  options on window, on session, and global. for window options we look
-	  window->session->global, and for session we look session->global
+	  window->session->global, and for session we look session->global.
+	  problem: what about windows in multiple sessions? there are contexts
+	  where we do not know which session, or where multiple choices makes
+	  no sense... could at least have one global list for all types of
+	  global options and keep separate window,session lists
 	* the way pane, window, session destroy is handled is too complicated
 	  and the distinction between session.c, window.c and server-fn.c
 	  functions is not clear. could we just have kill_pane(),
@@ -121,10 +94,8 @@
 	  or even guarantee that cmdq->c != NULL and provide a better way to
 	  tell when in the config file - then we use cmdq->c if we need a
 	  client w/o a session else cmd_current_client
-	* optimize pane redraws, 20120318184853.GK10965@yelena.nicm.ath.cx

 - miscellaneous
-	* way to keep a job running just read its last line of output for #()
 	* link panes into multiple windows
 	* live update: server started with -U connects to server, requests
 	  sessions and windows, receives file descriptors
@@ -133,7 +104,27 @@
 	  jobs and run-shell and lock command all start with slightly different
 	  environments
 	* multiline status line? separate command prompt and status line?
-	* customizable command aliases
 	* automatic pane logging
-	* BCE? We are halfway there (output side is done for pane backgrounds),
-	  just need to change how screen/grid handles erase
+	* marks in history, automatically add (move?) one when pane is changed
+	* this doesn't work, need pane reference count probably:
+	  bind -n DoubleClick3Status confirm-before -p "kill-window #I? (y/n)" kill-window
+	* respawn -c flag same as neww etc
+	* marker lines in history (GitHub issue 1042)
+	* tree mode stuff: predefined filters, tag-all key, ...
+
+- hooks
+	* more hooks for various things
+	* finish after hooks for special commands. these do not have a hook at
+          the moment:
+		 attach-session detach-client kill-server respawn-window
+		 swap-window break-pane find-window kill-session rotate-window
+		 switch-client choose-tree if-shell kill-window run-shell
+		 wait-for command-prompt join-pane move-window source-file
+		 confirm-before kill-pane respawn-pane swap-pane
+          at the moment AFTERHOOK uses current only if target is not valid,
+          but target is ALWAYS valid - it should use current if no -t flag?
+          then select-* could use AFTERHOOK
+	* multiple hooks with the same name?
+	* finish hooks for notifys
+	* for session_closed, if no sessions at all, perhaps fake up a
+          temporary one
--- a/alerts.c
+++ b/alerts.c
@@ -19,88 +19,84 @@
 #include <sys/types.h>

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

 #include "tmux.h"

-int	alerts_fired;
+static int	alerts_fired;

-void	alerts_timer(int, short, void *);
-int	alerts_enabled(struct window *, int);
-void	alerts_callback(int, short, void *);
-void	alerts_reset(struct window *);
+static void	alerts_timer(int, short, void *);
+static int	alerts_enabled(struct window *, int);
+static void	alerts_callback(int, short, void *);
+static void	alerts_reset(struct window *);

-void	alerts_run_hook(struct session *, struct winlink *, int);
-int	alerts_check_all(struct session *, struct winlink *);
-int	alerts_check_bell(struct session *, struct winlink *);
-int	alerts_check_activity(struct session *, struct winlink *);
-int	alerts_check_silence(struct session *, struct winlink *);
-void	alerts_ring_bell(struct session *);
+static int	alerts_action_applies(struct winlink *, const char *);
+static int	alerts_check_all(struct window *);
+static int	alerts_check_bell(struct window *);
+static int	alerts_check_activity(struct window *);
+static int	alerts_check_silence(struct window *);
+static void	alerts_set_message(struct winlink *, const char *,
+		    const char *);

-void
+static TAILQ_HEAD(, window) alerts_list = TAILQ_HEAD_INITIALIZER(alerts_list);
+
+static void
 alerts_timer(__unused int fd, __unused short events, void *arg)
 {
 	struct window	*w = arg;

 	log_debug("@%u alerts timer expired", w->id);
-	alerts_reset(w);
 	alerts_queue(w, WINDOW_SILENCE);
 }

-void
+static void
 alerts_callback(__unused int fd, __unused short events, __unused void *arg)
 {
-	struct window	*w;
-	struct session	*s;
-	struct winlink	*wl;
-	int		 flags, alerts;
+	struct window	*w, *w1;
+	int		 alerts;

-	RB_FOREACH(w, windows, &windows) {
-		RB_FOREACH(s, sessions, &sessions) {
-			RB_FOREACH(wl, winlinks, &s->windows) {
-				if (wl->window != w)
-					continue;
-				flags = w->flags;
+	TAILQ_FOREACH_SAFE(w, &alerts_list, alerts_entry, w1) {
+		alerts = alerts_check_all(w);
+		log_debug("@%u alerts check, alerts %#x", w->id, alerts);

-				alerts = alerts_check_all(s, wl);
+		w->alerts_queued = 0;
+		TAILQ_REMOVE(&alerts_list, w, alerts_entry);

-				log_debug("%s:%d @%u alerts check, alerts %#x, "
-				    "flags %#x", s->name, wl->idx, w->id,
-				    alerts, flags);
-			}
-		}
+		w->flags &= ~WINDOW_ALERTFLAGS;
+		window_remove_ref(w, __func__);
 	}
 	alerts_fired = 0;
 }

-void
-alerts_run_hook(struct session *s, struct winlink *wl, int flags)
+static int
+alerts_action_applies(struct winlink *wl, const char *name)
 {
-	struct cmd_find_state	 fs;
+	int	action;

-	if (cmd_find_from_winlink(&fs, s, wl) != 0)
-		return;
+	/*
+	 * {bell,activity,silence}-action determines when to alert: none means
+	 * nothing happens, current means only do something for the current
+	 * window and other means only for windows other than the current.
+	 */

-	if (flags & WINDOW_BELL)
-		hooks_run(s->hooks, NULL, &fs, "alert-bell");
-	if (flags & WINDOW_SILENCE)
-		hooks_run(s->hooks, NULL, &fs, "alert-silence");
-	if (flags & WINDOW_ACTIVITY)
-		hooks_run(s->hooks, NULL, &fs, "alert-activity");
+	action = options_get_number(wl->session->options, name);
+	if (action == ALERT_ANY)
+		return (1);
+	if (action == ALERT_CURRENT)
+		return (wl == wl->session->curw);
+	if (action == ALERT_OTHER)
+		return (wl != wl->session->curw);
+	return (0);
 }

-int
-alerts_check_all(struct session *s, struct winlink *wl)
+static int
+alerts_check_all(struct window *w)
 {
 	int	alerts;

-	alerts  = alerts_check_bell(s, wl);
-	alerts |= alerts_check_activity(s, wl);
-	alerts |= alerts_check_silence(s, wl);
-	if (alerts != 0) {
-		alerts_run_hook(s, wl, alerts);
-		server_status_session(s);
-	}
-
+	alerts	= alerts_check_bell(w);
+	alerts |= alerts_check_activity(w);
+	alerts |= alerts_check_silence(w);
 	return (alerts);
 }

@@ -110,14 +106,16 @@ alerts_check_session(struct session *s)
 	struct winlink	*wl;

 	RB_FOREACH(wl, winlinks, &s->windows)
-		alerts_check_all(s, wl);
+		alerts_check_all(wl->window);
 }

-int
+static int
 alerts_enabled(struct window *w, int flags)
 {
-	if (flags & WINDOW_BELL)
-		return (1);
+	if (flags & WINDOW_BELL) {
+		if (options_get_number(w->options, "monitor-bell"))
+			return (1);
+	}
 	if (flags & WINDOW_ACTIVITY) {
 		if (options_get_number(w->options, "monitor-activity"))
 			return (1);
@@ -138,11 +136,14 @@ alerts_reset_all(void)
 		alerts_reset(w);
 }

-void
+static void
 alerts_reset(struct window *w)
 {
 	struct timeval	tv;

+	if (!event_initialized(&w->alerts_timer))
+		evtimer_set(&w->alerts_timer, alerts_timer, w);
+
 	w->flags &= ~WINDOW_SILENCE;
 	event_del(&w->alerts_timer);

@@ -157,17 +158,21 @@ alerts_reset(struct window *w)
 void
 alerts_queue(struct window *w, int flags)
 {
-	if (w->flags & WINDOW_ACTIVITY)
-		alerts_reset(w);
+	alerts_reset(w);

-	if (!event_initialized(&w->alerts_timer))
-		evtimer_set(&w->alerts_timer, alerts_timer, w);
-
-	if (!alerts_fired) {
+	if ((w->flags & flags) != flags) {
 		w->flags |= flags;
 		log_debug("@%u alerts flags added %#x", w->id, flags);
+	}

-		if (alerts_enabled(w, flags)) {
+	if (alerts_enabled(w, flags)) {
+		if (!w->alerts_queued) {
+			w->alerts_queued = 1;
+			TAILQ_INSERT_TAIL(&alerts_list, w, alerts_entry);
+			window_add_ref(w, __func__);
+		}
+
+		if (!alerts_fired) {
 			log_debug("alerts check queued (by @%u)", w->id);
 			event_once(-1, EV_TIMEOUT, alerts_callback, NULL, NULL);
 			alerts_fired = 1;
@@ -175,120 +180,138 @@ alerts_queue(struct window *w, int flags)
 	}
 }

-int
-alerts_check_bell(struct session *s, struct winlink *wl)
+static int
+alerts_check_bell(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
-	int		 action, visual;
+	struct winlink	*wl;
+	struct session	*s;

-	if (!(w->flags & WINDOW_BELL))
+	if (~w->flags & WINDOW_BELL)
 		return (0);
-	if (s->curw != wl) {
-		wl->flags |= WINLINK_BELL;
-		w->flags &= ~WINDOW_BELL;
-	}
-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_BELL;
-
-	action = options_get_number(s->options, "bell-action");
-	if (action == BELL_NONE)
+	if (!options_get_number(w->options, "monitor-bell"))
 		return (0);

-	visual = options_get_number(s->options, "visual-bell");
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session != s || c->flags & CLIENT_CONTROL)
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;
+
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		/*
+		 * Bells are allowed even if there is an existing bell (so do
+		 * not check WINLINK_BELL).
+		 */
+		s = wl->session;
+		if (s->curw != wl)
+			wl->flags |= WINLINK_BELL;
+		if (!alerts_action_applies(wl, "bell-action"))
 			continue;
-		if (!visual) {
-			if ((action == BELL_CURRENT &&
-			    c->session->curw->window == w) ||
-			    (action == BELL_OTHER &&
-			    c->session->curw->window != w) ||
-			    action == BELL_ANY)
-				tty_putcode(&c->tty, TTYC_BEL);
+		notify_winlink("alert-bell", wl);
+
+		if (s->flags & SESSION_ALERTED)
 			continue;
-		}
-		if (action == BELL_CURRENT && c->session->curw->window == w)
-			status_message_set(c, "Bell in current window");
-		else if (action == BELL_ANY || (action == BELL_OTHER &&
-		    c->session->curw->window != w))
-			status_message_set(c, "Bell in window %d", wl->idx);
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Bell", "visual-bell");
 	}

 	return (WINDOW_BELL);
 }

-int
-alerts_check_activity(struct session *s, struct winlink *wl)
+static int
+alerts_check_activity(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
+	struct winlink	*wl;
+	struct session	*s;

-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_ACTIVITY;
-
-	if (!(w->flags & WINDOW_ACTIVITY) || wl->flags & WINLINK_ACTIVITY)
+	if (~w->flags & WINDOW_ACTIVITY)
 		return (0);
-	if (s->curw == wl)
-		return (0);
-
 	if (!options_get_number(w->options, "monitor-activity"))
 		return (0);

-	if (options_get_number(s->options, "bell-on-alert"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_ACTIVITY;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;

-	if (options_get_number(s->options, "visual-activity")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Activity in window %d", wl->idx);
-		}
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_ACTIVITY)
+			continue;
+		s = wl->session;
+		if (s->curw != wl)
+			wl->flags |= WINLINK_ACTIVITY;
+		if (!alerts_action_applies(wl, "activity-action"))
+			continue;
+		notify_winlink("alert-activity", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Activity", "visual-activity");
 	}

 	return (WINDOW_ACTIVITY);
 }

-int
-alerts_check_silence(struct session *s, struct winlink *wl)
+static int
+alerts_check_silence(struct window *w)
 {
-	struct client	*c;
-	struct window	*w = wl->window;
+	struct winlink	*wl;
+	struct session	*s;

-	if (s->curw->window == w)
-		w->flags &= ~WINDOW_SILENCE;
-
-	if (!(w->flags & WINDOW_SILENCE) || wl->flags & WINLINK_SILENCE)
+	if (~w->flags & WINDOW_SILENCE)
 		return (0);
-	if (s->curw == wl)
-		return (0);
-
 	if (options_get_number(w->options, "monitor-silence") == 0)
 		return (0);

-	if (options_get_number(s->options, "bell-on-alert"))
-		alerts_ring_bell(s);
-	wl->flags |= WINLINK_SILENCE;
+	TAILQ_FOREACH(wl, &w->winlinks, wentry)
+		wl->session->flags &= ~SESSION_ALERTED;

-	if (options_get_number(s->options, "visual-silence")) {
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			status_message_set(c, "Silence in window %d", wl->idx);
-		}
+	TAILQ_FOREACH(wl, &w->winlinks, wentry) {
+		if (wl->flags & WINLINK_SILENCE)
+			continue;
+		s = wl->session;
+		if (s->curw != wl)
+			wl->flags |= WINLINK_SILENCE;
+		if (!alerts_action_applies(wl, "silence-action"))
+			continue;
+		notify_winlink("alert-silence", wl);
+
+		if (s->flags & SESSION_ALERTED)
+			continue;
+		s->flags |= SESSION_ALERTED;
+
+		alerts_set_message(wl, "Silence", "visual-silence");
 	}

 	return (WINDOW_SILENCE);
 }

-void
-alerts_ring_bell(struct session *s)
+static void
+alerts_set_message(struct winlink *wl, const char *type, const char *option)
 {
 	struct client	*c;
+	int		 visual;

+	/*
+	 * We have found an alert (bell, activity or silence), so we need to
+	 * pass it on to the user. For each client attached to this session,
+	 * decide whether a bell, message or both is needed.
+	 *
+	 * If visual-{bell,activity,silence} is on, then a message is
+	 * substituted for a bell; if it is off, a bell is sent as normal; both
+	 * mean both a bell and message is sent.
+	 */
+
+	visual = options_get_number(wl->session->options, option);
 	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session == s && !(c->flags & CLIENT_CONTROL))
+		if (c->session != wl->session || c->flags & CLIENT_CONTROL)
+			continue;
+
+		if (visual == VISUAL_OFF || visual == VISUAL_BOTH)
 			tty_putcode(&c->tty, TTYC_BEL);
+		if (visual == VISUAL_OFF)
+			continue;
+		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
@@ -34,43 +34,20 @@ struct args_entry {
 	RB_ENTRY(args_entry)	 entry;
 };

-struct args_entry	*args_find(struct args *, u_char);
+static struct args_entry	*args_find(struct args *, u_char);

-RB_GENERATE(args_tree, args_entry, entry, args_cmp);
+static int	args_cmp(struct args_entry *, struct args_entry *);
+RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp);

 /* Arguments tree comparison function. */
-int
+static int
 args_cmp(struct args_entry *a1, struct args_entry *a2)
 {
 	return (a1->flag - a2->flag);
 }

-/* Create an arguments set with no flags. */
-struct args *
-args_create(int argc, ...)
-{
-	struct args	*args;
-	va_list		 ap;
-	int		 i;
-
-	args = xcalloc(1, sizeof *args);
-
-	args->argc = argc;
-	if (argc == 0)
-		args->argv = NULL;
-	else
-		args->argv = xcalloc(argc, sizeof *args->argv);
-
-	va_start(ap, argc);
-	for (i = 0; i < argc; i++)
-		args->argv[i] = xstrdup(va_arg(ap, char *));
-	va_end(ap);
-
-	return (args);
-}
-
 /* Find a flag in the arguments tree. */
-struct args_entry *
+static struct args_entry *
 args_find(struct args *args, u_char ch)
 {
 	struct args_entry	entry;
@@ -151,9 +128,10 @@ char *
 args_print(struct args *args)
 {
 	size_t		 	 len;
-	char			*buf;
-	int			 i;
+	char			*buf, *escaped;
+	int			 i, flags;
 	struct args_entry	*entry;
+	static const char	 quoted[] = " #\"';$";

 	len = 1;
 	buf = xcalloc(1, len);
@@ -177,20 +155,32 @@ args_print(struct args *args)
 			args_print_add(&buf, &len, " -%c ", entry->flag);
 		else
 			args_print_add(&buf, &len, "-%c ", entry->flag);
-		if (strchr(entry->value, ' ') != NULL)
-			args_print_add(&buf, &len, "\"%s\"", entry->value);
+
+		flags = VIS_OCTAL|VIS_TAB|VIS_NL;
+		if (entry->value[strcspn(entry->value, quoted)] != '\0')
+			flags |= VIS_DQ;
+		utf8_stravis(&escaped, entry->value, flags);
+		if (flags & VIS_DQ)
+			args_print_add(&buf, &len, "\"%s\"", escaped);
 		else
-			args_print_add(&buf, &len, "%s", entry->value);
+			args_print_add(&buf, &len, "%s", escaped);
+		free(escaped);
 	}

 	/* And finally the argument vector. */
 	for (i = 0; i < args->argc; i++) {
 		if (*buf != '\0')
 			args_print_add(&buf, &len, " ");
-		if (strchr(args->argv[i], ' ') != NULL)
-			args_print_add(&buf, &len, "\"%s\"", args->argv[i]);
+
+		flags = VIS_OCTAL|VIS_TAB|VIS_NL;
+		if (args->argv[i][strcspn(args->argv[i], quoted)] != '\0')
+			flags |= VIS_DQ;
+		utf8_stravis(&escaped, args->argv[i], flags);
+		if (flags & VIS_DQ)
+			args_print_add(&buf, &len, "\"%s\"", escaped);
 		else
-			args_print_add(&buf, &len, "%s", args->argv[i]);
+			args_print_add(&buf, &len, "%s", escaped);
+		free(escaped);
 	}

 	return (buf);
@@ -200,7 +190,7 @@ args_print(struct args *args)
 int
 args_has(struct args *args, u_char ch)
 {
-	return (args_find(args, ch) == NULL ? 0 : 1);
+	return (args_find(args, ch) != NULL);
 }

 /* Set argument value in the arguments tree. */
--- a/array.h
+++ b/array.h
@@ -1,120 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2006 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.
- */
-
-#ifndef ARRAY_H
-#define ARRAY_H
-
-#define ARRAY_INITIALIZER { NULL, 0, 0 }
-
-#define ARRAY_DECL(n, c)						\
-	struct n {							\
-		c	*list;						\
-		u_int	 num;						\
-		size_t	 space;						\
-	}
-
-#define ARRAY_ITEM(a, i) ((a)->list[i])
-#define ARRAY_ITEMSIZE(a) (sizeof *(a)->list)
-#define ARRAY_INITIALSPACE(a) (10 * ARRAY_ITEMSIZE(a))
-
-#define ARRAY_ENSURE(a, n) do {						\
-	if (UINT_MAX - (n) < (a)->num)					\
-		fatalx("number too big");				\
-	if (SIZE_MAX / ((a)->num + (n)) < ARRAY_ITEMSIZE(a))		\
-		fatalx("size too big");					\
-	if ((a)->space == 0) {						\
-	       	(a)->space = ARRAY_INITIALSPACE(a);			\
-		(a)->list = xrealloc((a)->list, (a)->space);		\
-	}								\
-	while ((a)->space <= ((a)->num + (n)) * ARRAY_ITEMSIZE(a)) {	\
-		(a)->list = xreallocarray((a)->list, 2, (a)->space);	\
-		(a)->space *= 2;					\
-	}								\
-} while (0)
-
-#define ARRAY_EMPTY(a) (((void *) (a)) == NULL || (a)->num == 0)
-#define ARRAY_LENGTH(a) ((a)->num)
-#define ARRAY_DATA(a) ((a)->list)
-
-#define ARRAY_FIRST(a) ARRAY_ITEM(a, 0)
-#define ARRAY_LAST(a) ARRAY_ITEM(a, (a)->num - 1)
-
-#define ARRAY_INIT(a) do {						\
-	(a)->num = 0;							\
-	(a)->list = NULL;		 				\
-	(a)->space = 0;							\
-} while (0)
-#define ARRAY_CLEAR(a) do {						\
-	(a)->num = 0;							\
-} while (0)
-
-#define ARRAY_SET(a, i, s) do {						\
-	(a)->list[i] = s;						\
-} while (0)
-
-#define ARRAY_ADD(a, s) do {						\
-	ARRAY_ENSURE(a, 1);						\
-	(a)->list[(a)->num] = s;					\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_INSERT(a, i, s) do {					\
-	ARRAY_ENSURE(a, 1);						\
-	if ((i) < (a)->num) {						\
-		memmove((a)->list + (i) + 1, (a)->list + (i), 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i)));		\
-	}								\
-	(a)->list[i] = s;						\
-	(a)->num++;							\
-} while (0)
-#define ARRAY_REMOVE(a, i) do {						\
-	if ((i) < (a)->num - 1) {					\
-		memmove((a)->list + (i), (a)->list + (i) + 1, 		\
-		    ARRAY_ITEMSIZE(a) * ((a)->num - (i) - 1));		\
-	}								\
-	(a)->num--;							\
-	if ((a)->num == 0)						\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_EXPAND(a, n) do {						\
-	ARRAY_ENSURE(a, n);						\
-	(a)->num += n;							\
-} while (0)
-#define ARRAY_TRUNC(a, n) do {						\
-	if ((a)->num > n)						\
-		(a)->num -= n;				       		\
-	else								\
-		ARRAY_FREE(a);						\
-} while (0)
-
-#define ARRAY_CONCAT(a, b) do {						\
-	ARRAY_ENSURE(a, (b)->num);					\
-	memcpy((a)->list + (a)->num, (b)->list, (b)->num * ARRAY_ITEMSIZE(a)); \
-	(a)->num += (b)->num;						\
-} while (0)
-
-#define ARRAY_FREE(a) do {						\
-	free((a)->list);						\
-	ARRAY_INIT(a);							\
-} while (0)
-#define ARRAY_FREEALL(a) do {						\
-	ARRAY_FREE(a);							\
-	free(a);							\
-} while (0)
-
-#endif
--- a/attributes.c
+++ b/attributes.c
@@ -23,7 +23,7 @@
 #include "tmux.h"

 const char *
-attributes_tostring(u_char attr)
+attributes_tostring(int attr)
 {
 	static char	buf[128];
 	size_t		len;
@@ -31,14 +31,15 @@ attributes_tostring(u_char attr)
 	if (attr == 0)
 		return ("none");

-	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s",
-		attr & GRID_ATTR_BRIGHT ? "bright," : "",
-		attr & GRID_ATTR_DIM ? "dim," : "",
-		attr & GRID_ATTR_UNDERSCORE ? "underscore," : "",
-		attr & GRID_ATTR_BLINK ? "blink," : "",
-		attr & GRID_ATTR_REVERSE ? "reverse," : "",
-		attr & GRID_ATTR_HIDDEN ? "hidden," : "",
-		attr & GRID_ATTR_ITALICS ? "italics," : "");
+	len = xsnprintf(buf, sizeof buf, "%s%s%s%s%s%s%s%s",
+	    (attr & GRID_ATTR_BRIGHT) ? "bright," : "",
+	    (attr & GRID_ATTR_DIM) ? "dim," : "",
+	    (attr & GRID_ATTR_UNDERSCORE) ? "underscore," : "",
+	    (attr & GRID_ATTR_BLINK)? "blink," : "",
+	    (attr & GRID_ATTR_REVERSE) ? "reverse," : "",
+	    (attr & GRID_ATTR_HIDDEN) ? "hidden," : "",
+	    (attr & GRID_ATTR_ITALICS) ? "italics," : "",
+	    (attr & GRID_ATTR_STRIKETHROUGH) ? "strikethrough," : "");
 	if (len > 0)
 		buf[len - 1] = '\0';

@@ -49,7 +50,7 @@ int
 attributes_fromstring(const char *str)
 {
 	const char	delimiters[] = " ,|";
-	u_char		attr;
+	int		attr;
 	size_t		end;

 	if (*str == '\0' || strcspn(str, delimiters) == 0)
@@ -78,6 +79,8 @@ attributes_fromstring(const char *str)
 			attr |= GRID_ATTR_HIDDEN;
 		else if (end == 7 && strncasecmp(str, "italics", end) == 0)
 			attr |= GRID_ATTR_ITALICS;
+		else if (end == 13 && strncasecmp(str, "strikethrough", end) == 0)
+			attr |= GRID_ATTR_STRIKETHROUGH;
 		else
 			return (-1);
 		str += end + strspn(str + end, delimiters);
--- a/autogen.sh
+++ b/autogen.sh
@@ -1,8 +1,8 @@
 #!/bin/sh

 if [ "x$(uname)" = "xOpenBSD" ]; then
-	[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.10
-	[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.65
+	[ -z "$AUTOMAKE_VERSION" ] && export AUTOMAKE_VERSION=1.15
+	[ -z "$AUTOCONF_VERSION" ] && export AUTOCONF_VERSION=2.69
 fi

 die()
--- a/cfg.c
+++ b/cfg.c
@@ -23,19 +23,40 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>

 #include "tmux.h"

-char		 *cfg_file;
-struct cmd_q	 *cfg_cmd_q;
-int		  cfg_finished;
-int		  cfg_references;
-char		**cfg_causes;
-u_int		  cfg_ncauses;
-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;

-void	cfg_default_done(struct cmd_q *);
+static enum cmd_retval
+cfg_client_done(__unused struct cmdq_item *item, __unused void *data)
+{
+	if (!cfg_finished)
+		return (CMD_RETURN_WAIT);
+	return (CMD_RETURN_NORMAL);
+}
+
+static enum cmd_retval
+cfg_done(__unused struct cmdq_item *item, __unused void *data)
+{
+	if (cfg_finished)
+		return (CMD_RETURN_NORMAL);
+	cfg_finished = 1;
+
+	if (!RB_EMPTY(&sessions))
+		cfg_show_causes(RB_MIN(sessions, &sessions));
+
+	if (cfg_item != NULL)
+		cfg_item->flags &= ~CMDQ_WAITING;
+
+	status_prompt_load_history();
+
+	return (CMD_RETURN_NORMAL);
+}

 void
 set_cfg_file(const char *path)
@@ -47,70 +68,105 @@ set_cfg_file(const char *path)
 void
 start_cfg(void)
 {
-	char		*cause = NULL;
 	const char	*home;
+	int		 quiet = 0;
+	struct client	*c;

-	cfg_cmd_q = cmdq_new(NULL);
-	cfg_cmd_q->emptyfn = cfg_default_done;
+	/*
+	 * Configuration files are loaded without a client, so NULL is passed
+	 * into load_cfg() and commands run in the global queue with
+	 * item->client NULL.
+	 *
+	 * However, we must block the initial client (but just the initial
+	 * client) so that its command runs after the configuration is loaded.
+	 * Because start_cfg() is called so early, we can be sure the client's
+	 * command queue is currently empty and our callback will be at the
+	 * front - we need to get in before MSG_COMMAND.
+	 */
+	c = TAILQ_FIRST(&clients);
+	if (c != NULL) {
+		cfg_item = cmdq_get_callback(cfg_client_done, NULL);
+		cmdq_append(c, cfg_item);
+	}

-	cfg_finished = 0;
-	cfg_references = 1;
-
-	cfg_client = TAILQ_FIRST(&clients);
-	if (cfg_client != NULL)
-		cfg_client->references++;
-
-	if (access(TMUX_CONF, R_OK) == 0) {
-		if (load_cfg(TMUX_CONF, cfg_cmd_q, &cause) == -1)
-			cfg_add_cause("%s: %s", TMUX_CONF, cause);
-	} else if (errno != ENOENT)
-		cfg_add_cause("%s: %s", TMUX_CONF, strerror(errno));
+	load_cfg(TMUX_CONF, NULL, NULL, 1);

 	if (cfg_file == NULL && (home = find_home()) != NULL) {
 		xasprintf(&cfg_file, "%s/.tmux.conf", home);
-		if (access(cfg_file, R_OK) != 0 && errno == ENOENT) {
-			free(cfg_file);
-			cfg_file = NULL;
-		}
+		quiet = 1;
 	}
-	if (cfg_file != NULL && load_cfg(cfg_file, cfg_cmd_q, &cause) == -1)
-		cfg_add_cause("%s: %s", cfg_file, cause);
-	free(cause);
+	if (cfg_file != NULL)
+		load_cfg(cfg_file, NULL, NULL, quiet);

-	cmdq_continue(cfg_cmd_q);
+	cmdq_append(NULL, cmdq_get_callback(cfg_done, NULL));
 }

 int
-load_cfg(const char *path, struct cmd_q *cmdq, char **cause)
+load_cfg(const char *path, struct client *c, struct cmdq_item *item, int quiet)
 {
-	FILE		*f;
-	char		 delim[3] = { '\\', '\\', '\0' };
-	u_int		 found;
-	size_t		 line = 0;
-	char		*buf, *cause1, *p;
-	struct cmd_list	*cmdlist;
+	FILE			*f;
+	const char		 delim[3] = { '\\', '\\', '\0' };
+	u_int			 found = 0;
+	size_t			 line = 0;
+	char			*buf, *cause1, *p, *q, *s;
+	struct cmd_list		*cmdlist;
+	struct cmdq_item	*new_item;
+	int			 condition = 0;
+	struct format_tree	*ft;

 	log_debug("loading %s", path);
 	if ((f = fopen(path, "rb")) == NULL) {
-		xasprintf(cause, "%s: %s", path, strerror(errno));
+		if (errno == ENOENT && quiet)
+			return (0);
+		cfg_add_cause("%s: %s", path, strerror(errno));
 		return (-1);
 	}

-	found = 0;
 	while ((buf = fparseln(f, NULL, &line, delim, 0)) != NULL) {
 		log_debug("%s: %s", path, buf);

-		/* Skip empty lines. */
 		p = buf;
-		while (isspace((u_char) *p))
+		while (isspace((u_char)*p))
 			p++;
 		if (*p == '\0') {
 			free(buf);
 			continue;
 		}
+		q = p + strlen(p) - 1;
+		while (q != p && isspace((u_char)*q))
+			*q-- = '\0';

-		/* Parse and run the command. */
-		if (cmd_string_parse(p, &cmdlist, path, line, &cause1) != 0) {
+		if (condition != 0 && strcmp(p, "%endif") == 0) {
+			condition = 0;
+			continue;
+		}
+		if (strncmp(p, "%if ", 4) == 0) {
+			if (condition != 0) {
+				cfg_add_cause("%s:%zu: nested %%if", path,
+				    line);
+				continue;
+			}
+			ft = format_create(NULL, NULL, FORMAT_NONE,
+			    FORMAT_NOJOBS);
+
+			s = p + 3;
+			while (isspace((u_char)*s))
+				s++;
+			s = format_expand(ft, s);
+			if (*s != '\0' && (s[0] != '0' || s[1] != '\0'))
+				condition = 1;
+			else
+				condition = -1;
+			free(s);
+
+			format_free(ft);
+			continue;
+		}
+		if (condition == -1)
+			continue;
+
+		cmdlist = cmd_string_parse(p, path, line, &cause1);
+		if (cmdlist == NULL) {
 			free(buf);
 			if (cause1 == NULL)
 				continue;
@@ -122,8 +178,13 @@ load_cfg(const char *path, struct cmd_q *cmdq, char **cause)

 		if (cmdlist == NULL)
 			continue;
-		cmdq_append(cmdq, cmdlist, NULL);
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		if (item != NULL)
+			cmdq_insert_after(item, new_item);
+		else
+			cmdq_append(c, new_item);
 		cmd_list_free(cmdlist);
+
 		found++;
 	}
 	fclose(f);
@@ -131,34 +192,6 @@ load_cfg(const char *path, struct cmd_q *cmdq, char **cause)
 	return (found);
 }

-void
-cfg_default_done(__unused struct cmd_q *cmdq)
-{
-	if (--cfg_references != 0)
-		return;
-	cfg_finished = 1;
-
-	if (!RB_EMPTY(&sessions))
-		cfg_show_causes(RB_MIN(sessions, &sessions));
-
-	cmdq_free(cfg_cmd_q);
-	cfg_cmd_q = NULL;
-
-	if (cfg_client != NULL) {
-		/*
-		 * The client command queue starts with client_exit set to 1 so
-		 * only continue if not empty (that is, we have been delayed
-		 * during configuration parsing for long enough that the
-		 * MSG_COMMAND has arrived), else the client will exit before
-		 * the MSG_COMMAND which might tell it not to.
-		 */
-		if (!TAILQ_EMPTY(&cfg_client->cmdq->queue))
-			cmdq_continue(cfg_client->cmdq);
-		server_client_unref(cfg_client);
-		cfg_client = NULL;
-	}
-}
-
 void
 cfg_add_cause(const char *fmt, ...)
 {
@@ -175,12 +208,12 @@ cfg_add_cause(const char *fmt, ...)
 }

 void
-cfg_print_causes(struct cmd_q *cmdq)
+cfg_print_causes(struct cmdq_item *item)
 {
 	u_int	 i;

 	for (i = 0; i < cfg_ncauses; i++) {
-		cmdq_print(cmdq, "%s", cfg_causes[i]);
+		cmdq_print(item, "%s", cfg_causes[i]);
 		free(cfg_causes[i]);
 	}

@@ -199,7 +232,7 @@ cfg_show_causes(struct session *s)
 		return;
 	wp = s->curw->window->active;

-	window_pane_set_mode(wp, &window_copy_mode);
+	window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
 	window_copy_init_for_output(wp);
 	for (i = 0; i < cfg_ncauses; i++) {
 		window_copy_add(wp, "%s", cfg_causes[i]);
--- a/client.c
+++ b/client.c
@@ -33,11 +33,11 @@

 #include "tmux.h"

-struct tmuxproc	*client_proc;
-struct tmuxpeer	*client_peer;
-int		 client_flags;
-struct event	 client_stdin;
-enum {
+static struct tmuxproc	*client_proc;
+static struct tmuxpeer	*client_peer;
+static int		 client_flags;
+static struct event	 client_stdin;
+static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
 	CLIENT_EXIT_DETACHED_HUP,
@@ -47,29 +47,31 @@ enum {
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
 } client_exitreason = CLIENT_EXIT_NONE;
-int		 client_exitval;
-enum msgtype	 client_exittype;
-const char	*client_exitsession;
-int		 client_attached;
+static int		 client_exitval;
+static enum msgtype	 client_exittype;
+static const char	*client_exitsession;
+static const char	*client_execshell;
+static const char	*client_execcmd;
+static int		 client_attached;

-__dead void	client_exec(const char *,const char *);
-int		client_get_lock(char *);
-int		client_connect(struct event_base *, const char *, int);
-void		client_send_identify(const char *, const char *);
-void		client_stdin_callback(int, short, void *);
-void		client_write(int, const char *, size_t);
-void		client_signal(int);
-void		client_dispatch(struct imsg *, void *);
-void		client_dispatch_attached(struct imsg *);
-void		client_dispatch_wait(struct imsg *, const char *);
-const char     *client_exit_message(void);
+static __dead void	 client_exec(const char *,const char *);
+static int		 client_get_lock(char *);
+static int		 client_connect(struct event_base *, const char *, int);
+static void		 client_send_identify(const char *, const char *);
+static void		 client_stdin_callback(int, short, void *);
+static void		 client_write(int, const char *, size_t);
+static void		 client_signal(int);
+static void		 client_dispatch(struct imsg *, void *);
+static void		 client_dispatch_attached(struct imsg *);
+static void		 client_dispatch_wait(struct imsg *);
+static const char	*client_exit_message(void);

 /*
 * Get server create lock. If already held then server start is happening in
 * another client, so block until the lock is released and return -2 to
 * retry. Return -1 on failure to continue and start the server anyway.
 */
-int
+static int
 client_get_lock(char *lockfile)
 {
 	int lockfd;
@@ -96,7 +98,7 @@ client_get_lock(char *lockfile)
 }

 /* Connect client to server. */
-int
+static int
 client_connect(struct event_base *base, const char *path, int start_server)
 {
 	struct sockaddr_un	sa;
@@ -154,7 +156,7 @@ retry:
 			close(lockfd);
 			return (-1);
 		}
-		fd = server_start(base, lockfd, lockfile);
+		fd = server_start(client_proc, base, lockfd, lockfile);
 	}

 	if (locked && lockfd >= 0) {
@@ -212,8 +214,7 @@ client_exit_message(void)

 /* Client main loop. */
 int
-client_main(struct event_base *base, int argc, char **argv, int flags,
-    const char *shellcmd)
+client_main(struct event_base *base, int argc, char **argv, int flags)
 {
 	struct cmd		*cmd;
 	struct cmd_list		*cmdlist;
@@ -234,7 +235,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags,

 	/* Set up the initial command. */
 	cmdflags = 0;
-	if (shellcmd != NULL) {
+	if (shell_command != NULL) {
 		msg = MSG_SHELL;
 		cmdflags = CMD_STARTSERVER;
 	} else if (argc == 0) {
@@ -249,20 +250,18 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		 * flag.
 		 */
 		cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause);
-		if (cmdlist == NULL) {
-			fprintf(stderr, "%s\n", cause);
-			return (1);
+		if (cmdlist != NULL) {
+			TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+				if (cmd->entry->flags & CMD_STARTSERVER)
+					cmdflags |= CMD_STARTSERVER;
+			}
+			cmd_list_free(cmdlist);
 		}
-		cmdflags &= ~CMD_STARTSERVER;
-		TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
-			if (cmd->entry->flags & CMD_STARTSERVER)
-				cmdflags |= CMD_STARTSERVER;
-		}
-		cmd_list_free(cmdlist);
 	}

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

 	/* Initialize the client socket and start the server. */
 	fd = client_connect(base, socket_path, cmdflags & CMD_STARTSERVER);
@@ -276,8 +275,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 		}
 		return (1);
 	}
-	client_peer = proc_add_peer(client_proc, fd, client_dispatch,
-	    (void *)shellcmd);
+	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);

 	/* Save these before pledge(). */
 	if ((cwd = getcwd(path, sizeof path)) == NULL) {
@@ -287,7 +285,6 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";

-#ifdef __OpenBSD__
 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
 	 * locking (which uses system(3)).
@@ -299,9 +296,10 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	 */
 	if (pledge("stdio unix sendfd proc exec tty", NULL) != 0)
 		fatal("pledge failed");
-#endif

 	/* Free stuff that is not used in the client. */
+	if (ptm_fd != -1)
+		close(ptm_fd);
 	options_free(global_options);
 	options_free(global_s_options);
 	options_free(global_w_options);
@@ -312,8 +310,11 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
 	    client_stdin_callback, NULL);
 	if (client_flags & CLIENT_CONTROLCONTROL) {
-		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0)
-			fatal("tcgetattr failed");
+		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
+			fprintf(stderr, "tcgetattr failed: %s\n",
+			    strerror(errno));
+			return (1);
+		}
 		cfmakeraw(&tio);
 		tio.c_iflag = ICRNL|IXANY;
 		tio.c_oflag = OPOST|ONLCR;
@@ -361,6 +362,13 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 	/* Start main loop. */
 	proc_loop(client_proc, NULL);

+	/* Run command if user requested exec, instead of exiting. */
+	if (client_exittype == MSG_EXEC) {
+		if (client_flags & CLIENT_CONTROLCONTROL)
+			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
+		client_exec(client_execshell, client_execcmd);
+	}
+
 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
@@ -383,7 +391,7 @@ client_main(struct event_base *base, int argc, char **argv, int flags,
 }

 /* Send identify messages to server. */
-void
+static void
 client_send_identify(const char *ttynam, const char *cwd)
 {
 	const char	 *s;
@@ -420,7 +428,7 @@ client_send_identify(const char *ttynam, const char *cwd)
 }

 /* Callback for client stdin read events. */
-void
+static void
 client_stdin_callback(__unused int fd, __unused short events,
    __unused void *arg)
 {
@@ -436,7 +444,7 @@ client_stdin_callback(__unused int fd, __unused short events,
 }

 /* Force write to file descriptor. */
-void
+static void
 client_write(int fd, const char *data, size_t size)
 {
 	ssize_t	used;
@@ -454,7 +462,7 @@ client_write(int fd, const char *data, size_t size)
 }

 /* Run command in shell; used for -c. */
-__dead void
+static __dead void
 client_exec(const char *shell, const char *shellcmd)
 {
 	const char	*name, *ptr;
@@ -473,6 +481,8 @@ client_exec(const char *shell, const char *shellcmd)
 		xasprintf(&argv0, "%s", name);
 	setenv("SHELL", shell, 1);

+	proc_clear_signals(client_proc, 1);
+
 	setblocking(STDIN_FILENO, 1);
 	setblocking(STDOUT_FILENO, 1);
 	setblocking(STDERR_FILENO, 1);
@@ -483,7 +493,7 @@ client_exec(const char *shell, const char *shellcmd)
 }

 /* Callback to handle signals in the client. */
-void
+static void
 client_signal(int sig)
 {
 	struct sigaction sigact;
@@ -523,8 +533,8 @@ client_signal(int sig)
 }

 /* Callback for client read events. */
-void
-client_dispatch(struct imsg *imsg, void *arg)
+static void
+client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
 		client_exitreason = CLIENT_EXIT_LOST_SERVER;
@@ -536,19 +546,18 @@ client_dispatch(struct imsg *imsg, void *arg)
 	if (client_attached)
 		client_dispatch_attached(imsg);
 	else
-		client_dispatch_wait(imsg, arg);
+		client_dispatch_wait(imsg);
 }

 /* Dispatch imsgs when in wait state (before MSG_READY). */
-void
-client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
+static void
+client_dispatch_wait(struct imsg *imsg)
 {
 	char			*data;
 	ssize_t			 datalen;
 	struct msg_stdout_data	 stdoutdata;
 	struct msg_stderr_data	 stderrdata;
 	int			 retval;
-#ifdef __OpenBSD__
 	static int		 pledge_applied;

 	/*
@@ -562,7 +571,6 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 			fatal("pledge failed");
 		pledge_applied = 1;
 	};
-#endif

 	data = imsg->data;
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
@@ -622,8 +630,7 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");

-		clear_signals(0);
-		client_exec(data, shellcmd);
+		client_exec(data, shell_command);
 		/* NOTREACHED */
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
@@ -636,7 +643,7 @@ client_dispatch_wait(struct imsg *imsg, const char *shellcmd)
 }

 /* Dispatch imsgs in attached state (after MSG_READY). */
-void
+static void
 client_dispatch_attached(struct imsg *imsg)
 {
 	struct sigaction	 sigact;
@@ -660,6 +667,16 @@ client_dispatch_attached(struct imsg *imsg)
 			client_exitreason = CLIENT_EXIT_DETACHED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
+	case MSG_EXEC:
+		if (datalen == 0 || data[datalen - 1] != '\0' ||
+		    strlen(data) + 1 == (size_t)datalen)
+			fatalx("bad MSG_EXEC string");
+		client_execcmd = xstrdup(data);
+		client_execshell = xstrdup(data + strlen(data) + 1);
+
+		client_exittype = imsg->hdr.type;
+		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
+		break;
 	case MSG_EXIT:
 		if (datalen != 0 && datalen != sizeof (int))
 			fatalx("bad MSG_EXIT size");
--- a/cmd-attach-session.c
+++ b/cmd-attach-session.c
@@ -30,7 +30,8 @@
 * Attach existing session to the current terminal.
 */

-enum cmd_retval	cmd_attach_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_attach_session_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_attach_session_entry = {
 	.name = "attach-session",
@@ -39,51 +40,64 @@ const struct cmd_entry cmd_attach_session_entry = {
 	.args = { "c:dErt:", 0, 0 },
 	.usage = "[-dEr] [-c working-directory] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION_WITHPANE,
+	/* -t is special */

 	.flags = CMD_STARTSERVER,
 	.exec = cmd_attach_session_exec
 };

 enum cmd_retval
-cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
-    int Eflag)
+cmd_attach_session(struct cmdq_item *item, const char *tflag, int dflag,
+    int rflag, const char *cflag, int Eflag)
 {
-	struct session		*s = cmdq->state.tflag.s;
-	struct client		*c = cmdq->client, *c_loop;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	const char		*update;
-	char			*cause, *cwd;
-	struct format_tree	*ft;
+	struct cmd_find_state	*current = &item->shared->current;
+	enum cmd_find_type	 type;
+	int			 flags;
+	struct client		*c = item->client, *c_loop;
+	struct session		*s;
+	struct winlink		*wl;
+	struct window_pane	*wp;
+	char			*cause;

 	if (RB_EMPTY(&sessions)) {
-		cmdq_error(cmdq, "no sessions");
+		cmdq_error(item, "no sessions");
 		return (CMD_RETURN_ERROR);
 	}

 	if (c == NULL)
 		return (CMD_RETURN_NORMAL);
 	if (server_client_check_nested(c)) {
-		cmdq_error(cmdq, "sessions should be nested with care, "
+		cmdq_error(item, "sessions should be nested with care, "
 		    "unset $TMUX to force");
 		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(&item->target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = item->target.s;
+	wl = item->target.wl;
+	wp = item->target.wp;
+
 	if (wl != NULL) {
 		if (wp != NULL)
 			window_set_active_pane(wp->window, wp);
 		session_set_current(s, wl);
+		if (wp != NULL)
+			cmd_find_from_winlink_pane(current, wl, wp, 0);
+		else
+			cmd_find_from_winlink(current, wl, 0);
 	}

 	if (cflag != NULL) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, wl, wp);
-		cwd = format_expand(ft, cflag);
-		format_free(ft);
-
 		free((void *)s->cwd);
-		s->cwd = cwd;
+		s->cwd = format_single(item, cflag, c, s, wl, wp);
 	}

 	if (c->session != NULL) {
@@ -94,28 +108,24 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
 				server_client_detach(c_loop, MSG_DETACH);
 			}
 		}
-
-		if (!Eflag) {
-			update = options_get_string(s->options,
-			    "update-environment");
-			environ_update(update, c->environ, s->environ);
-		}
+		if (!Eflag)
+			environ_update(s->options, c->environ, s->environ);

 		c->session = s;
-		server_client_set_key_table(c, NULL);
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
 		status_timer_start(c);
-		notify_attached_session_changed(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;
 	} else {
 		if (server_client_open(c, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
-
 		if (rflag)
 			c->flags |= CLIENT_READONLY;

@@ -126,17 +136,13 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
 				server_client_detach(c_loop, MSG_DETACH);
 			}
 		}
-
-		if (!Eflag) {
-			update = options_get_string(s->options,
-			    "update-environment");
-			environ_update(update, c->environ, s->environ);
-		}
+		if (!Eflag)
+			environ_update(s->options, c->environ, s->environ);

 		c->session = s;
 		server_client_set_key_table(c, NULL);
 		status_timer_start(c);
-		notify_attached_session_changed(c);
+		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
 		gettimeofday(&s->last_attached_time, NULL);
 		server_redraw_client(c);
@@ -144,8 +150,8 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,

 		if (~c->flags & CLIENT_CONTROL)
 			proc_send(c->peer, MSG_READY, -1, NULL, 0);
-		hooks_run(c->session->hooks, c, NULL, "client-attached");
-		cmdq->client_exit = 0;
+		notify_client("client-attached", c);
+		c->flags |= CLIENT_ATTACHED;
 	}
 	recalculate_sizes();
 	alerts_check_session(s);
@@ -154,11 +160,12 @@ cmd_attach_session(struct cmd_q *cmdq, int dflag, int rflag, const char *cflag,
 	return (CMD_RETURN_NORMAL);
 }

-enum cmd_retval
-cmd_attach_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_attach_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;

-	return (cmd_attach_session(cmdq, args_has(args, 'd'),
-	    args_has(args, 'r'), args_get(args, 'c'), args_has(args, 'E')));
+	return (cmd_attach_session(item, args_get(args, 't'),
+	    args_has(args, 'd'), args_has(args, 'r'), args_get(args, 'c'),
+	    args_has(args, 'E')));
 }
--- a/cmd-bind-key.c
+++ b/cmd-bind-key.c
@@ -24,28 +24,25 @@
 #include "tmux.h"

 /*
- * Bind a key to a command, this recurses through cmd_*.
+ * Bind a key to a command.
 */

-enum cmd_retval	 cmd_bind_key_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 cmd_bind_key_mode_table(struct cmd *, struct cmd_q *,
-		     key_code);
+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 = { "cnrt:T:", 1, -1 },
-	.usage = "[-cnr] [-t mode-table] [-T key-table] key command "
-		 "[arguments]",
+	.args = { "cnrT:", 2, -1 },
+	.usage = "[-cnr] [-T key-table] key "
+	         "command [arguments]",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_bind_key_exec
 };

-enum cmd_retval
-cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_bind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	char		*cause;
@@ -53,27 +50,12 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	key_code	 key;
 	const char	*tablename;

-	if (args_has(args, 't')) {
-		if (args->argc != 2 && args->argc != 3) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	} else {
-		if (args->argc < 2) {
-			cmdq_error(cmdq, "not enough arguments");
-			return (CMD_RETURN_ERROR);
-		}
-	}
-
 	key = key_string_lookup_string(args->argv[0]);
 	if (key == KEYC_NONE || key == KEYC_UNKNOWN) {
-		cmdq_error(cmdq, "unknown key: %s", args->argv[0]);
+		cmdq_error(item, "unknown key: %s", args->argv[0]);
 		return (CMD_RETURN_ERROR);
 	}

-	if (args_has(args, 't'))
-		return (cmd_bind_key_mode_table(self, cmdq, key));
-
 	if (args_has(args, 'T'))
 		tablename = args_get(args, 'T');
 	else if (args_has(args, 'n'))
@@ -84,7 +66,7 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	cmdlist = cmd_list_parse(args->argc - 1, args->argv + 1, NULL, 0,
 	    &cause);
 	if (cmdlist == NULL) {
-		cmdq_error(cmdq, "%s", cause);
+		cmdq_error(item, "%s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
@@ -92,68 +74,3 @@ cmd_bind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	key_bindings_add(tablename, key, args_has(args, 'r'), cmdlist);
 	return (CMD_RETURN_NORMAL);
 }
-
-enum cmd_retval
-cmd_bind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind, mtmp;
-	enum mode_key_cmd		 cmd;
-	const char			*arg;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	cmd = mode_key_fromstring(mtab->cmdstr, args->argv[1]);
-	if (cmd == MODEKEY_NONE) {
-		cmdq_error(cmdq, "unknown command: %s", args->argv[1]);
-		return (CMD_RETURN_ERROR);
-	}
-
-	switch (cmd) {
-	case MODEKEYCOPY_APPENDSELECTION:
-	case MODEKEYCOPY_COPYSELECTION:
-	case MODEKEYCOPY_STARTNAMEDBUFFER:
-		if (args->argc == 2)
-			arg = NULL;
-		else {
-			arg = args->argv[2];
-			if (strcmp(arg, "-x") != 0) {
-				cmdq_error(cmdq, "unknown argument");
-				return (CMD_RETURN_ERROR);
-			}
-		}
-		break;
-	case MODEKEYCOPY_COPYPIPE:
-		if (args->argc != 3) {
-			cmdq_error(cmdq, "no argument given");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = args->argv[2];
-		break;
-	default:
-		if (args->argc != 2) {
-			cmdq_error(cmdq, "no argument allowed");
-			return (CMD_RETURN_ERROR);
-		}
-		arg = NULL;
-		break;
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) == NULL) {
-		mbind = xmalloc(sizeof *mbind);
-		mbind->key = mtmp.key;
-		mbind->mode = mtmp.mode;
-		RB_INSERT(mode_key_tree, mtab->tree, mbind);
-	}
-	mbind->cmd = cmd;
-	mbind->arg = arg != NULL ? xstrdup(arg) : NULL;
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-break-pane.c
+++ b/cmd-break-pane.c
@@ -28,45 +28,46 @@

 #define BREAK_PANE_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"

-enum cmd_retval	 cmd_break_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_break_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_break_pane_entry = {
 	.name = "break-pane",
 	.alias = "breakp",

-	.args = { "dPF:s:t:", 0, 0 },
-	.usage = "[-dP] [-F format] [-s src-pane] [-t dst-window]",
+	.args = { "dPF:n:s:t:", 0, 0 },
+	.usage = "[-dP] [-F format] [-n window-name] [-s src-pane] "
+		 "[-t dst-window]",

-	.sflag = CMD_PANE,
-	.tflag = CMD_WINDOW_INDEX,
+	.source = { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },

 	.flags = 0,
 	.exec = cmd_break_pane_exec
 };

-enum cmd_retval
-cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_break_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.sflag.wl;
-	struct session		*src_s = cmdq->state.sflag.s;
-	struct session		*dst_s = cmdq->state.tflag.s;
-	struct window_pane	*wp = cmdq->state.sflag.wp;
+	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;
-	char			*cause;
-	int			 idx = cmdq->state.tflag.idx;
-	struct format_tree	*ft;
+	char			*name, *cause;
+	int			 idx = item->target.idx;
 	const char		*template;
 	char			*cp;

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

 	if (window_count_panes(w) == 1) {
-		cmdq_error(cmdq, "can't break with only one pane");
+		cmdq_error(item, "can't break with only one pane");
 		return (CMD_RETURN_ERROR);
 	}
 	server_unzoom_window(w);
@@ -75,20 +76,29 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	window_lost_pane(w, wp);
 	layout_close_pane(wp);

-	w = wp->window = window_create1(dst_s->sx, dst_s->sy);
+	w = wp->window = window_create(dst_s->sx, dst_s->sy);
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	w->active = wp;
-	name = default_window_name(w);
-	window_set_name(w, name);
-	free(name);
+
+	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);
+	}
+
 	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 */
-	if (!args_has(self->args, 'd'))
+	if (!args_has(self->args, 'd')) {
 		session_select(dst_s, wl->idx);
+		cmd_find_from_session(current, dst_s, 0);
+	}

 	server_redraw_session(src_s);
 	if (src_s != dst_s)
@@ -100,15 +110,9 @@ cmd_break_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = BREAK_PANE_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, dst_s, wl, wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, dst_s, wl, wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-capture-pane.c
+++ b/cmd-capture-pane.c
@@ -27,12 +27,12 @@
 * Write the entire contents of a pane to a buffer or stdout.
 */

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

-char		*cmd_capture_pane_append(char *, size_t *, char *, size_t);
-char		*cmd_capture_pane_pending(struct args *, struct window_pane *,
+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 *);
-char		*cmd_capture_pane_history(struct args *, struct cmd_q *,
+static char	*cmd_capture_pane_history(struct args *, struct cmdq_item *,
 		     struct window_pane *, size_t *);

 const struct cmd_entry cmd_capture_pane_entry = {
@@ -43,13 +43,26 @@ const struct cmd_entry cmd_capture_pane_entry = {
 	.usage = "[-aCeJpPq] " CMD_BUFFER_USAGE " [-E end-line] "
 		 "[-S start-line]" CMD_TARGET_PANE_USAGE,

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_capture_pane_exec
 };

-char *
+const struct cmd_entry cmd_clear_history_entry = {
+	.name = "clear-history",
+	.alias = "clearhist",
+
+	.args = { "t:", 0, 0 },
+	.usage = CMD_TARGET_PANE_USAGE,
+
+	.target = { 't', CMD_FIND_PANE, 0 },
+
+	.flags = CMD_AFTERHOOK,
+	.exec = cmd_capture_pane_exec
+};
+
+static char *
 cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 {
 	buf = xrealloc(buf, *len + linelen + 1);
@@ -58,7 +71,7 @@ cmd_capture_pane_append(char *buf, size_t *len, char *line, size_t linelen)
 	return (buf);
 }

-char *
+static char *
 cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
    size_t *len)
 {
@@ -77,7 +90,7 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	buf = xstrdup("");
 	if (args_has(args, 'C')) {
 		for (i = 0; i < linelen; i++) {
-			if (line[i] >= ' ') {
+			if (line[i] >= ' ' && line[i] != '\\') {
 				tmp[0] = line[i];
 				tmp[1] = '\0';
 			} else
@@ -90,8 +103,8 @@ cmd_capture_pane_pending(struct args *args, struct window_pane *wp,
 	return (buf);
 }

-char *
-cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
+static char *
+cmd_capture_pane_history(struct args *args, struct cmdq_item *item,
    struct window_pane *wp, size_t *len)
 {
 	struct grid		*gd;
@@ -108,7 +121,7 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 		gd = wp->saved_grid;
 		if (gd == NULL) {
 			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "no alternate screen");
+				cmdq_error(item, "no alternate screen");
 				return (NULL);
 			}
 			return (xstrdup(""));
@@ -175,29 +188,36 @@ cmd_capture_pane_history(struct args *args, struct cmd_q *cmdq,
 	return (buf);
 }

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

+	if (self->entry == &cmd_clear_history_entry) {
+		if (wp->mode == &window_copy_mode)
+			window_pane_reset_mode(wp);
+		grid_clear_history(wp->base.grid);
+		return (CMD_RETURN_NORMAL);
+	}
+
 	len = 0;
 	if (args_has(args, 'P'))
 		buf = cmd_capture_pane_pending(args, wp, &len);
 	else
-		buf = cmd_capture_pane_history(args, cmdq, wp, &len);
+		buf = cmd_capture_pane_history(args, item, wp, &len);
 	if (buf == NULL)
 		return (CMD_RETURN_ERROR);

 	if (args_has(args, 'p')) {
-		c = cmdq->client;
+		c = item->client;
 		if (c == NULL ||
 		    (c->session != NULL && !(c->flags & CLIENT_CONTROL))) {
-			cmdq_error(cmdq, "can't write to stdout");
+			cmdq_error(item, "can't write to stdout");
 			free(buf);
 			return (CMD_RETURN_ERROR);
 		}
@@ -212,7 +232,7 @@ cmd_capture_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			bufname = args_get(args, 'b');

 		if (paste_set(buf, len, bufname, &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 			free(buf);
 			return (CMD_RETURN_ERROR);
--- a/cmd-choose-buffer.c
+++ b/cmd-choose-buffer.c
@@ -1,100 +0,0 @@
-/* $OpenBSD$ */
-
-/*
- * Copyright (c) 2010 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 <ctype.h>
-#include <stdlib.h>
-
-#include "tmux.h"
-
-/*
- * Enter choice mode to choose a buffer.
- */
-
-#define CHOOSE_BUFFER_TEMPLATE						\
-	"#{buffer_name}: #{buffer_size} bytes: #{buffer_sample}"
-
-enum cmd_retval	 cmd_choose_buffer_exec(struct cmd *, struct cmd_q *);
-
-const struct cmd_entry cmd_choose_buffer_entry = {
-	.name = "choose-buffer",
-	.alias = NULL,
-
-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-
-	.tflag = CMD_WINDOW,
-
-	.flags = 0,
-	.exec = cmd_choose_buffer_exec
-};
-
-enum cmd_retval
-cmd_choose_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_choose_data	*cdata;
-	struct paste_buffer		*pb;
-	char				*action, *action_data;
-	const char			*template;
-	u_int				 idx;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = CHOOSE_BUFFER_TEMPLATE;
-
-	if (paste_get_top(NULL) == NULL)
-		return (CMD_RETURN_NORMAL);
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("paste-buffer -b '%%'");
-
-	idx = 0;
-	pb = NULL;
-	while ((pb = paste_walk(pb)) != NULL) {
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx;
-
-		cdata->ft_template = xstrdup(template);
-		format_defaults_paste_buffer(cdata->ft, pb);
-
-		xasprintf(&action_data, "%s", paste_buffer_name(pb));
-		cdata->command = cmd_template_replace(action, action_data, 1);
-		free(action_data);
-
-		window_choose_add(wl->window->active, cdata);
-		idx++;
-	}
-	free(action);
-
-	window_choose_ready(wl->window->active, 0, NULL);
-
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-choose-client.c
+++ b/cmd-choose-client.c
@@ -1,134 +0,0 @@
-/* $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 <ctype.h>
-#include <stdlib.h>
-
-#include "tmux.h"
-
-/*
- * Enter choice mode to choose a client.
- */
-
-#define CHOOSE_CLIENT_TEMPLATE					\
-	"#{client_tty}: #{session_name} "			\
-	"[#{client_width}x#{client_height} #{client_termname}]"	\
-	"#{?client_utf8, (utf8),}#{?client_readonly, (ro),} "	\
-	"(last used #{t:client_activity})"
-
-enum cmd_retval	 cmd_choose_client_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_choose_client_callback(struct window_choose_data *);
-
-const struct cmd_entry cmd_choose_client_entry = {
-	.name = "choose-client",
-	.alias = NULL,
-
-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
-
-	.tflag = CMD_WINDOW,
-
-	.flags = 0,
-	.exec = cmd_choose_client_exec
-};
-
-struct cmd_choose_client_data {
-	struct client	*client;
-};
-
-enum cmd_retval
-cmd_choose_client_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct client			*c1;
-	struct window_choose_data	*cdata;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	const char			*template;
-	char				*action;
-	u_int			 	 idx, cur;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = CHOOSE_CLIENT_TEMPLATE;
-
-	if (args->argc != 0)
-		action = xstrdup(args->argv[0]);
-	else
-		action = xstrdup("detach-client -t '%%'");
-
-	cur = idx = 0;
-	TAILQ_FOREACH(c1, &clients, entry) {
-		if (c1->session == NULL || c1->tty.path == NULL)
-			continue;
-		if (c1 == cmdq->client)
-			cur = idx;
-
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = idx;
-
-		cdata->ft_template = xstrdup(template);
-		format_add(cdata->ft, "line", "%u", idx);
-		format_defaults(cdata->ft, c1, NULL, NULL, NULL);
-
-		cdata->command = cmd_template_replace(action, c1->tty.path, 1);
-
-		window_choose_add(wl->window->active, cdata);
-
-		idx++;
-	}
-	free(action);
-
-	window_choose_ready(wl->window->active, cur,
-	    cmd_choose_client_callback);
-
-	return (CMD_RETURN_NORMAL);
-}
-
-void
-cmd_choose_client_callback(struct window_choose_data *cdata)
-{
-	struct client  	*c;
-	u_int		 idx;
-
-	if (cdata == NULL)
-		return;
-	if (cdata->start_client->flags & CLIENT_DEAD)
-		return;
-
-	idx = 0;
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (idx == cdata->idx)
-			break;
-		idx++;
-	}
-	if (c == NULL || c->session == NULL)
-		return;
-
-	window_choose_data_run(cdata);
-}
--- a/cmd-choose-tree.c
+++ b/cmd-choose-tree.c
@@ -18,236 +18,74 @@

 #include <sys/types.h>

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

-#define CMD_CHOOSE_TREE_WINDOW_ACTION "select-window -t '%%'"
-#define CMD_CHOOSE_TREE_SESSION_ACTION "switch-client -t '%%'"
-
 /*
- * Enter choice mode to choose a session and/or window.
+ * Enter a mode.
 */

-#define CHOOSE_TREE_SESSION_TEMPLATE				\
-	"#{session_name}: #{session_windows} windows"		\
-	"#{?session_grouped, (group ,}"				\
-	"#{session_group}#{?session_grouped,),}"		\
-	"#{?session_attached, (attached),}"
-#define CHOOSE_TREE_WINDOW_TEMPLATE				\
-	"#{window_index}: #{window_name}#{window_flags} "	\
-	"\"#{pane_title}\""
-
-enum cmd_retval	cmd_choose_tree_exec(struct cmd *, struct cmd_q *);
+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 = { "S:W:swub:c:t:", 0, 1 },
-	.usage = "[-suw] [-b session-template] [-c window template] "
-		 "[-S format] [-W format] " CMD_TARGET_WINDOW_USAGE,
+	.args = { "F:f:NO:st:w", 0, 1 },
+	.usage = "[-Nsw] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,

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

 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };

-const struct cmd_entry cmd_choose_session_entry = {
-	.name = "choose-session",
+const struct cmd_entry cmd_choose_client_entry = {
+	.name = "choose-client",
 	.alias = NULL,

-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE " [-F format] [template]",
+	.args = { "F:f:NO:t:", 0, 1 },
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,

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

 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };

-const struct cmd_entry cmd_choose_window_entry = {
-	.name = "choose-window",
+const struct cmd_entry cmd_choose_buffer_entry = {
+	.name = "choose-buffer",
 	.alias = NULL,

-	.args = { "F:t:", 0, 1 },
-	.usage = CMD_TARGET_WINDOW_USAGE "[-F format] [template]",
+	.args = { "F:f:NO:t:", 0, 1 },
+	.usage = "[-N] [-F format] [-f filter] [-O sort-order] "
+	         CMD_TARGET_PANE_USAGE,

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

 	.flags = 0,
 	.exec = cmd_choose_tree_exec
 };

-enum cmd_retval
-cmd_choose_tree_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_choose_tree_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct winlink			*wl = cmdq->state.tflag.wl, *wm;
-	struct session			*s = cmdq->state.tflag.s, *s2;
-	struct window_choose_data	*wcd = NULL;
-	const char			*ses_template, *win_template;
-	char				*final_win_action, *cur_win_template;
-	char				*final_win_template_middle;
-	char				*final_win_template_last;
-	const char			*ses_action, *win_action;
-	u_int				 cur_win, idx_ses, win_ses, win_max;
-	u_int				 wflag, sflag;
+	struct window_pane		*wp = item->target.wp;
+	const struct window_mode	*mode;

-	ses_template = win_template = NULL;
-	ses_action = win_action = NULL;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		return (CMD_RETURN_NORMAL);
-
-	/* Sort out which command this is. */
-	wflag = sflag = 0;
-	if (self->entry == &cmd_choose_session_entry) {
-		sflag = 1;
-		if ((ses_template = args_get(args, 'F')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if (args->argc != 0)
-			ses_action = args->argv[0];
-		else
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-	} else if (self->entry == &cmd_choose_window_entry) {
-		wflag = 1;
-		if ((win_template = args_get(args, 'F')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-
-		if (args->argc != 0)
-			win_action = args->argv[0];
-		else
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-	} else {
-		wflag = args_has(args, 'w');
-		sflag = args_has(args, 's');
-
-		if ((ses_action = args_get(args, 'b')) == NULL)
-			ses_action = CMD_CHOOSE_TREE_SESSION_ACTION;
-
-		if ((win_action = args_get(args, 'c')) == NULL)
-			win_action = CMD_CHOOSE_TREE_WINDOW_ACTION;
-
-		if ((ses_template = args_get(args, 'S')) == NULL)
-			ses_template = CHOOSE_TREE_SESSION_TEMPLATE;
-
-		if ((win_template = args_get(args, 'W')) == NULL)
-			win_template = CHOOSE_TREE_WINDOW_TEMPLATE;
-	}
-
-	/*
-	 * If not asking for windows and sessions, assume no "-ws" given and
-	 * hence display the entire tree outright.
-	 */
-	if (!wflag && !sflag)
-		wflag = sflag = 1;
-
-	/*
-	 * If we're drawing in tree mode, including sessions, then pad the
-	 * window template, otherwise just render the windows as a flat list
-	 * without any padding.
-	 */
-	if (wflag && sflag) {
-		xasprintf(&final_win_template_middle,
-		    " \001tq\001> %s", win_template);
-		xasprintf(&final_win_template_last,
-		    " \001mq\001> %s", win_template);
-	} else if (wflag) {
-		final_win_template_middle = xstrdup(win_template);
-		final_win_template_last = xstrdup(win_template);
+	if (self->entry == &cmd_choose_buffer_entry) {
+		if (paste_get_top(NULL) == NULL)
+			return (CMD_RETURN_NORMAL);
+		mode = &window_buffer_mode;
+	} else if (self->entry == &cmd_choose_client_entry) {
+		if (server_client_how_many() == 0)
+			return (CMD_RETURN_NORMAL);
+		mode = &window_client_mode;
 	} else
-		final_win_template_middle = final_win_template_last = NULL;
-
-	idx_ses = cur_win = -1;
-	RB_FOREACH(s2, sessions, &sessions) {
-		idx_ses++;
-
-		/*
-		 * If we're just choosing windows, jump straight there. Note
-		 * that this implies the current session, so only choose
-		 * windows when the session matches this one.
-		 */
-		if (wflag && !sflag) {
-			if (s != s2)
-				continue;
-			goto windows_only;
-		}
-
-		wcd = window_choose_add_session(wl->window->active,
-		    c, s2, ses_template, ses_action, idx_ses);
-
-		/* If we're just choosing sessions, skip choosing windows. */
-		if (sflag && !wflag) {
-			if (s == s2)
-				cur_win = idx_ses;
-			continue;
-		}
-windows_only:
-		win_ses = win_max = -1;
-		RB_FOREACH(wm, winlinks, &s2->windows)
-			win_max++;
-		RB_FOREACH(wm, winlinks, &s2->windows) {
-			win_ses++;
-			if (sflag && wflag)
-				idx_ses++;
-
-			if (wm == s2->curw && s == s2) {
-				if (wflag && !sflag) {
-					/*
-					 * Then we're only counting windows.
-					 * So remember which is the current
-					 * window in the list.
-					 */
-					cur_win = win_ses;
-				} else
-					cur_win = idx_ses;
-			}
-
-			xasprintf(&final_win_action, "%s %s %s",
-			    wcd != NULL ? wcd->command : "",
-			    wcd != NULL ? ";" : "", win_action);
-
-			if (win_ses != win_max)
-				cur_win_template = final_win_template_middle;
-			else
-				cur_win_template = final_win_template_last;
-
-			window_choose_add_window(wl->window->active,
-			    c, s2, wm, cur_win_template,
-			    final_win_action,
-			    (wflag && !sflag) ? win_ses : idx_ses);
-
-			free(final_win_action);
-		}
-
-		/*
-		 * If we're just drawing windows, don't consider moving on to
-		 * other sessions as we only list windows in this session.
-		 */
-		if (wflag && !sflag)
-			break;
-	}
-	free(final_win_template_middle);
-	free(final_win_template_last);
-
-	window_choose_ready(wl->window->active, cur_win, NULL);
-
-	if (args_has(args, 'u')) {
-		window_choose_expand_all(wl->window->active);
-		window_choose_set_current(wl->window->active, cur_win);
-	}
+		mode = &window_tree_mode;

+	window_pane_set_mode(wp, mode, &item->target, args);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-command-prompt.c
+++ b/cmd-command-prompt.c
@@ -29,56 +29,64 @@
 * Prompt for command in client.
 */

-enum cmd_retval	cmd_command_prompt_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_command_prompt_exec(struct cmd *,
+			    struct cmdq_item *);

-int	cmd_command_prompt_callback(void *, const char *);
-void	cmd_command_prompt_free(void *);
+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 = { "I:p:t:", 0, 1 },
-	.usage = "[-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
+	.args = { "1iI:Np:t:", 0, 1 },
+	.usage = "[-1Ni] [-I inputs] [-p prompts] " CMD_TARGET_CLIENT_USAGE " "
 		 "[template]",

-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_command_prompt_exec
 };

 struct cmd_command_prompt_cdata {
-	struct client	*c;
-	char		*inputs;
-	char		*next_input;
-	char		*next_prompt;
-	char		*prompts;
-	char		*template;
-	int		 idx;
+	int	 flags;
+
+	char	*inputs;
+	char	*next_input;
+
+	char	*prompts;
+	char	*next_prompt;
+
+	char	*template;
+	int	 idx;
 };

-enum cmd_retval
-cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_command_prompt_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	const char			*inputs, *prompts;
 	struct cmd_command_prompt_cdata	*cdata;
-	struct client			*c = cmdq->state.c;
+	struct client			*c;
 	char				*prompt, *ptr, *input = NULL;
 	size_t				 n;

+	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);

-	cdata = xmalloc(sizeof *cdata);
-	cdata->c = c;
-	cdata->idx = 1;
+	cdata = xcalloc(1, sizeof *cdata);
+
 	cdata->inputs = NULL;
 	cdata->next_input = NULL;
-	cdata->next_prompt = NULL;
+
 	cdata->prompts = NULL;
+	cdata->next_prompt = NULL;
+
 	cdata->template = NULL;
+	cdata->idx = 1;

 	if (args->argc != 0)
 		cdata->template = xstrdup(args->argv[0]);
@@ -108,34 +116,56 @@ cmd_command_prompt_exec(struct cmd *self, struct cmd_q *cmdq)
 		input = strsep(&cdata->next_input, ",");
 	}

+	if (args_has(args, '1'))
+		cdata->flags |= PROMPT_SINGLE;
+	else if (args_has(args, 'N'))
+		cdata->flags |= PROMPT_NUMERIC;
+	else if (args_has(args, 'i'))
+		cdata->flags |= PROMPT_INCREMENTAL;
 	status_prompt_set(c, prompt, input, cmd_command_prompt_callback,
-	    cmd_command_prompt_free, cdata, 0);
+	    cmd_command_prompt_free, cdata, cdata->flags);
 	free(prompt);

 	return (CMD_RETURN_NORMAL);
 }

-int
-cmd_command_prompt_callback(void *data, const char *s)
+static enum cmd_retval
+cmd_command_prompt_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static int
+cmd_command_prompt_callback(struct client *c, void *data, const char *s,
+    int done)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
-	struct client			*c = cdata->c;
 	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
 	char				*cause, *new_template, *prompt, *ptr;
 	char				*input = NULL;

 	if (s == NULL)
 		return (0);
+	if (done && (cdata->flags & PROMPT_INCREMENTAL))
+		return (0);

 	new_template = cmd_template_replace(cdata->template, s, cdata->idx);
-	free(cdata->template);
-	cdata->template = new_template;
+	if (done) {
+		free(cdata->template);
+		cdata->template = new_template;
+	}

 	/*
 	 * Check if there are more prompts; if so, get its respective input
 	 * and update the prompt data.
 	 */
-	if ((ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
+	if (done && (ptr = strsep(&cdata->next_prompt, ",")) != NULL) {
 		xasprintf(&prompt, "%s ", ptr);
 		input = strsep(&cdata->next_input, ",");
 		status_prompt_update(c, prompt, input);
@@ -145,24 +175,29 @@ cmd_command_prompt_callback(void *data, const char *s)
 		return (1);
 	}

-	if (cmd_string_parse(new_template, &cmdlist, NULL, 0, &cause) != 0) {
+	cmdlist = cmd_string_parse(new_template, NULL, 0, &cause);
+	if (cmdlist == NULL) {
 		if (cause != NULL) {
-			*cause = toupper((u_char) *cause);
-			status_message_set(c, "%s", cause);
-			free(cause);
-		}
-		return (0);
+			new_item = cmdq_get_callback(cmd_command_prompt_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
 	}

-	cmdq_run(c->cmdq, cmdlist, NULL);
-	cmd_list_free(cmdlist);
+	if (new_item != NULL)
+		cmdq_append(c, new_item);

-	if (c->prompt_callbackfn != (void *) &cmd_command_prompt_callback)
+	if (!done)
+		free(new_template);
+	if (c->prompt_inputcb != cmd_command_prompt_callback)
 		return (1);
 	return (0);
 }

-void
+static void
 cmd_command_prompt_free(void *data)
 {
 	struct cmd_command_prompt_cdata	*cdata = data;
--- a/cmd-confirm-before.c
+++ b/cmd-confirm-before.c
@@ -28,10 +28,12 @@
 * Asks for confirmation before executing a command.
 */

-enum cmd_retval	 cmd_confirm_before_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_confirm_before_exec(struct cmd *,
+			    struct cmdq_item *);

-int		 cmd_confirm_before_callback(void *, const char *);
-void		 cmd_confirm_before_free(void *);
+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",
@@ -40,26 +42,26 @@ const struct cmd_entry cmd_confirm_before_entry = {
 	.args = { "p:t:", 1, 1 },
 	.usage = "[-p prompt] " CMD_TARGET_CLIENT_USAGE " command",

-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_confirm_before_exec
 };

 struct cmd_confirm_before_data {
-	char		*cmd;
-	struct client	*client;
+	char	*cmd;
 };

-enum cmd_retval
-cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_confirm_before_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_confirm_before_data	*cdata;
-	struct client			*c = cmdq->state.c;
+	struct client			*c;
 	char				*cmd, *copy, *new_prompt, *ptr;
 	const char			*prompt;

+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
 	if ((prompt = args_get(args, 'p')) != NULL)
 		xasprintf(&new_prompt, "%s ", prompt);
 	else {
@@ -72,9 +74,6 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	cdata = xmalloc(sizeof *cdata);
 	cdata->cmd = xstrdup(args->argv[0]);

-	cdata->client = c;
-	cdata->client->references++;
-
 	status_prompt_set(c, new_prompt, NULL,
 	    cmd_confirm_before_callback, cmd_confirm_before_free, cdata,
 	    PROMPT_SINGLE);
@@ -83,12 +82,24 @@ cmd_confirm_before_exec(struct cmd *self, struct cmd_q *cmdq)
 	return (CMD_RETURN_NORMAL);
 }

-int
-cmd_confirm_before_callback(void *data, const char *s)
+static enum cmd_retval
+cmd_confirm_before_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static int
+cmd_confirm_before_callback(struct client *c, void *data, const char *s,
+    __unused int done)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
 	struct cmd_list			*cmdlist;
+	struct cmdq_item		*new_item;
 	char				*cause;

 	if (c->flags & CLIENT_DEAD)
@@ -99,27 +110,28 @@ cmd_confirm_before_callback(void *data, const char *s)
 	if (tolower((u_char) s[0]) != 'y' || s[1] != '\0')
 		return (0);

-	if (cmd_string_parse(cdata->cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	cmdlist = cmd_string_parse(cdata->cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
 		if (cause != NULL) {
-			cmdq_error(c->cmdq, "%s", cause);
-			free(cause);
-		}
-		return (0);
+			new_item = cmdq_get_callback(cmd_confirm_before_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
 	}

-	cmdq_run(c->cmdq, cmdlist, NULL);
-	cmd_list_free(cmdlist);
+	if (new_item != NULL)
+		cmdq_append(c, new_item);

 	return (0);
 }

-void
+static void
 cmd_confirm_before_free(void *data)
 {
 	struct cmd_confirm_before_data	*cdata = data;
-	struct client			*c = cdata->client;
-
-	server_client_unref(c);

 	free(cdata->cmd);
 	free(cdata);
--- a/cmd-copy-mode.c
+++ b/cmd-copy-mode.c
@@ -24,7 +24,7 @@
 * Enter copy or clock mode.
 */

-enum cmd_retval	 cmd_copy_mode_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_copy_mode_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_copy_mode_entry = {
 	.name = "copy-mode",
@@ -33,9 +33,9 @@ const struct cmd_entry cmd_copy_mode_entry = {
 	.args = { "Met:u", 0, 0 },
 	.usage = "[-Mu] " CMD_TARGET_PANE_USAGE,

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };

@@ -46,44 +46,47 @@ const struct cmd_entry cmd_clock_mode_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_PANE_USAGE,

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_copy_mode_exec
 };

-enum cmd_retval
-cmd_copy_mode_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_copy_mode_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
+	struct cmdq_shared	*shared = item->shared;
+	struct client		*c = item->client;
 	struct session		*s;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
+	int			 flag;

 	if (args_has(args, 'M')) {
-		if ((wp = cmd_mouse_pane(&cmdq->item->mouse, &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 (self->entry == &cmd_clock_mode_entry) {
-		window_pane_set_mode(wp, &window_clock_mode);
+		window_pane_set_mode(wp, &window_clock_mode, NULL, NULL);
 		return (CMD_RETURN_NORMAL);
 	}

 	if (wp->mode != &window_copy_mode) {
-		if (window_pane_set_mode(wp, &window_copy_mode) != 0)
+		flag = window_pane_set_mode(wp, &window_copy_mode, NULL, NULL);
+		if (flag != 0)
 			return (CMD_RETURN_NORMAL);
 		window_copy_init_from_pane(wp, args_has(self->args, 'e'));
 	}
 	if (args_has(args, 'M')) {
 		if (wp->mode != NULL && wp->mode != &window_copy_mode)
 			return (CMD_RETURN_NORMAL);
-		window_copy_start_drag(c, &cmdq->item->mouse);
+		window_copy_start_drag(c, &shared->mouse);
 	}
 	if (wp->mode == &window_copy_mode && args_has(self->args, 'u'))
-		window_copy_pageup(wp);
+		window_copy_pageup(wp, 0);

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-detach-client.c
+++ b/cmd-detach-client.c
@@ -26,17 +26,18 @@
 * Detach a client.
 */

-enum cmd_retval	 cmd_detach_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_detach_client_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_detach_client_entry = {
 	.name = "detach-client",
 	.alias = "detach",

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

-	.sflag = CMD_SESSION,
-	.tflag = CMD_CLIENT,
+	.source = { 's', CMD_FIND_SESSION, CMD_FIND_CANFAIL },

 	.flags = CMD_READONLY,
 	.exec = cmd_detach_client_exec
@@ -49,24 +50,24 @@ const struct cmd_entry cmd_suspend_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,

-	.tflag = CMD_CLIENT,
-
 	.flags = 0,
 	.exec = cmd_detach_client_exec
 };

-enum cmd_retval
-cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_detach_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c, *cloop;
+	struct client	*c, *cloop;
 	struct session	*s;
 	enum msgtype	 msgtype;
+	const char	*cmd = args_get(args, 'E');
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);

 	if (self->entry == &cmd_suspend_client_entry) {
-		tty_stop_tty(&c->tty);
-		c->flags |= CLIENT_SUSPENDED;
-		proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0);
+		server_client_suspend(c);
 		return (CMD_RETURN_NORMAL);
 	}

@@ -76,22 +77,35 @@ cmd_detach_client_exec(struct cmd *self, struct cmd_q *cmdq)
 		msgtype = MSG_DETACH;

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

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

-	server_client_detach(c, msgtype);
+	if (cmd != NULL)
+		server_client_exec(c, cmd);
+	else
+		server_client_detach(c, msgtype);
 	return (CMD_RETURN_STOP);
 }
--- a/cmd-display-message.c
+++ b/cmd-display-message.c
@@ -32,7 +32,8 @@
 	"#{window_name}, current pane #{pane_index} "	\
 	"- (%H:%M %d-%b-%y)"

-enum cmd_retval	 cmd_display_message_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_display_message_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_display_message_entry = {
 	.name = "display-message",
@@ -42,29 +43,29 @@ const struct cmd_entry cmd_display_message_entry = {
 	.usage = "[-p] [-c target-client] [-F format] "
 		 CMD_TARGET_PANE_USAGE " [message]",

-	.cflag = CMD_CLIENT_CANFAIL,
-	.tflag = CMD_PANE,
+	.target = { 't', CMD_FIND_PANE, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_message_exec
 };

-enum cmd_retval
-cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_display_message_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct client		*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;
 	struct format_tree	*ft;

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

 	template = args_get(args, 'F');
 	if (args->argc != 0)
@@ -72,15 +73,16 @@ cmd_display_message_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (template == NULL)
 		template = DISPLAY_MESSAGE_TEMPLATE;

-	ft = format_create(cmdq, 0);
+	ft = format_create(item->client, item, FORMAT_NONE, 0);
 	format_defaults(ft, c, s, wl, wp);

 	msg = format_expand_time(ft, template, time(NULL));
 	if (args_has(self->args, 'p'))
-		cmdq_print(cmdq, "%s", msg);
-	else
+		cmdq_print(item, "%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
@@ -18,31 +18,112 @@

 #include <sys/types.h>

+#include <ctype.h>
+#include <stdlib.h>
+
 #include "tmux.h"

 /*
 * Display panes on a client.
 */

-enum cmd_retval	 cmd_display_panes_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_display_panes_exec(struct cmd *,
+			    struct cmdq_item *);
+
+static void		cmd_display_panes_callback(struct client *,
+			    struct window_pane *);

 const struct cmd_entry cmd_display_panes_entry = {
 	.name = "display-panes",
 	.alias = "displayp",

-	.args = { "t:", 0, 0 },
-	.usage = CMD_TARGET_CLIENT_USAGE,
+	.args = { "d:t:", 0, 1 },
+	.usage = "[-d duration] " CMD_TARGET_CLIENT_USAGE,

-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_display_panes_exec
 };

-enum cmd_retval
-cmd_display_panes_exec(__unused struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_display_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
-	server_set_identify(cmdq->state.c);
+	struct args	*args = self->args;
+	struct client	*c;
+	struct session	*s;
+	u_int		 delay;
+	char		*cause;
+
+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
+	if (c->identify_callback != NULL)
+		return (CMD_RETURN_NORMAL);
+
+	c->identify_callback = cmd_display_panes_callback;
+	if (args->argc != 0)
+		c->identify_callback_data = xstrdup(args->argv[0]);
+	else
+		c->identify_callback_data = xstrdup("select-pane -t '%%'");
+	s = c->session;
+
+	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");
+	server_client_set_identify(c, delay);

 	return (CMD_RETURN_NORMAL);
 }
+
+static enum cmd_retval
+cmd_display_panes_error(struct cmdq_item *item, void *data)
+{
+	char	*error = data;
+
+	cmdq_error(item, "%s", error);
+	free(error);
+
+	return (CMD_RETURN_NORMAL);
+}
+
+static void
+cmd_display_panes_callback(struct client *c, struct window_pane *wp)
+{
+	struct cmd_list		*cmdlist;
+	struct cmdq_item	*new_item;
+	char			*template, *cmd, *expanded, *cause;
+
+	template = c->identify_callback_data;
+	if (wp == NULL)
+		goto out;
+	xasprintf(&expanded, "%%%u", wp->id);
+	cmd = cmd_template_replace(template, expanded, 1);
+
+	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
+		if (cause != NULL) {
+			new_item = cmdq_get_callback(cmd_display_panes_error,
+			    cause);
+		} else
+			new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, NULL, 0);
+		cmd_list_free(cmdlist);
+	}
+
+	if (new_item != NULL)
+		cmdq_append(c, new_item);
+
+	free(cmd);
+	free(expanded);
+
+out:
+	free(c->identify_callback_data);
+	c->identify_callback_data = NULL;
+	c->identify_callback = NULL;
+}
--- a/cmd-find-window.c
+++ b/cmd-find-window.c
@@ -18,9 +18,7 @@

 #include <sys/types.h>

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

 #include "tmux.h"

@@ -28,213 +26,69 @@
 * Find window containing text.
 */

-#define FIND_WINDOW_TEMPLATE					\
-	"#{window_index}: #{window_name} "			\
-	"[#{window_width}x#{window_height}] "			\
-	"(#{window_panes} panes) #{window_find_matches}"
-
-enum cmd_retval	 cmd_find_window_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_find_window_callback(struct window_choose_data *);
-
-/* Flags for determining matching behavior. */
-#define CMD_FIND_WINDOW_BY_TITLE   0x1
-#define CMD_FIND_WINDOW_BY_CONTENT 0x2
-#define CMD_FIND_WINDOW_BY_NAME    0x4
-
-#define CMD_FIND_WINDOW_ALL		\
-	(CMD_FIND_WINDOW_BY_TITLE |	\
-	 CMD_FIND_WINDOW_BY_CONTENT |	\
-	 CMD_FIND_WINDOW_BY_NAME)
+static enum cmd_retval	cmd_find_window_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_find_window_entry = {
 	.name = "find-window",
 	.alias = "findw",

-	.args = { "F:CNt:T", 1, 4 },
-	.usage = "[-CNT] [-F format] " CMD_TARGET_WINDOW_USAGE " match-string",
+	.args = { "CNt:T", 1, 1 },
+	.usage = "[-CNT] " CMD_TARGET_PANE_USAGE " match-string",

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

 	.flags = 0,
 	.exec = cmd_find_window_exec
 };

-struct cmd_find_window_data {
-	struct winlink	*wl;
-	char		*list_ctx;
-	u_int		 pane_id;
-	TAILQ_ENTRY(cmd_find_window_data) entry;
-};
-TAILQ_HEAD(cmd_find_window_list, cmd_find_window_data);
-
-u_int	cmd_find_window_match_flags(struct args *);
-void	cmd_find_window_match(struct cmd_find_window_list *, int,
-	    struct winlink *, const char *, const char *);
-
-u_int
-cmd_find_window_match_flags(struct args *args)
+static enum cmd_retval
+cmd_find_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	u_int	match_flags = 0;
+	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;

-	/* Turn on flags based on the options. */
-	if (args_has(args, 'T'))
-		match_flags |= CMD_FIND_WINDOW_BY_TITLE;
-	if (args_has(args, 'C'))
-		match_flags |= CMD_FIND_WINDOW_BY_CONTENT;
-	if (args_has(args, 'N'))
-		match_flags |= CMD_FIND_WINDOW_BY_NAME;
+	C = args_has(args, 'C');
+	N = args_has(args, 'N');
+	T = args_has(args, 'T');

-	/* If none of the flags were set, default to matching anything. */
-	if (match_flags == 0)
-		match_flags = CMD_FIND_WINDOW_ALL;
+	if (!C && !N && !T)
+		C = N = T = 1;

-	return (match_flags);
-}
+	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);

-void
-cmd_find_window_match(struct cmd_find_window_list *find_list,
-    int match_flags, struct winlink *wl, const char *str,
-    const char *searchstr)
-{
-	struct cmd_find_window_data	*find_data;
-	struct window_pane		*wp;
-	u_int				 i, line;
-	char				*sres;
+	new_args = args_parse("", 1, &argv);
+	args_set(new_args, 'f', filter);

-	find_data = xcalloc(1, sizeof *find_data);
+	window_pane_set_mode(wp, &window_tree_mode, &item->target, new_args);

-	i = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		i++;
+	args_free(new_args);
+	free(filter);

-		if ((match_flags & CMD_FIND_WINDOW_BY_NAME) &&
-		    fnmatch(searchstr, wl->window->name, 0) == 0) {
-			find_data->list_ctx = xstrdup("");
-			break;
-		}
-
-		if ((match_flags & CMD_FIND_WINDOW_BY_TITLE) &&
-		    fnmatch(searchstr, wp->base.title, 0) == 0) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u title: \"%s\"", i - 1, wp->base.title);
-			break;
-		}
-
-		if (match_flags & CMD_FIND_WINDOW_BY_CONTENT &&
-		    (sres = window_pane_search(wp, str, &line)) != NULL) {
-			xasprintf(&find_data->list_ctx,
-			    "pane %u line %u: \"%s\"", i - 1, line + 1, sres);
-			free(sres);
-			break;
-		}
-	}
-
-	if (find_data->list_ctx != NULL) {
-		find_data->wl = wl;
-		find_data->pane_id = i - 1;
-		TAILQ_INSERT_TAIL(find_list, find_data, entry);
-	} else
-		free(find_data);
-}
-
-enum cmd_retval
-cmd_find_window_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	struct client			*c = cmdq->state.c;
-	struct window_choose_data	*cdata;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl, *wm;
-	struct cmd_find_window_list	 find_list;
-	struct cmd_find_window_data	*find_data;
-	struct cmd_find_window_data	*find_data1;
-	char				*str, *searchstr;
-	const char			*template;
-	u_int				 i, match_flags;
-
-	if (c == NULL) {
-		cmdq_error(cmdq, "no client available");
-		return (CMD_RETURN_ERROR);
-	}
-
-	if ((template = args_get(args, 'F')) == NULL)
-		template = FIND_WINDOW_TEMPLATE;
-
-	match_flags = cmd_find_window_match_flags(args);
-	str = args->argv[0];
-
-	TAILQ_INIT(&find_list);
-
-	xasprintf(&searchstr, "*%s*", str);
-	RB_FOREACH(wm, winlinks, &s->windows)
-	    cmd_find_window_match(&find_list, match_flags, wm, str, searchstr);
-	free(searchstr);
-
-	if (TAILQ_EMPTY(&find_list)) {
-		cmdq_error(cmdq, "no windows matching: %s", str);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (TAILQ_NEXT(TAILQ_FIRST(&find_list), entry) == NULL) {
-		if (session_select(s, TAILQ_FIRST(&find_list)->wl->idx) == 0)
-			server_redraw_session(s);
-		recalculate_sizes();
-		goto out;
-	}
-
-	if (window_pane_set_mode(wl->window->active, &window_choose_mode) != 0)
-		goto out;
-
-	i = 0;
-	TAILQ_FOREACH(find_data, &find_list, entry) {
-		cdata = window_choose_data_create(TREE_OTHER, c, c->session);
-		cdata->idx = find_data->wl->idx;
-		cdata->wl = find_data->wl;
-
-		cdata->ft_template = xstrdup(template);
-		cdata->pane_id = find_data->pane_id;
-
-		format_add(cdata->ft, "line", "%u", i);
-		format_add(cdata->ft, "window_find_matches", "%s",
-		    find_data->list_ctx);
-		format_defaults(cdata->ft, NULL, s, find_data->wl, NULL);
-
-		window_choose_add(wl->window->active, cdata);
-
-		i++;
-	}
-
-	window_choose_ready(wl->window->active, 0, cmd_find_window_callback);
-
-out:
-	TAILQ_FOREACH_SAFE(find_data, &find_list, entry, find_data1) {
-		free(find_data->list_ctx);
-		TAILQ_REMOVE(&find_list, find_data, entry);
-		free(find_data);
-	}
 	return (CMD_RETURN_NORMAL);
 }
-
-void
-cmd_find_window_callback(struct window_choose_data *cdata)
-{
-	struct session		*s;
-	struct window_pane	*wp;
-
-	if (cdata == NULL)
-		return;
-
-	s = cdata->start_session;
-	if (!session_alive(s))
-		return;
-
-	wp = window_pane_at_index(cdata->wl->window, cdata->pane_id);
-	if (wp != NULL && window_pane_visible(wp))
-		window_set_active_pane(cdata->wl->window, wp);
-
-	if (session_select(s, cdata->idx) == 0) {
-		server_redraw_session(s);
-		recalculate_sizes();
-	}
-}
--- a/cmd-find.c
+++ b/cmd-find.c
@@ -26,33 +26,28 @@

 #include "tmux.h"

-struct session	*cmd_find_try_TMUX(struct client *, struct window *);
-int		 cmd_find_client_better(struct client *, struct client *);
-struct client	*cmd_find_best_client(struct client **, u_int);
-int		 cmd_find_session_better(struct session *, struct session *,
-		     int);
-struct session	*cmd_find_best_session(struct session **, u_int, int);
-int		 cmd_find_best_session_with_window(struct cmd_find_state *);
-int		 cmd_find_best_winlink_with_window(struct cmd_find_state *);
+static int	cmd_find_session_better(struct session *, struct session *,
+		    int);
+static struct session *cmd_find_best_session(struct session **, u_int, int);
+static int	cmd_find_best_session_with_window(struct cmd_find_state *);
+static int	cmd_find_best_winlink_with_window(struct cmd_find_state *);

-int		 cmd_find_current_session_with_client(struct cmd_find_state *);
-int		 cmd_find_current_session(struct cmd_find_state *);
-struct client	*cmd_find_current_client(struct cmd_q *);
+static const char *cmd_find_map_table(const char *[][2], const char *);

-const char	*cmd_find_map_table(const char *[][2], const char *);
+static int	cmd_find_get_session(struct cmd_find_state *, const char *);
+static int	cmd_find_get_window(struct cmd_find_state *, const char *, int);
+static int	cmd_find_get_window_with_session(struct cmd_find_state *,
+		    const char *);
+static int	cmd_find_get_pane(struct cmd_find_state *, const char *, int);
+static int	cmd_find_get_pane_with_session(struct cmd_find_state *,
+		    const char *);
+static int	cmd_find_get_pane_with_window(struct cmd_find_state *,
+		    const char *);

-int	cmd_find_get_session(struct cmd_find_state *, const char *);
-int	cmd_find_get_window(struct cmd_find_state *, const char *);
-int	cmd_find_get_window_with_session(struct cmd_find_state *, const char *);
-int	cmd_find_get_window_with_pane(struct cmd_find_state *);
-int	cmd_find_get_pane(struct cmd_find_state *, const char *);
-int	cmd_find_get_pane_with_session(struct cmd_find_state *, const char *);
-int	cmd_find_get_pane_with_window(struct cmd_find_state *, const char *);
-
-const char *cmd_find_session_table[][2] = {
+static const char *cmd_find_session_table[][2] = {
 	{ NULL, NULL }
 };
-const char *cmd_find_window_table[][2] = {
+static const char *cmd_find_window_table[][2] = {
 	{ "{start}", "^" },
 	{ "{last}", "!" },
 	{ "{end}", "$" },
@@ -60,7 +55,7 @@ const char *cmd_find_window_table[][2] = {
 	{ "{previous}", "-" },
 	{ NULL, NULL }
 };
-const char *cmd_find_pane_table[][2] = {
+static const char *cmd_find_pane_table[][2] = {
 	{ "{last}", "!" },
 	{ "{next}", "+" },
 	{ "{previous}", "-" },
@@ -80,14 +75,13 @@ const char *cmd_find_pane_table[][2] = {
 };

 /* Get session from TMUX if present. */
-struct session *
-cmd_find_try_TMUX(struct client *c, struct window *w)
+static struct session *
+cmd_find_try_TMUX(struct client *c)
 {
 	struct environ_entry	*envent;
 	char			 tmp[256];
 	long long		 pid;
 	u_int			 session;
-	struct session		*s;

 	envent = environ_find(c->environ, "TMUX");
 	if (envent == NULL)
@@ -97,17 +91,28 @@ cmd_find_try_TMUX(struct client *c, struct window *w)
 		return (NULL);
 	if (pid != getpid())
 		return (NULL);
-	log_debug("client %p TMUX is %s (session @%u)", c, envent->value,
-	    session);
+	log_debug("client %p TMUX %s (session @%u)", c, envent->value, session);
+	return (session_find_by_id(session));
+}

-	s = session_find_by_id(session);
-	if (s == NULL || (w != NULL && !session_has(s, w)))
+/* Find pane containing client if any. */
+static struct window_pane *
+cmd_find_inside_pane(struct client *c)
+{
+	struct window_pane	*wp;
+
+	if (c == NULL)
 		return (NULL);
-	return (s);
+
+	RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
+		if (strcmp(wp->tty, c->ttyname) == 0)
+			break;
+	}
+	return (wp);
 }

 /* Is this client better? */
-int
+static int
 cmd_find_client_better(struct client *c, struct client *than)
 {
 	if (than == NULL)
@@ -115,34 +120,29 @@ cmd_find_client_better(struct client *c, struct client *than)
 	return (timercmp(&c->activity_time, &than->activity_time, >));
 }

-/* Find best client from a list, or all if list is NULL. */
-struct client *
-cmd_find_best_client(struct client **clist, u_int csize)
+/* Find best client for session. */
+static struct client *
+cmd_find_best_client(struct session *s)
 {
 	struct client	*c_loop, *c;
-	u_int		 i;
+
+	if (s->flags & SESSION_UNATTACHED)
+		s = NULL;

 	c = NULL;
-	if (clist != NULL) {
-		for (i = 0; i < csize; i++) {
-			if (clist[i]->session == NULL)
-				continue;
-			if (cmd_find_client_better(clist[i], c))
-				c = clist[i];
-		}
-	} else {
-		TAILQ_FOREACH(c_loop, &clients, entry) {
-			if (c_loop->session == NULL)
-				continue;
-			if (cmd_find_client_better(c_loop, c))
-				c = c_loop;
-		}
+	TAILQ_FOREACH(c_loop, &clients, entry) {
+		if (c_loop->session == NULL)
+			continue;
+		if (s != NULL && c_loop->session != s)
+			continue;
+		if (cmd_find_client_better(c_loop, c))
+			c = c_loop;
 	}
 	return (c);
 }

 /* Is this session better? */
-int
+static int
 cmd_find_session_better(struct session *s, struct session *than, int flags)
 {
 	int	attached;
@@ -160,7 +160,7 @@ cmd_find_session_better(struct session *s, struct session *than, int flags)
 }

 /* Find best session from a list, or all if list is NULL. */
-struct session *
+static struct session *
 cmd_find_best_session(struct session **slist, u_int ssize, int flags)
 {
 	struct session	 *s_loop, *s;
@@ -182,19 +182,13 @@ cmd_find_best_session(struct session **slist, u_int ssize, int flags)
 }

 /* Find best session and winlink for window. */
-int
+static int
 cmd_find_best_session_with_window(struct cmd_find_state *fs)
 {
 	struct session	**slist = NULL;
 	u_int		  ssize;
 	struct session	 *s;

-	if (fs->cmdq != NULL && fs->cmdq->client != NULL) {
-		fs->s = cmd_find_try_TMUX(fs->cmdq->client, fs->w);
-		if (fs->s != NULL)
-			return (cmd_find_best_winlink_with_window(fs));
-	}
-
 	ssize = 0;
 	RB_FOREACH(s, sessions, &sessions) {
 		if (!session_has(s, fs->w))
@@ -219,13 +213,13 @@ fail:
 * Find the best winlink for a window (the current if it contains the pane,
 * otherwise the first).
 */
-int
+static int
 cmd_find_best_winlink_with_window(struct cmd_find_state *fs)
 {
 	struct winlink	 *wl, *wl_loop;

 	wl = NULL;
-	if (fs->s->curw->window == fs->w)
+	if (fs->s->curw != NULL && fs->s->curw->window == fs->w)
 		wl = fs->s->curw;
 	else {
 		RB_FOREACH(wl_loop, winlinks, &fs->s->windows) {
@@ -242,148 +236,8 @@ cmd_find_best_winlink_with_window(struct cmd_find_state *fs)
 	return (0);
 }

-/* Find current session when we have an unattached client. */
-int
-cmd_find_current_session_with_client(struct cmd_find_state *fs)
-{
-	struct window_pane	*wp;
-
-	/*
-	 * If this is running in a pane, we can use that to limit the list of
-	 * sessions to those containing that pane (we still use the current
-	 * window in the best session).
-	 */
-	if (fs->cmdq != NULL && fs->cmdq->client->tty.path != NULL) {
-		RB_FOREACH(wp, window_pane_tree, &all_window_panes) {
-			if (strcmp(wp->tty, fs->cmdq->client->tty.path) == 0)
-				break;
-		}
-	} else
-		wp = NULL;
-
-	/* Not running in a pane. We know nothing. Find the best session. */
-	if (wp == NULL)
-		goto unknown_pane;
-
-	/* Find the best session and winlink containing this pane. */
-	fs->w = wp->window;
-	if (cmd_find_best_session_with_window(fs) != 0) {
-		if (wp != NULL) {
-			/*
-			 * The window may have been destroyed but the pane
-			 * still on all_window_panes due to something else
-			 * holding a reference.
-			 */
-			goto unknown_pane;
-		}
-		return (-1);
-	}
-
-	/* Use the current window and pane from this session. */
-	fs->wl = fs->s->curw;
-	fs->idx = fs->wl->idx;
-	fs->w = fs->wl->window;
-	fs->wp = fs->w->active;
-
-	return (0);
-
-unknown_pane:
-	fs->s = NULL;
-	if (fs->cmdq != NULL)
-		fs->s = cmd_find_try_TMUX(fs->cmdq->client, NULL);
-	if (fs->s == NULL)
-		fs->s = cmd_find_best_session(NULL, 0, fs->flags);
-	if (fs->s == NULL)
-		return (-1);
-	fs->wl = fs->s->curw;
-	fs->idx = fs->wl->idx;
-	fs->w = fs->wl->window;
-	fs->wp = fs->w->active;
-
-	return (0);
-}
-
-/*
- * Work out the best current state. If this function succeeds, the state is
- * guaranteed to be completely filled in.
- */
-int
-cmd_find_current_session(struct cmd_find_state *fs)
-{
-	/* If we know the current client, use it. */
-	if (fs->cmdq != NULL && fs->cmdq->client != NULL) {
-		log_debug("%s: have client %p%s", __func__, fs->cmdq->client,
-		    fs->cmdq->client->session == NULL ? "" : " (with session)");
-		if (fs->cmdq->client->session == NULL)
-			return (cmd_find_current_session_with_client(fs));
-		fs->s = fs->cmdq->client->session;
-		fs->wl = fs->s->curw;
-		fs->idx = fs->wl->idx;
-		fs->w = fs->wl->window;
-		fs->wp = fs->w->active;
-		return (0);
-	}
-
-	/* We know nothing, find the best session and client. */
-	fs->s = cmd_find_best_session(NULL, 0, fs->flags);
-	if (fs->s == NULL)
-		return (-1);
-	fs->wl = fs->s->curw;
-	fs->idx = fs->wl->idx;
-	fs->w = fs->wl->window;
-	fs->wp = fs->w->active;
-
-	return (0);
-}
-
-/* Work out the best current client. */
-struct client *
-cmd_find_current_client(struct cmd_q *cmdq)
-{
-	struct cmd_find_state	 current;
-	struct session		*s;
-	struct client		*c, **clist = NULL;
-	u_int		 	 csize;
-
-	/* If the queue client has a session, use it. */
-	if (cmdq->client != NULL && cmdq->client->session != NULL) {
-		log_debug("%s: using cmdq %p client %p", __func__, cmdq,
-		    cmdq->client);
-		return (cmdq->client);
-	}
-
-	/* Otherwise find the current session. */
-	cmd_find_clear_state(&current, cmdq, 0);
-	if (cmd_find_current_session(&current) != 0)
-		return (NULL);
-
-	/* If it is attached, find the best of it's clients. */
-	s = current.s;
-	log_debug("%s: current session $%u %s", __func__, s->id, s->name);
-	if (~s->flags & SESSION_UNATTACHED) {
-		csize = 0;
-		TAILQ_FOREACH(c, &clients, entry) {
-			if (c->session != s)
-				continue;
-			clist = xreallocarray(clist, csize + 1, sizeof *clist);
-			clist[csize++] = c;
-		}
-		if (csize != 0) {
-			c = cmd_find_best_client(clist, csize);
-			if (c != NULL) {
-				free(clist);
-				return (c);
-			}
-		}
-		free(clist);
-	}
-
-	/* Otherwise pick best of all clients. */
-	return (cmd_find_best_client(NULL, 0));
-}
-
 /* Maps string in table. */
-const char *
+static const char *
 cmd_find_map_table(const char *table[][2], const char *s)
 {
 	u_int	i;
@@ -396,7 +250,7 @@ cmd_find_map_table(const char *table[][2], const char *s)
 }

 /* Find session from string. Fills in s. */
-int
+static int
 cmd_find_get_session(struct cmd_find_state *fs, const char *session)
 {
 	struct session	*s, *s_loop;
@@ -460,8 +314,8 @@ cmd_find_get_session(struct cmd_find_state *fs, const char *session)
 }

 /* Find window from string. Fills in s, wl, w. */
-int
-cmd_find_get_window(struct cmd_find_state *fs, const char *window)
+static int
+cmd_find_get_window(struct cmd_find_state *fs, const char *window, int only)
 {
 	log_debug("%s: %s", __func__, window);

@@ -481,7 +335,7 @@ cmd_find_get_window(struct cmd_find_state *fs, const char *window)
 		return (0);

 	/* Otherwise try as a session itself. */
-	if (cmd_find_get_session(fs, window) == 0) {
+	if (!only && cmd_find_get_session(fs, window) == 0) {
 		fs->wl = fs->s->curw;
 		fs->w = fs->wl->window;
 		if (~fs->flags & CMD_FIND_WINDOW_INDEX)
@@ -496,7 +350,7 @@ cmd_find_get_window(struct cmd_find_state *fs, const char *window)
 * Find window from string, assuming it is in given session. Needs s, fills in
 * wl and w.
 */
-int
+static int
 cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)
 {
 	struct winlink	*wl;
@@ -646,19 +500,9 @@ cmd_find_get_window_with_session(struct cmd_find_state *fs, const char *window)
 	return (-1);
 }

-/* Find window from given pane. Needs wp, fills in s and wl and w. */
-int
-cmd_find_get_window_with_pane(struct cmd_find_state *fs)
-{
-	log_debug("%s", __func__);
-
-	fs->w = fs->wp->window;
-	return (cmd_find_best_session_with_window(fs));
-}
-
 /* Find pane from string. Fills in s, wl, w, wp. */
-int
-cmd_find_get_pane(struct cmd_find_state *fs, const char *pane)
+static int
+cmd_find_get_pane(struct cmd_find_state *fs, const char *pane, int only)
 {
 	log_debug("%s: %s", __func__, pane);

@@ -682,7 +526,7 @@ cmd_find_get_pane(struct cmd_find_state *fs, const char *pane)
 		return (0);

 	/* Otherwise try as a window itself (this will also try as session). */
-	if (cmd_find_get_window(fs, pane) == 0) {
+	if (!only && cmd_find_get_window(fs, pane, 0) == 0) {
 		fs->wp = fs->w->active;
 		return (0);
 	}
@@ -694,7 +538,7 @@ cmd_find_get_pane(struct cmd_find_state *fs, const char *pane)
 * Find pane from string, assuming it is in given session. Needs s, fills in wl
 * and w and wp.
 */
-int
+static int
 cmd_find_get_pane_with_session(struct cmd_find_state *fs, const char *pane)
 {
 	log_debug("%s: %s", __func__, pane);
@@ -721,7 +565,7 @@ cmd_find_get_pane_with_session(struct cmd_find_state *fs, const char *pane)
 * Find pane from string, assuming it is in the given window. Needs w, fills in
 * wp.
 */
-int
+static int
 cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 {
 	const char		*errstr;
@@ -734,7 +578,9 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 	/* Check for pane ids starting with %. */
 	if (*pane == '%') {
 		fs->wp = window_pane_find_by_id_str(pane);
-		if (fs->wp == NULL || fs->wp->window != fs->w)
+		if (fs->wp == NULL)
+			return (-1);
+		if (fs->wp->window != fs->w)
 			return (-1);
 		return (0);
 	}
@@ -744,6 +590,8 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)
 		if (fs->w->last == NULL)
 			return (-1);
 		fs->wp = fs->w->last;
+		if (fs->wp == NULL)
+			return (-1);
 		return (0);
 	} else if (strcmp(pane, "{up-of}") == 0) {
 		fs->wp = window_pane_find_up(fs->w->active);
@@ -800,16 +648,24 @@ cmd_find_get_pane_with_window(struct cmd_find_state *fs, const char *pane)

 /* Clear state. */
 void
-cmd_find_clear_state(struct cmd_find_state *fs, struct cmd_q *cmdq, int flags)
+cmd_find_clear_state(struct cmd_find_state *fs, int flags)
 {
 	memset(fs, 0, sizeof *fs);

-	fs->cmdq = cmdq;
 	fs->flags = flags;

 	fs->idx = -1;
 }

+/* Check if state is empty. */
+int
+cmd_find_empty_state(struct cmd_find_state *fs)
+{
+	if (fs->s == NULL && fs->wl == NULL && fs->w == NULL && fs->wp == NULL)
+		return (1);
+	return (0);
+}
+
 /* Check if a state if valid. */
 int
 cmd_find_valid_state(struct cmd_find_state *fs)
@@ -832,9 +688,7 @@ cmd_find_valid_state(struct cmd_find_state *fs)
 	if (fs->w != fs->wl->window)
 		return (0);

-	if (!window_has_pane(fs->w, fs->wp))
-		return (0);
-	return (window_pane_visible(fs->wp));
+	return (window_has_pane(fs->w, fs->wp));
 }

 /* Copy a state. */
@@ -872,10 +726,10 @@ cmd_find_log_state(const char *prefix, struct cmd_find_state *fs)
 }

 /* Find state from a session. */
-int
-cmd_find_from_session(struct cmd_find_state *fs, struct session *s)
+void
+cmd_find_from_session(struct cmd_find_state *fs, struct session *s, int flags)
 {
-	cmd_find_clear_state(fs, NULL, 0);
+	cmd_find_clear_state(fs, flags);

 	fs->s = s;
 	fs->wl = fs->s->curw;
@@ -883,46 +737,83 @@ cmd_find_from_session(struct cmd_find_state *fs, struct session *s)
 	fs->wp = fs->w->active;

 	cmd_find_log_state(__func__, fs);
-	return (0);
 }

 /* Find state from a winlink. */
-int
-cmd_find_from_winlink(struct cmd_find_state *fs, struct session *s,
-    struct winlink *wl)
+void
+cmd_find_from_winlink(struct cmd_find_state *fs, struct winlink *wl, int flags)
 {
-	cmd_find_clear_state(fs, NULL, 0);
+	cmd_find_clear_state(fs, flags);

-	fs->s = s;
+	fs->s = wl->session;
 	fs->wl = wl;
 	fs->w = wl->window;
 	fs->wp = wl->window->active;

+	cmd_find_log_state(__func__, fs);
+}
+
+/* Find state from a session and window. */
+int
+cmd_find_from_session_window(struct cmd_find_state *fs, struct session *s,
+    struct window *w, int flags)
+{
+	cmd_find_clear_state(fs, flags);
+
+	fs->s = s;
+	fs->w = w;
+	if (cmd_find_best_winlink_with_window(fs) != 0) {
+		cmd_find_clear_state(fs, flags);
+		return (-1);
+	}
+	fs->wp = fs->w->active;
+
 	cmd_find_log_state(__func__, fs);
 	return (0);
 }

 /* Find state from a window. */
 int
-cmd_find_from_window(struct cmd_find_state *fs, struct window *w)
+cmd_find_from_window(struct cmd_find_state *fs, struct window *w, int flags)
 {
-	cmd_find_clear_state(fs, NULL, 0);
+	cmd_find_clear_state(fs, flags);

 	fs->w = w;
-	if (cmd_find_best_session_with_window(fs) != 0)
+	if (cmd_find_best_session_with_window(fs) != 0) {
+		cmd_find_clear_state(fs, flags);
 		return (-1);
-	if (cmd_find_best_winlink_with_window(fs) != 0)
+	}
+	if (cmd_find_best_winlink_with_window(fs) != 0) {
+		cmd_find_clear_state(fs, flags);
 		return (-1);
+	}
+	fs->wp = fs->w->active;

 	cmd_find_log_state(__func__, fs);
 	return (0);
 }

+/* Find state from a winlink and pane. */
+void
+cmd_find_from_winlink_pane(struct cmd_find_state *fs, struct winlink *wl,
+    struct window_pane *wp, int flags)
+{
+	cmd_find_clear_state(fs, flags);
+
+	fs->s = wl->session;
+	fs->wl = wl;
+	fs->idx = fs->wl->idx;
+	fs->w = fs->wl->window;
+	fs->wp = wp;
+
+	cmd_find_log_state(__func__, fs);
+}
+
 /* Find state from a pane. */
 int
-cmd_find_from_pane(struct cmd_find_state *fs, struct window_pane *wp)
+cmd_find_from_pane(struct cmd_find_state *fs, struct window_pane *wp, int flags)
 {
-	if (cmd_find_from_window(fs, wp->window) != 0)
+	if (cmd_find_from_window(fs, wp->window, flags) != 0)
 		return (-1);
 	fs->wp = wp;

@@ -930,48 +821,183 @@ cmd_find_from_pane(struct cmd_find_state *fs, struct window_pane *wp)
 	return (0);
 }

-/* Find current state. */
+/* Find state from nothing. */
 int
-cmd_find_current(struct cmd_find_state *fs, struct cmd_q *cmdq, int flags)
+cmd_find_from_nothing(struct cmd_find_state *fs, int flags)
 {
-	cmd_find_clear_state(fs, cmdq, flags);
-	if (cmd_find_current_session(fs) != 0) {
-		if (~flags & CMD_FIND_QUIET)
-			cmdq_error(cmdq, "no current session");
+	cmd_find_clear_state(fs, flags);
+
+	fs->s = cmd_find_best_session(NULL, 0, flags);
+	if (fs->s == NULL) {
+		cmd_find_clear_state(fs, flags);
 		return (-1);
 	}
+	fs->wl = fs->s->curw;
+	fs->idx = fs->wl->idx;
+	fs->w = fs->wl->window;
+	fs->wp = fs->w->active;
+
+	cmd_find_log_state(__func__, fs);
 	return (0);
 }

+/* Find state from mouse. */
+int
+cmd_find_from_mouse(struct cmd_find_state *fs, struct mouse_event *m, int flags)
+{
+	cmd_find_clear_state(fs, flags);
+
+	if (!m->valid)
+		return (-1);
+
+	fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);
+	if (fs->wp == NULL) {
+		cmd_find_clear_state(fs, flags);
+		return (-1);
+	}
+	fs->w = fs->wl->window;
+
+	cmd_find_log_state(__func__, fs);
+	return (0);
+}
+
+/* Find state from client. */
+int
+cmd_find_from_client(struct cmd_find_state *fs, struct client *c, int flags)
+{
+	struct session		*s;
+	struct winlink		*wl;
+	struct window_pane	*wp;
+
+	/* If no client, treat as from nothing. */
+	if (c == NULL)
+		return (cmd_find_from_nothing(fs, flags));
+
+	/* If this is an attached client, all done. */
+	if (c->session != NULL) {
+		cmd_find_from_session(fs, c->session, flags);
+		return (0);
+	}
+	cmd_find_clear_state(fs, flags);
+
+	/*
+	 * If this is an unattached client running in a pane, we can use that
+	 * to limit the list of sessions to those containing that pane.
+	 */
+	wp = cmd_find_inside_pane(c);
+	if (wp == NULL)
+		goto unknown_pane;
+
+	/* If we have a session in TMUX, see if it has this pane. */
+	s = cmd_find_try_TMUX(c);
+	if (s != NULL) {
+		RB_FOREACH(wl, winlinks, &s->windows) {
+			if (window_has_pane(wl->window, wp))
+				break;
+		}
+		if (wl != NULL) {
+			fs->s = s;
+			fs->wl = s->curw; /* use current session */
+			fs->w = fs->wl->window;
+			fs->wp = fs->w->active; /* use active pane */
+
+			cmd_find_log_state(__func__, fs);
+			return (0);
+		}
+	}
+
+	/*
+	 * Don't have a session, or it doesn't have this pane. Try all
+	 * sessions.
+	 */
+	fs->w = wp->window;
+	if (cmd_find_best_session_with_window(fs) != 0) {
+		if (wp != NULL) {
+			/*
+			 * The window may have been destroyed but the pane
+			 * still on all_window_panes due to something else
+			 * holding a reference.
+			 */
+			goto unknown_pane;
+		}
+		cmd_find_clear_state(fs, 0);
+		return (-1);
+	}
+	fs->wl = fs->s->curw;
+	fs->w = fs->wl->window;
+	fs->wp = fs->w->active; /* use active pane */
+
+	cmd_find_log_state(__func__, fs);
+	return (0);
+
+unknown_pane:
+	/*
+	 * We're not running in a known pane, but maybe this client has TMUX
+	 * in the environment. That'd give us a session.
+	 */
+	s = cmd_find_try_TMUX(c);
+	if (s != NULL) {
+		cmd_find_from_session(fs, s, flags);
+		return (0);
+	}
+
+	/* Otherwise we need to guess. */
+	return (cmd_find_from_nothing(fs, flags));
+}
+
 /*
 * Split target into pieces and resolve for the given type. Fills in the given
 * state. Returns 0 on success or -1 on error.
 */
 int
-cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
-    struct cmd_q *cmdq, const char *target, enum cmd_find_type type, int flags)
+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 cmd_find_state	 current;
 	char			*colon, *period, *copy = NULL;
-	const char		*session, *window, *pane;
+	const char		*session, *window, *pane, *s;
+	int			 window_only = 0, pane_only = 0;
+
+	/* Can fail flag implies quiet. */
+	if (flags & CMD_FIND_CANFAIL)
+		flags |= CMD_FIND_QUIET;

 	/* Log the arguments. */
-	if (target == NULL)
-		log_debug("%s: target none, type %d", __func__, type);
+	if (type == CMD_FIND_PANE)
+		s = "pane";
+	else if (type == CMD_FIND_WINDOW)
+		s = "window";
+	else if (type == CMD_FIND_SESSION)
+		s = "session";
 	else
-		log_debug("%s: target %s, type %d", __func__, target, type);
-	log_debug("%s: cmdq %p, flags %#x", __func__, cmdq, flags);
+		s = "unknown";
+	if (target == NULL)
+		log_debug("%s: target none, type %s", __func__, s);
+	else
+		log_debug("%s: target %s, type %s", __func__, target, s);
+	log_debug("%s: item %p, flags %#x", __func__, item, flags);

 	/* Clear new state. */
-	cmd_find_clear_state(fs, cmdq, flags);
+	cmd_find_clear_state(fs, flags);

 	/* Find current state. */
-	if (server_check_marked() && (flags & CMD_FIND_DEFAULT_MARKED))
+	if (server_check_marked() && (flags & CMD_FIND_DEFAULT_MARKED)) {
 		fs->current = &marked_pane;
-	else if (cmd_find_valid_state(&cmdq->current))
-		fs->current = &cmdq->current;
-	else
-		fs->current = current;
+		log_debug("%s: current is marked pane", __func__);
+	} 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, item->client, flags) == 0) {
+		fs->current = &current;
+		log_debug("%s: current is from client", __func__);
+	} else {
+		if (~flags & CMD_FIND_QUIET)
+			cmdq_error(item, "no current target");
+		goto error;
+	}
+	if (!cmd_find_valid_state(fs->current))
+		fatalx("invalid current find state");

 	/* An empty or NULL target is the current. */
 	if (target == NULL || *target == '\0')
@@ -979,7 +1005,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,

 	/* Mouse target is a plain = or {mouse}. */
 	if (strcmp(target, "=") == 0 || strcmp(target, "{mouse}") == 0) {
-		m = &cmdq->item->mouse;
+		m = &item->shared->mouse;
 		switch (type) {
 		case CMD_FIND_PANE:
 			fs->wp = cmd_mouse_pane(m, &fs->s, &fs->wl);
@@ -997,7 +1023,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 		}
 		if (fs->wp == NULL) {
 			if (~flags & CMD_FIND_QUIET)
-				cmdq_error(cmdq, "no mouse target");
+				cmdq_error(item, "no mouse target");
 			goto error;
 		}
 		goto found;
@@ -1007,7 +1033,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	if (strcmp(target, "~") == 0 || strcmp(target, "{marked}") == 0) {
 		if (!server_check_marked()) {
 			if (~flags & CMD_FIND_QUIET)
-				cmdq_error(cmdq, "no marked target");
+				cmdq_error(item, "no marked target");
 			goto error;
 		}
 		cmd_find_copy_state(fs, &marked_pane);
@@ -1031,13 +1057,17 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	if (colon != NULL && period != NULL) {
 		session = copy;
 		window = colon;
+		window_only = 1;
 		pane = period;
+		pane_only = 1;
 	} else if (colon != NULL && period == NULL) {
 		session = copy;
 		window = colon;
+		window_only = 1;
 	} else if (colon == NULL && period != NULL) {
 		window = copy;
 		pane = period;
+		pane_only = 1;
 	} else {
 		if (*copy == '$')
 			session = copy;
@@ -1086,14 +1116,14 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	if (pane != NULL)
 		pane = cmd_find_map_table(cmd_find_pane_table, pane);

-	log_debug("target %s (flags %#x): session=%s, window=%s, pane=%s",
-	    target, flags, session == NULL ? "none" : session,
+	log_debug("%s: target %s (flags %#x): session=%s, window=%s, pane=%s",
+	    __func__, target, flags, session == NULL ? "none" : session,
 	    window == NULL ? "none" : window, pane == NULL ? "none" : pane);

 	/* No pane is allowed if want an index. */
 	if (pane != NULL && (flags & CMD_FIND_WINDOW_INDEX)) {
 		if (~flags & CMD_FIND_QUIET)
-			cmdq_error(cmdq, "can't specify pane here");
+			cmdq_error(item, "can't specify pane here");
 		goto error;
 	}

@@ -1144,7 +1174,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	/* No session. If window and pane, try them. */
 	if (window != NULL && pane != NULL) {
 		/* This will fill in session, winlink and window. */
-		if (cmd_find_get_window(fs, window) != 0)
+		if (cmd_find_get_window(fs, window, window_only) != 0)
 			goto no_window;
 		/* This will fill in pane. */
 		if (cmd_find_get_pane_with_window(fs, pane) != 0)
@@ -1155,7 +1185,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	/* If just window is present, try it. */
 	if (window != NULL && pane == NULL) {
 		/* This will fill in session, winlink and window. */
-		if (cmd_find_get_window(fs, window) != 0)
+		if (cmd_find_get_window(fs, window, window_only) != 0)
 			goto no_window;
 		fs->wp = fs->wl->window->active;
 		goto found;
@@ -1164,7 +1194,7 @@ cmd_find_target(struct cmd_find_state *fs, struct cmd_find_state *current,
 	/* If just pane is present, try it. */
 	if (window == NULL && pane != NULL) {
 		/* This will fill in session, winlink, window and pane. */
-		if (cmd_find_get_pane(fs, pane) != 0)
+		if (cmd_find_get_pane(fs, pane, pane_only) != 0)
 			goto no_pane;
 		goto found;
 	}
@@ -1178,9 +1208,11 @@ current:

 error:
 	fs->current = NULL;
-	log_debug("    error");
+	log_debug("%s: error", __func__);

 	free(copy);
+	if (flags & CMD_FIND_CANFAIL)
+		return (0);
 	return (-1);

 found:
@@ -1192,37 +1224,60 @@ found:

 no_session:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(cmdq, "can't find session %s", session);
+		cmdq_error(item, "can't find session %s", session);
 	goto error;

 no_window:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(cmdq, "can't find window %s", window);
+		cmdq_error(item, "can't find window %s", window);
 	goto error;

 no_pane:
 	if (~flags & CMD_FIND_QUIET)
-		cmdq_error(cmdq, "can't find pane %s", pane);
+		cmdq_error(item, "can't find pane %s", pane);
 	goto error;
 }

+/* Find the current client. */
+static struct client *
+cmd_find_current_client(struct cmdq_item *item, int quiet)
+{
+	struct client		*c;
+	struct session		*s;
+	struct window_pane	*wp;
+	struct cmd_find_state	 fs;
+
+	if (item->client != NULL && item->client->session != NULL)
+		return (item->client);
+
+	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)
+			c = cmd_find_best_client(fs.s);
+	} else {
+		s = cmd_find_best_session(NULL, 0, CMD_FIND_QUIET);
+		if (s != NULL)
+			c = cmd_find_best_client(s);
+	}
+	if (c == NULL && !quiet)
+		cmdq_error(item, "no current client");
+	log_debug("%s: no target, return %p", __func__, c);
+	return (c);
+}
+
 /* Find the target client or report an error and return NULL. */
 struct client *
-cmd_find_client(struct cmd_q *cmdq, const char *target, int quiet)
+cmd_find_client(struct cmdq_item *item, const char *target, int quiet)
 {
 	struct client	*c;
 	char		*copy;
 	size_t		 size;
-	const char	*path;

 	/* A NULL argument means the current client. */
-	if (cmdq != NULL && target == NULL) {
-		c = cmd_find_current_client(cmdq);
-		if (c == NULL && !quiet)
-			cmdq_error(cmdq, "no current client");
-		log_debug("%s: no target, return %p", __func__, c);
-		return (c);
-	}
+	if (target == NULL)
+		return (cmd_find_current_client(item, quiet));
 	copy = xstrdup(target);

 	/* Trim a single trailing colon if any. */
@@ -1230,26 +1285,26 @@ cmd_find_client(struct cmd_q *cmdq, const char *target, int quiet)
 	if (size != 0 && copy[size - 1] == ':')
 		copy[size - 1] = '\0';

-	/* Check path of each client. */
+	/* Check name and path of each client. */
 	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session == NULL || c->tty.path == NULL)
+		if (c->session == NULL)
 			continue;
-		path = c->tty.path;
-
-		/* Try for exact match. */
-		if (strcmp(copy, path) == 0)
+		if (strcmp(copy, c->name) == 0)
 			break;

-		/* Try without leading /dev. */
-		if (strncmp(path, _PATH_DEV, (sizeof _PATH_DEV) - 1) != 0)
+		if (*c->ttyname == '\0')
 			continue;
-		if (strcmp(copy, path + (sizeof _PATH_DEV) - 1) == 0)
+		if (strcmp(copy, c->ttyname) == 0)
+			break;
+		if (strncmp(c->ttyname, _PATH_DEV, (sizeof _PATH_DEV) - 1) != 0)
+			continue;
+		if (strcmp(copy, c->ttyname + (sizeof _PATH_DEV) - 1) == 0)
 			break;
 	}

 	/* If no client found, report an error. */
 	if (c == NULL && !quiet)
-		cmdq_error(cmdq, "can't find client %s", copy);
+		cmdq_error(item, "can't find client %s", copy);

 	free(copy);
 	log_debug("%s: target %s, return %p", __func__, target, c);
--- a/cmd-if-shell.c
+++ b/cmd-if-shell.c
@@ -29,11 +29,10 @@
 * Executes a tmux command if a shell command returns true or false.
 */

-enum cmd_retval	 cmd_if_shell_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_if_shell_exec(struct cmd *, struct cmdq_item *);

-void	cmd_if_shell_callback(struct job *);
-void	cmd_if_shell_done(struct cmd_q *);
-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",
@@ -43,48 +42,47 @@ const struct cmd_entry cmd_if_shell_entry = {
 	.usage = "[-bF] " CMD_TARGET_PANE_USAGE " shell-command command "
 		 "[command]",

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

 	.flags = 0,
 	.exec = cmd_if_shell_exec
 };

 struct cmd_if_shell_data {
+	char			*file;
+	u_int			 line;
+
 	char			*cmd_if;
 	char			*cmd_else;

-	struct cmd_q		*cmdq;
+	struct client		*client;
+	struct cmdq_item	*item;
 	struct mouse_event	 mouse;
-
-	int			 bflag;
-	int			 references;
 };

-enum cmd_retval
-cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_if_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
+	struct cmdq_shared		*shared = item->shared;
 	struct cmd_if_shell_data	*cdata;
 	char				*shellcmd, *cmd, *cause;
 	struct cmd_list			*cmdlist;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_pane		*wp = cmdq->state.tflag.wp;
-	struct format_tree		*ft;
+	struct cmdq_item		*new_item;
+	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			*cwd;

-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
+	if (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
 	else if (s != NULL)
 		cwd = s->cwd;
 	else
 		cwd = NULL;

-	ft = format_create(cmdq, 0);
-	format_defaults(ft, NULL, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);
-
+	shellcmd = format_single(item, args->argv[0], c, s, wl, wp);
 	if (args_has(args, 'F')) {
 		cmd = NULL;
 		if (*shellcmd != '0' && *shellcmd != '\0')
@@ -94,19 +92,25 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
 		free(shellcmd);
 		if (cmd == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
+		cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+		if (cmdlist == NULL) {
 			if (cause != NULL) {
-				cmdq_error(cmdq, "%s", cause);
+				cmdq_error(item, "%s", cause);
 				free(cause);
 			}
 			return (CMD_RETURN_ERROR);
 		}
-		cmdq_run(cmdq, cmdlist, &cmdq->item->mouse);
+		new_item = cmdq_get_command(cmdlist, NULL, &shared->mouse, 0);
+		cmdq_insert_after(item, new_item);
 		cmd_list_free(cmdlist);
 		return (CMD_RETURN_NORMAL);
 	}

-	cdata = xmalloc(sizeof *cdata);
+	cdata = xcalloc(1, sizeof *cdata);
+	if (self->file != NULL) {
+		cdata->file = xstrdup(self->file);
+		cdata->line = self->line;
+	}

 	cdata->cmd_if = xstrdup(args->argv[1]);
 	if (args->argc == 3)
@@ -114,91 +118,76 @@ cmd_if_shell_exec(struct cmd *self, struct cmd_q *cmdq)
 	else
 		cdata->cmd_else = NULL;

-	cdata->bflag = args_has(args, 'b');
+	cdata->client = item->client;
+	if (cdata->client != NULL)
+		cdata->client->references++;

-	cdata->cmdq = cmdq;
-	memcpy(&cdata->mouse, &cmdq->item->mouse, sizeof cdata->mouse);
-	cmdq->references++;
+	if (!args_has(args, 'b'))
+		cdata->item = item;
+	else
+		cdata->item = NULL;
+	memcpy(&cdata->mouse, &shared->mouse, sizeof cdata->mouse);

-	cdata->references = 1;
-	job_run(shellcmd, s, cwd, cmd_if_shell_callback, cmd_if_shell_free,
-	    cdata);
+	job_run(shellcmd, s, cwd, NULL, cmd_if_shell_callback,
+	    cmd_if_shell_free, cdata);
 	free(shellcmd);

-	if (cdata->bflag)
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }

-void
+static void
 cmd_if_shell_callback(struct job *job)
 {
 	struct cmd_if_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq, *cmdq1;
+	struct client			*c = cdata->client;
 	struct cmd_list			*cmdlist;
-	char				*cause, *cmd;
-
-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
+	struct cmdq_item		*new_item;
+	char				*cause, *cmd, *file = cdata->file;
+	u_int				 line = cdata->line;

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

-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
-		if (cause != NULL) {
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-		}
-		return;
+	cmdlist = cmd_string_parse(cmd, file, line, &cause);
+	if (cmdlist == NULL) {
+		if (cause != NULL && cdata->item != NULL)
+			cmdq_error(cdata->item, "%s", cause);
+		free(cause);
+		new_item = NULL;
+	} else {
+		new_item = cmdq_get_command(cmdlist, NULL, &cdata->mouse, 0);
+		cmd_list_free(cmdlist);
 	}

-	cmdq1 = cmdq_new(cmdq->client);
-	cmdq1->emptyfn = cmd_if_shell_done;
-	cmdq1->data = cdata;
+	if (new_item != NULL) {
+		if (cdata->item == NULL)
+			cmdq_append(c, new_item);
+		else
+			cmdq_insert_after(cdata->item, new_item);
+	}

-	cdata->references++;
-	cmdq_run(cmdq1, cmdlist, &cdata->mouse);
-	cmd_list_free(cmdlist);
+out:
+	if (cdata->item != NULL)
+		cdata->item->flags &= ~CMDQ_WAITING;
 }

-void
-cmd_if_shell_done(struct cmd_q *cmdq1)
-{
-	struct cmd_if_shell_data	*cdata = cmdq1->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-	cmdq_free(cmdq1);
-
-	if (--cdata->references != 0)
-		return;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
-
-	free(cdata->cmd_else);
-	free(cdata->cmd_if);
-	free(cdata);
-}
-
-void
+static void
 cmd_if_shell_free(void *data)
 {
 	struct cmd_if_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;

-	if (--cdata->references != 0)
-		return;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);
+	if (cdata->client != NULL)
+		server_client_unref(cdata->client);

 	free(cdata->cmd_else);
 	free(cdata->cmd_if);
+
+	free(cdata->file);
 	free(cdata);
 }
--- a/cmd-join-pane.c
+++ b/cmd-join-pane.c
@@ -28,9 +28,7 @@
 * Join or move a pane into another (like split/swap/kill).
 */

-enum cmd_retval	 cmd_join_pane_exec(struct cmd *, struct cmd_q *);
-
-enum cmd_retval	 join_pane(struct cmd *, struct cmd_q *, int);
+static enum cmd_retval	cmd_join_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_join_pane_entry = {
 	.name = "join-pane",
@@ -39,8 +37,8 @@ const struct cmd_entry cmd_join_pane_entry = {
 	.args = { "bdhvp:l:s:t:", 0, 0 },
 	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,

-	.sflag = CMD_PANE_MARKED,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },

 	.flags = 0,
 	.exec = cmd_join_pane_exec
@@ -53,23 +51,18 @@ const struct cmd_entry cmd_move_pane_entry = {
 	.args = { "bdhvp:l:s:t:", 0, 0 },
 	.usage = "[-bdhv] [-p percentage|-l size] " CMD_SRCDST_PANE_USAGE,

-	.sflag = CMD_PANE,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, 0 },
+	.target = { 't', CMD_FIND_PANE, 0 },

 	.flags = 0,
 	.exec = cmd_join_pane_exec
 };

-enum cmd_retval
-cmd_join_pane_exec(struct cmd *self, struct cmd_q *cmdq)
-{
-	return (join_pane(self, cmdq, self->entry == &cmd_join_pane_entry));
-}
-
-enum cmd_retval
-join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
+static enum cmd_retval
+cmd_join_pane_exec(struct cmd *self, struct cmdq_item *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;
@@ -78,25 +71,31 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	int			 size, percentage, dst_idx;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
+	int			 not_same_window;

-	dst_s = cmdq->state.tflag.s;
-	dst_wl = cmdq->state.tflag.wl;
-	dst_wp = cmdq->state.tflag.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;
 	server_unzoom_window(dst_w);

-	src_wl = cmdq->state.sflag.wl;
-	src_wp = cmdq->state.sflag.wp;
+	src_wl = item->source.wl;
+	src_wp = item->source.wp;
 	src_w = src_wl->window;
 	server_unzoom_window(src_w);

 	if (not_same_window && src_w == dst_w) {
-		cmdq_error(cmdq, "can't join a pane to its own window");
+		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(cmdq, "source and target panes must be different");
+		cmdq_error(item, "source and target panes must be different");
 		return (CMD_RETURN_ERROR);
 	}

@@ -108,14 +107,14 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (args_has(args, 'l')) {
 		size = args_strtonum(args, 'l', 0, INT_MAX, &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "size %s", cause);
+			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(cmdq, "percentage %s", cause);
+			cmdq_error(item, "percentage %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -124,9 +123,9 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 		else
 			size = (dst_wp->sx * percentage) / 100;
 	}
-	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'));
+	lc = layout_split_pane(dst_wp, type, size, args_has(args, 'b'), 0);
 	if (lc == NULL) {
-		cmdq_error(cmdq, "create pane failed: pane too small");
+		cmdq_error(item, "create pane failed: pane too small");
 		return (CMD_RETURN_ERROR);
 	}

@@ -135,11 +134,6 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	window_lost_pane(src_w, src_wp);
 	TAILQ_REMOVE(&src_w->panes, src_wp, entry);

-	if (window_count_panes(src_w) == 0)
-		server_kill_window(src_w);
-	else
-		notify_window_layout_changed(src_w);
-
 	src_wp->window = dst_w;
 	TAILQ_INSERT_AFTER(&dst_w->panes, dst_wp, src_wp, entry);
 	layout_assign_pane(lc, src_wp);
@@ -152,10 +146,16 @@ join_pane(struct cmd *self, struct cmd_q *cmdq, int not_same_window)
 	if (!args_has(args, 'd')) {
 		window_set_active_pane(dst_w, src_wp);
 		session_select(dst_s, dst_idx);
+		cmd_find_from_session(current, dst_s, 0);
 		server_redraw_session(dst_s);
 	} else
 		server_status_session(dst_s);

-	notify_window_layout_changed(dst_w);
+	if (window_count_panes(src_w) == 0)
+		server_kill_window(src_w);
+	else
+		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
@@ -26,7 +26,7 @@
 * Kill pane.
 */

-enum cmd_retval	 cmd_kill_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_kill_pane_entry = {
 	.name = "kill-pane",
@@ -35,27 +35,20 @@ const struct cmd_entry cmd_kill_pane_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_PANE_USAGE,

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

 	.flags = 0,
 	.exec = cmd_kill_pane_exec
 };

-enum cmd_retval
-cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct window_pane	*loopwp, *tmpwp, *wp = cmdq->state.tflag.wp;
+	struct winlink		*wl = item->target.wl;
+	struct window_pane	*loopwp, *tmpwp, *wp = item->target.wp;

 	server_unzoom_window(wl->window);

-	if (window_count_panes(wl->window) == 1) {
-		/* Only one pane, kill the window. */
-		server_kill_window(wl->window);
-		recalculate_sizes();
-		return (CMD_RETURN_NORMAL);
-	}
-
 	if (args_has(self->args, 'a')) {
 		TAILQ_FOREACH_SAFE(loopwp, &wl->window->panes, entry, tmpwp) {
 			if (loopwp == wp)
@@ -63,11 +56,17 @@ cmd_kill_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			layout_close_pane(loopwp);
 			window_remove_pane(wl->window, loopwp);
 		}
+		server_redraw_window(wl->window);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	if (window_count_panes(wl->window) == 1) {
+		server_kill_window(wl->window);
+		recalculate_sizes();
 	} else {
 		layout_close_pane(wp);
 		window_remove_pane(wl->window, wp);
+		server_redraw_window(wl->window);
 	}
-	server_redraw_window(wl->window);
-
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-kill-server.c
+++ b/cmd-kill-server.c
@@ -27,7 +27,7 @@
 * Kill the server and do nothing else.
 */

-enum cmd_retval	 cmd_kill_server_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_server_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_kill_server_entry = {
 	.name = "kill-server",
@@ -51,8 +51,8 @@ const struct cmd_entry cmd_start_server_entry = {
 	.exec = cmd_kill_server_exec
 };

-enum cmd_retval
-cmd_kill_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_server_exec(struct cmd *self, __unused struct cmdq_item *item)
 {
 	if (self->entry == &cmd_kill_server_entry)
 		kill(getpid(), SIGTERM);
--- a/cmd-kill-session.c
+++ b/cmd-kill-session.c
@@ -27,7 +27,7 @@
 * Note this deliberately has no alias to make it hard to hit by accident.
 */

-enum cmd_retval	 cmd_kill_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_session_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_kill_session_entry = {
 	.name = "kill-session",
@@ -36,20 +36,20 @@ const struct cmd_entry cmd_kill_session_entry = {
 	.args = { "aCt:", 0, 0 },
 	.usage = "[-aC] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = 0,
 	.exec = cmd_kill_session_exec
 };

-enum cmd_retval
-cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct session	*s, *sloop, *stmp;
 	struct winlink	*wl;

-	s = cmdq->state.tflag.s;
+	s = item->target.s;

 	if (args_has(args, 'C')) {
 		RB_FOREACH(wl, winlinks, &s->windows) {
@@ -61,12 +61,12 @@ cmd_kill_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		RB_FOREACH_SAFE(sloop, sessions, &sessions, stmp) {
 			if (sloop != s) {
 				server_destroy_session(sloop);
-				session_destroy(sloop);
+				session_destroy(sloop, __func__);
 			}
 		}
 	} else {
 		server_destroy_session(s);
-		session_destroy(s);
+		session_destroy(s, __func__);
 	}
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-kill-window.c
+++ b/cmd-kill-window.c
@@ -24,7 +24,7 @@
 * Destroy window.
 */

-enum cmd_retval	 cmd_kill_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_kill_window_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_kill_window_entry = {
 	.name = "kill-window",
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_kill_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_kill_window_exec
@@ -46,23 +46,23 @@ const struct cmd_entry cmd_unlink_window_entry = {
 	.args = { "kt:", 0, 0 },
 	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_kill_window_exec
 };

-enum cmd_retval
-cmd_kill_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_kill_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl, *wl2, *wl3;
+	struct winlink		*wl = item->target.wl, *wl2, *wl3;
 	struct window		*w = wl->window;
-	struct session		*s = cmdq->state.tflag.s;
+	struct session		*s = item->target.s;

 	if (self->entry == &cmd_unlink_window_entry) {
 		if (!args_has(self->args, 'k') && !session_is_linked(s, w)) {
-			cmdq_error(cmdq, "window only linked to one session");
+			cmdq_error(item, "window only linked to one session");
 			return (CMD_RETURN_ERROR);
 		}
 		server_unlink_window(s, wl);
--- a/cmd-list-buffers.c
+++ b/cmd-list-buffers.c
@@ -30,7 +30,7 @@
 #define LIST_BUFFERS_TEMPLATE						\
 	"#{buffer_name}: #{buffer_size} bytes: \"#{buffer_sample}\""

-enum cmd_retval	 cmd_list_buffers_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_buffers_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_list_buffers_entry = {
 	.name = "list-buffers",
@@ -39,12 +39,12 @@ const struct cmd_entry cmd_list_buffers_entry = {
 	.args = { "F:", 0, 0 },
 	.usage = "[-F format]",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_buffers_exec
 };

-enum cmd_retval
-cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_buffers_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct paste_buffer	*pb;
@@ -57,11 +57,11 @@ cmd_list_buffers_exec(struct cmd *self, struct cmd_q *cmdq)

 	pb = NULL;
 	while ((pb = paste_walk(pb)) != NULL) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_defaults_paste_buffer(ft, pb);

 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);

 		format_free(ft);
--- a/cmd-list-clients.c
+++ b/cmd-list-clients.c
@@ -29,11 +29,11 @@
 */

 #define LIST_CLIENTS_TEMPLATE					\
-	"#{client_tty}: #{session_name} "			\
+	"#{client_name}: #{session_name} "			\
 	"[#{client_width}x#{client_height} #{client_termname}]"	\
 	"#{?client_utf8, (utf8),} #{?client_readonly, (ro),}"

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

 const struct cmd_entry cmd_list_clients_entry = {
 	.name = "list-clients",
@@ -42,14 +42,14 @@ const struct cmd_entry cmd_list_clients_entry = {
 	.args = { "F:t:", 0, 0 },
 	.usage = "[-F format] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

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

-enum cmd_retval
-cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_clients_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args 		*args = self->args;
 	struct client		*c;
@@ -60,7 +60,7 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
 	char			*line;

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

@@ -72,12 +72,12 @@ cmd_list_clients_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (c->session == NULL || (s != NULL && s != c->session))
 			continue;

-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", idx);
 		format_defaults(ft, c, NULL, NULL, NULL);

 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);

 		format_free(ft);
--- a/cmd-list-keys.c
+++ b/cmd-list-keys.c
@@ -27,19 +27,19 @@
 * List key bindings.
 */

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

-enum cmd_retval	 cmd_list_keys_table(struct cmd *, struct cmd_q *);
-enum cmd_retval	 cmd_list_keys_commands(struct cmd_q *);
+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 = { "t:T:", 0, 0 },
-	.usage = "[-t mode-table] [-T key-table]",
+	.args = { "T:", 0, 0 },
+	.usage = "[-T key-table]",

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

@@ -47,15 +47,15 @@ const struct cmd_entry cmd_list_commands_entry = {
 	.name = "list-commands",
 	.alias = "lscm",

-	.args = { "", 0, 0 },
-	.usage = "",
+	.args = { "F:", 0, 0 },
+	.usage = "[-F format]",

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

-enum cmd_retval
-cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct key_table	*table;
@@ -65,14 +65,11 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 	int			 repeat, width, tablewidth, keywidth;

 	if (self->entry == &cmd_list_commands_entry)
-		return (cmd_list_keys_commands(cmdq));
-
-	if (args_has(args, 't'))
-		return (cmd_list_keys_table(self, cmdq));
+		return (cmd_list_keys_commands(self, item));

 	tablename = args_get(args, 'T');
 	if (tablename != NULL && key_bindings_get_table(tablename, 0) == NULL) {
-		cmdq_error(cmdq, "table %s doesn't exist", tablename);
+		cmdq_error(item, "table %s doesn't exist", tablename);
 		return (CMD_RETURN_ERROR);
 	}

@@ -84,7 +81,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 		RB_FOREACH(bd, key_bindings, &table->key_bindings) {
 			key = key_string_lookup_key(bd->key);

-			if (bd->can_repeat)
+			if (bd->flags & KEY_BINDING_REPEAT)
 				repeat = 1;

 			width = utf8_cstrwidth(table->name);
@@ -104,7 +101,7 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)

 			if (!repeat)
 				r = "";
-			else if (bd->can_repeat)
+			else if (bd->flags & KEY_BINDING_REPEAT)
 				r = "-r ";
 			else
 				r = "   ";
@@ -124,77 +121,53 @@ cmd_list_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 			strlcat(tmp, cp, sizeof tmp);
 			free(cp);

-			cmdq_print(cmdq, "bind-key %s", tmp);
+			cmdq_print(item, "bind-key %s", tmp);
 		}
 	}

 	return (CMD_RETURN_NORMAL);
 }

-enum cmd_retval
-cmd_list_keys_table(struct cmd *self, struct cmd_q *cmdq)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind;
-	const char			*key, *cmdstr, *mode;
-	int			 	 width, keywidth, any_mode;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	width = 0;
-	any_mode = 0;
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		if (mbind->mode != 0)
-			any_mode = 1;
-
-		keywidth = strlen(key);
-		if (keywidth > width)
-			width = keywidth;
-	}
-
-	RB_FOREACH(mbind, mode_key_tree, mtab->tree) {
-		key = key_string_lookup_key(mbind->key);
-
-		mode = "";
-		if (mbind->mode != 0)
-			mode = "c";
-		cmdstr = mode_key_tostring(mtab->cmdstr, mbind->cmd);
-		if (cmdstr != NULL) {
-			cmdq_print(cmdq, "bind-key -%st %s%s %*s %s%s%s%s",
-			    mode, any_mode && *mode == '\0' ? " " : "",
-			    mtab->name, (int) width, key, cmdstr,
-			    mbind->arg != NULL ? " \"" : "",
-			    mbind->arg != NULL ? mbind->arg : "",
-			    mbind->arg != NULL ? "\"": "");
-		}
-	}
-
-	return (CMD_RETURN_NORMAL);
-}
-
-enum cmd_retval
-cmd_list_keys_commands(struct cmd_q *cmdq)
+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;
+	char			 *line;
+
+	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 (entry->alias == NULL) {
-			cmdq_print(cmdq, "%s %s", entry->name, entry->usage);
-			continue;
-		}
-		cmdq_print(cmdq, "%s (%s) %s", entry->name, entry->alias,
-		    entry->usage);
+
+		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
@@ -26,13 +26,13 @@
 * List panes on given window.
 */

-enum cmd_retval	 cmd_list_panes_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_panes_exec(struct cmd *, struct cmdq_item *);

-void	cmd_list_panes_server(struct cmd *, struct cmd_q *);
-void	cmd_list_panes_session(struct cmd *, struct session *, struct cmd_q *,
-	    int);
-void	cmd_list_panes_window(struct cmd *, struct session *, struct winlink *,
-	    struct cmd_q *, int);
+static void	cmd_list_panes_server(struct cmd *, struct cmdq_item *);
+static void	cmd_list_panes_session(struct cmd *, struct session *,
+		    struct cmdq_item *, int);
+static void	cmd_list_panes_window(struct cmd *, struct session *,
+		    struct winlink *, struct cmdq_item *, int);

 const struct cmd_entry cmd_list_panes_entry = {
 	.name = "list-panes",
@@ -41,51 +41,51 @@ const struct cmd_entry cmd_list_panes_entry = {
 	.args = { "asF:t:", 0, 0 },
 	.usage = "[-as] [-F format] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_panes_exec
 };

-enum cmd_retval
-cmd_list_panes_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_panes_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct session	*s = item->target.s;
+	struct winlink	*wl = item->target.wl;

 	if (args_has(args, 'a'))
-		cmd_list_panes_server(self, cmdq);
+		cmd_list_panes_server(self, item);
 	else if (args_has(args, 's'))
-		cmd_list_panes_session(self, s, cmdq, 1);
+		cmd_list_panes_session(self, s, item, 1);
 	else
-		cmd_list_panes_window(self, s, wl, cmdq, 0);
+		cmd_list_panes_window(self, s, wl, item, 0);

 	return (CMD_RETURN_NORMAL);
 }

-void
-cmd_list_panes_server(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_list_panes_server(struct cmd *self, struct cmdq_item *item)
 {
 	struct session	*s;

 	RB_FOREACH(s, sessions, &sessions)
-		cmd_list_panes_session(self, s, cmdq, 2);
+		cmd_list_panes_session(self, s, item, 2);
 }

-void
-cmd_list_panes_session(struct cmd *self, struct session *s, struct cmd_q *cmdq,
-    int type)
+static void
+cmd_list_panes_session(struct cmd *self, struct session *s,
+    struct cmdq_item *item, int type)
 {
 	struct winlink	*wl;

 	RB_FOREACH(wl, winlinks, &s->windows)
-		cmd_list_panes_window(self, s, wl, cmdq, type);
+		cmd_list_panes_window(self, s, wl, item, type);
 }

-void
+static void
 cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,
-    struct cmd_q *cmdq, int type)
+    struct cmdq_item *item, int type)
 {
 	struct args		*args = self->args;
 	struct window_pane	*wp;
@@ -123,12 +123,12 @@ cmd_list_panes_window(struct cmd *self, struct session *s, struct winlink *wl,

 	n = 0;
 	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		format_defaults(ft, NULL, s, wl, wp);

 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);

 		format_free(ft);
--- a/cmd-list-sessions.c
+++ b/cmd-list-sessions.c
@@ -36,7 +36,8 @@
 	"#{session_group}#{?session_grouped,),}"	\
 	"#{?session_attached, (attached),}"

-enum cmd_retval	 cmd_list_sessions_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_list_sessions_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_list_sessions_entry = {
 	.name = "list-sessions",
@@ -45,12 +46,12 @@ const struct cmd_entry cmd_list_sessions_entry = {
 	.args = { "F:", 0, 0 },
 	.usage = "[-F format]",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_sessions_exec
 };

-enum cmd_retval
-cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_sessions_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct session		*s;
@@ -64,12 +65,12 @@ cmd_list_sessions_exec(struct cmd *self, struct cmd_q *cmdq)

 	n = 0;
 	RB_FOREACH(s, sessions, &sessions) {
-		ft = format_create(cmdq, 0);
+		ft = format_create(item->client, item, FORMAT_NONE, 0);
 		format_add(ft, "line", "%u", n);
 		format_defaults(ft, NULL, s, NULL, NULL);

 		line = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);

 		format_free(ft);
--- a/cmd-list-windows.c
+++ b/cmd-list-windows.c
@@ -39,11 +39,11 @@
 	"(#{window_panes} panes) "				\
 	"[#{window_width}x#{window_height}] "

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

-void	cmd_list_windows_server(struct cmd *, struct cmd_q *);
-void	cmd_list_windows_session(struct cmd *, struct session *,
-	    struct cmd_q *, int);
+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",
@@ -52,41 +52,41 @@ const struct cmd_entry cmd_list_windows_entry = {
 	.args = { "F:at:", 0, 0 },
 	.usage = "[-a] [-F format] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_list_windows_exec
 };

-enum cmd_retval
-cmd_list_windows_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_list_windows_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;

 	if (args_has(args, 'a'))
-		cmd_list_windows_server(self, cmdq);
+		cmd_list_windows_server(self, item);
 	else
-		cmd_list_windows_session(self, cmdq->state.tflag.s, cmdq, 0);
+		cmd_list_windows_session(self, item->target.s, item, 0);

 	return (CMD_RETURN_NORMAL);
 }

-void
-cmd_list_windows_server(struct cmd *self, struct cmd_q *cmdq)
+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, cmdq, 1);
+		cmd_list_windows_session(self, s, item, 1);
 }

-void
+static void
 cmd_list_windows_session(struct cmd *self, struct session *s,
-    struct cmd_q *cmdq, int type)
+    struct cmdq_item *item, int type)
 {
 	struct args		*args = self->args;
 	struct winlink		*wl;
-	u_int			n;
+	u_int			 n;
 	struct format_tree	*ft;
 	const char		*template;
 	char			*line;
@@ -105,12 +105,12 @@ cmd_list_windows_session(struct cmd *self, struct session *s,

 	n = 0;
 	RB_FOREACH(wl, winlinks, &s->windows) {
-		ft = format_create(cmdq, 0);
+		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(cmdq, "%s", line);
+		cmdq_print(item, "%s", line);
 		free(line);

 		format_free(ft);
--- a/cmd-load-buffer.c
+++ b/cmd-load-buffer.c
@@ -31,8 +31,9 @@
 * Loads a paste buffer from a file.
 */

-enum cmd_retval	 cmd_load_buffer_exec(struct cmd *, struct cmd_q *);
-void		 cmd_load_buffer_callback(struct client *, int, void *);
+static enum cmd_retval	cmd_load_buffer_exec(struct cmd *, struct cmdq_item *);
+
+static void		cmd_load_buffer_callback(struct client *, int, void *);

 const struct cmd_entry cmd_load_buffer_entry = {
 	.name = "load-buffer",
@@ -41,21 +42,26 @@ const struct cmd_entry cmd_load_buffer_entry = {
 	.args = { "b:", 1, 1 },
 	.usage = CMD_BUFFER_USAGE " path",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_load_buffer_exec
 };

-enum cmd_retval
-cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+struct cmd_load_buffer_data {
+	struct cmdq_item	*item;
+	char			*bufname;
+};
+
+static enum cmd_retval
+cmd_load_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct client	*c = cmdq->client;
-	struct session  *s;
-	FILE		*f;
-	const char	*path, *bufname, *cwd;
-	char		*pdata, *new_pdata, *cause, *file, resolved[PATH_MAX];
-	size_t		 psize;
-	int		 ch, error;
+	struct args			*args = self->args;
+	struct cmd_load_buffer_data	*cdata;
+	struct client			*c = item->client;
+	FILE				*f;
+	const char			*path, *bufname;
+	char				*pdata, *new_pdata, *cause, *file;
+	size_t				 psize;
+	int				 ch, error;

 	bufname = NULL;
 	if (args_has(args, 'b'))
@@ -63,36 +69,27 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)

 	path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
+		cdata = xcalloc(1, sizeof *cdata);
+		cdata->item = item;
+
+		if (bufname != NULL)
+			cdata->bufname = xstrdup(bufname);
+
 		error = server_set_stdin_callback(c, cmd_load_buffer_callback,
-		    (void *)bufname, &cause);
+		    cdata, &cause);
 		if (error != 0) {
-			cmdq_error(cmdq, "%s: %s", path, cause);
+			cmdq_error(item, "%s: %s", path, cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
 		return (CMD_RETURN_WAIT);
 	}

-	if (c != NULL && c->session == NULL && c->cwd != NULL)
-		cwd = c->cwd;
-	else if ((s = c->session) != NULL && s->cwd != NULL)
-		cwd = s->cwd;
-	else
-		cwd = ".";
-
-	if (*path == '/')
-		file = xstrdup(path);
-	else
-		xasprintf(&file, "%s/%s", cwd, path);
-	if (realpath(file, resolved) == NULL &&
-	    strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
-		cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
-		return (CMD_RETURN_ERROR);
-	}
-	f = fopen(resolved, "rb");
-	free(file);
+	file = server_client_get_path(c, path);
+	f = fopen(file, "rb");
 	if (f == NULL) {
-		cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
+		cmdq_error(item, "%s: %s", file, strerror(errno));
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}

@@ -101,23 +98,24 @@ cmd_load_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	while ((ch = getc(f)) != EOF) {
 		/* Do not let the server die due to memory exhaustion. */
 		if ((new_pdata = realloc(pdata, psize + 2)) == NULL) {
-			cmdq_error(cmdq, "realloc error: %s", strerror(errno));
+			cmdq_error(item, "realloc error: %s", strerror(errno));
 			goto error;
 		}
 		pdata = new_pdata;
 		pdata[psize++] = ch;
 	}
 	if (ferror(f)) {
-		cmdq_error(cmdq, "%s: read error", resolved);
+		cmdq_error(item, "%s: read error", file);
 		goto error;
 	}
 	if (pdata != NULL)
 		pdata[psize] = '\0';

 	fclose(f);
+	free(file);

 	if (paste_set(pdata, psize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
+		cmdq_error(item, "%s", cause);
 		free(pdata);
 		free(cause);
 		return (CMD_RETURN_ERROR);
@@ -129,15 +127,16 @@ error:
 	free(pdata);
 	if (f != NULL)
 		fclose(f);
+	free(file);
 	return (CMD_RETURN_ERROR);
 }

-void
+static void
 cmd_load_buffer_callback(struct client *c, int closed, void *data)
 {
-	const char	*bufname = data;
-	char		*pdata, *cause, *saved;
-	size_t		 psize;
+	struct cmd_load_buffer_data	*cdata = data;
+	char				*pdata, *cause, *saved;
+	size_t				 psize;

 	if (!closed)
 		return;
@@ -145,7 +144,7 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)

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

 	psize = EVBUFFER_LENGTH(c->stdin_data);
 	if (psize == 0 || (pdata = malloc(psize + 1)) == NULL)
@@ -155,7 +154,7 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
 	pdata[psize] = '\0';
 	evbuffer_drain(c->stdin_data, psize);

-	if (paste_set(pdata, psize, bufname, &cause) != 0) {
+	if (paste_set(pdata, psize, cdata->bufname, &cause) != 0) {
 		/* No context so can't use server_client_msg_error. */
 		if (~c->flags & CLIENT_UTF8) {
 			saved = cause;
@@ -167,7 +166,9 @@ cmd_load_buffer_callback(struct client *c, int closed, void *data)
 		free(pdata);
 		free(cause);
 	}
-
 out:
-	cmdq_continue(c->cmdq);
+	cdata->item->flags &= ~CMDQ_WAITING;
+
+	free(cdata->bufname);
+	free(cdata);
 }
--- a/cmd-lock-server.c
+++ b/cmd-lock-server.c
@@ -24,7 +24,7 @@
 * Lock commands.
 */

-enum cmd_retval	 cmd_lock_server_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_lock_server_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_lock_server_entry = {
 	.name = "lock-server",
@@ -33,7 +33,7 @@ const struct cmd_entry cmd_lock_server_entry = {
 	.args = { "", 0, 0 },
 	.usage = "",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };

@@ -44,9 +44,9 @@ const struct cmd_entry cmd_lock_session_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };

@@ -57,22 +57,25 @@ const struct cmd_entry cmd_lock_client_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_CLIENT_USAGE,

-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_lock_server_exec
 };

-enum cmd_retval
-cmd_lock_server_exec(struct cmd *self, __unused struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_lock_server_exec(struct cmd *self, struct cmdq_item *item)
 {
+	struct args	*args = self->args;
+	struct client	*c;
+
 	if (self->entry == &cmd_lock_server_entry)
 		server_lock();
 	else if (self->entry == &cmd_lock_session_entry)
-		server_lock_session(cmdq->state.tflag.s);
-	else
-		server_lock_client(cmdq->state.c);
-
+		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
@@ -26,7 +26,7 @@
 * Move a window.
 */

-enum cmd_retval	 cmd_move_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_move_window_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_move_window_entry = {
 	.name = "move-window",
@@ -35,8 +35,8 @@ const struct cmd_entry cmd_move_window_entry = {
 	.args = { "adkrs:t:", 0, 0 },
 	.usage = "[-dkr] " CMD_SRCDST_WINDOW_USAGE,

-	.sflag = CMD_WINDOW,
-	.tflag = CMD_MOVEW_R,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */

 	.flags = 0,
 	.exec = cmd_move_window_exec
@@ -49,32 +49,42 @@ const struct cmd_entry cmd_link_window_entry = {
 	.args = { "adks:t:", 0, 0 },
 	.usage = "[-dk] " CMD_SRCDST_WINDOW_USAGE,

-	.sflag = CMD_WINDOW,
-	.tflag = CMD_WINDOW_INDEX,
+	.source = { 's', CMD_FIND_WINDOW, 0 },
+	/* -t is special */

 	.flags = 0,
 	.exec = cmd_move_window_exec
 };

-enum cmd_retval
-cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_move_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*src = cmdq->state.sflag.s;
-	struct session	*dst = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.sflag.wl;
+	const char	*tflag = args_get(args, 't');
+	struct session	*src;
+	struct session	*dst;
+	struct winlink	*wl;
 	char		*cause;
-	int		 idx = cmdq->state.tflag.idx, kflag, dflag, sflag;
-
-	kflag = args_has(self->args, 'k');
-	dflag = args_has(self->args, 'd');
+	int		 idx, kflag, dflag, sflag;

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

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

 	kflag = args_has(self->args, 'k');
 	dflag = args_has(self->args, 'd');
@@ -87,7 +97,7 @@ cmd_move_window_exec(struct cmd *self, struct cmd_q *cmdq)

 	if (server_link_window(src, wl, dst, idx, kflag, !dflag,
 	    &cause) != 0) {
-		cmdq_error(cmdq, "can't link window: %s", cause);
+		cmdq_error(item, "can't link window: %s", cause);
 		free(cause);
 		return (CMD_RETURN_ERROR);
 	}
--- a/cmd-new-session.c
+++ b/cmd-new-session.c
@@ -33,7 +33,7 @@

 #define NEW_SESSION_TEMPLATE "#{session_name}:"

-enum cmd_retval	 cmd_new_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_new_session_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_new_session_entry = {
 	.name = "new-session",
@@ -44,7 +44,7 @@ const struct cmd_entry cmd_new_session_entry = {
 		 "[-s session-name] " CMD_TARGET_SESSION_USAGE " [-x width] "
 		 "[-y height] [command]",

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

 	.flags = CMD_STARTSERVER,
 	.exec = cmd_new_session_exec
@@ -57,79 +57,91 @@ const struct cmd_entry cmd_has_session_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = 0,
 	.exec = cmd_new_session_exec
 };

-enum cmd_retval
-cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_new_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session		*s, *as;
-	struct session		*groupwith = cmdq->state.tflag.s;
+	struct client		*c = item->client;
+	struct session		*s, *as, *groupwith;
 	struct window		*w;
 	struct environ		*env;
 	struct termios		 tio, *tiop;
-	const char		*newname, *target, *update, *errstr, *template;
-	const char		*path, *cwd, *to_free = NULL;
-	char		       **argv, *cmd, *cause, *cp;
+	struct session_group	*sg;
+	const char		*newname, *errstr, *template, *group, *prefix;
+	const char		*path, *cmd, *cwd;
+	char		       **argv, *cause, *cp, *to_free = NULL;
 	int			 detached, already_attached, idx, argc;
+	int			 is_control = 0;
 	u_int			 sx, sy;
-	struct format_tree	*ft;
 	struct environ_entry	*envent;
+	struct cmd_find_state	 fs;

 	if (self->entry == &cmd_has_session_entry) {
 		/*
-		 * cmd_prepare() will fail if the session cannot be found,
-		 * hence always return success here.
+		 * cmd_find_target() will fail if the session cannot be found,
+		 * so always return success here.
 		 */
 		return (CMD_RETURN_NORMAL);
 	}

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

 	newname = args_get(args, 's');
 	if (newname != NULL) {
 		if (!session_check_name(newname)) {
-			cmdq_error(cmdq, "bad session name: %s", newname);
+			cmdq_error(item, "bad session name: %s", newname);
 			return (CMD_RETURN_ERROR);
 		}
 		if ((as = session_find(newname)) != NULL) {
 			if (args_has(args, 'A')) {
-				/*
-				 * This cmdq is now destined for
-				 * attach-session.  Because attach-session
-				 * will have already been prepared, copy this
-				 * session into its tflag so it can be used.
-				 */
-				cmd_find_from_session(&cmdq->state.tflag, as);
-				return (cmd_attach_session(cmdq,
-				    args_has(args, 'D'), 0, NULL,
-				    args_has(args, 'E')));
+				return (cmd_attach_session(item,
+				    newname, args_has(args, 'D'),
+				    0, NULL, args_has(args, 'E')));
 			}
-			cmdq_error(cmdq, "duplicate session: %s", newname);
+			cmdq_error(item, "duplicate session: %s", newname);
 			return (CMD_RETURN_ERROR);
 		}
 	}

-	if ((target = args_get(args, 't')) != NULL) {
+	/* Is this going to be part of a session group? */
+	group = args_get(args, 't');
+	if (group != NULL) {
+		groupwith = item->target.s;
 		if (groupwith == NULL) {
-			cmdq_error(cmdq, "no such session: %s", target);
-			goto error;
-		}
-	} else
+			if (!session_check_name(group)) {
+				cmdq_error(item, "bad group name: %s", group);
+				goto error;
+			}
+			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. */
 	detached = args_has(args, 'd');
 	if (c == NULL)
 		detached = 1;
+	else if (c->flags & CLIENT_CONTROL)
+		is_control = 1;

 	/* Is this client already attached? */
 	already_attached = 0;
@@ -138,10 +150,9 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)

 	/* Get the new session working directory. */
 	if (args_has(args, 'c')) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, NULL, NULL, NULL);
-		to_free = cwd = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
+		cwd = args_get(args, 'c');
+		to_free = format_single(item, cwd, c, NULL, NULL, NULL);
+		cwd = to_free;
 	} else if (c != NULL && c->session == NULL && c->cwd != NULL)
 		cwd = c->cwd;
 	else
@@ -157,8 +168,8 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * over.
 	 */
 	if (!detached && !already_attached && c->tty.fd != -1) {
-		if (server_client_check_nested(cmdq->client)) {
-			cmdq_error(cmdq, "sessions should be nested with care, "
+		if (server_client_check_nested(item->client)) {
+			cmdq_error(item, "sessions should be nested with care, "
 			    "unset $TMUX to force");
 			return (CMD_RETURN_ERROR);
 		}
@@ -171,36 +182,38 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	/* Open the terminal if necessary. */
 	if (!detached && !already_attached) {
 		if (server_client_open(c, &cause) != 0) {
-			cmdq_error(cmdq, "open terminal failed: %s", cause);
+			cmdq_error(item, "open terminal failed: %s", cause);
 			free(cause);
 			goto error;
 		}
 	}

 	/* Find new session size. */
-	if (c != NULL) {
+	if (!detached) {
 		sx = c->tty.sx;
 		sy = c->tty.sy;
+		if (!is_control &&
+		    sy > 0 &&
+		    options_get_number(global_s_options, "status"))
+			sy--;
 	} else {
 		sx = 80;
 		sy = 24;
 	}
-	if (detached && args_has(args, 'x')) {
+	if ((is_control || detached) && args_has(args, 'x')) {
 		sx = strtonum(args_get(args, 'x'), 1, USHRT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "width %s", errstr);
+			cmdq_error(item, "width %s", errstr);
 			goto error;
 		}
 	}
-	if (detached && args_has(args, 'y')) {
+	if ((is_control || detached) && args_has(args, 'y')) {
 		sy = strtonum(args_get(args, 'y'), 1, USHRT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "height %s", errstr);
+			cmdq_error(item, "height %s", errstr);
 			goto error;
 		}
 	}
-	if (sy > 0 && options_get_number(global_s_options, "status"))
-		sy--;
 	if (sx == 0)
 		sx = 1;
 	if (sy == 0)
@@ -212,11 +225,11 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (!args_has(args, 't') && args->argc != 0) {
 		argc = args->argc;
 		argv = args->argv;
-	} else if (groupwith == NULL) {
+	} else if (sg == NULL && groupwith == NULL) {
 		cmd = options_get_string(global_s_options, "default-command");
 		if (cmd != NULL && *cmd != '\0') {
 			argc = 1;
-			argv = &cmd;
+			argv = (char **)&cmd;
 		} else {
 			argc = 0;
 			argv = NULL;
@@ -233,19 +246,16 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)

 	/* Construct the environment. */
 	env = environ_create();
-	if (c != NULL && !args_has(args, 'E')) {
-		update = options_get_string(global_s_options,
-		    "update-environment");
-		environ_update(update, c->environ, env);
-	}
+	if (c != NULL && !args_has(args, 'E'))
+		environ_update(global_s_options, c->environ, env);

 	/* Create the new session. */
 	idx = -1 - options_get_number(global_s_options, "base-index");
-	s = session_create(newname, argc, argv, path, cwd, env, tiop, idx, sx,
-	    sy, &cause);
+	s = session_create(prefix, newname, argc, argv, path, cwd, env, tiop,
+	    idx, sx, sy, &cause);
 	environ_free(env);
 	if (s == NULL) {
-		cmdq_error(cmdq, "create session failed: %s", cause);
+		cmdq_error(item, "create session failed: %s", cause);
 		free(cause);
 		goto error;
 	}
@@ -261,11 +271,19 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	 * If a target session is given, this is to be part of a session group,
 	 * so add it to the group and synchronize.
 	 */
-	if (groupwith != NULL) {
-		session_group_add(groupwith, s);
+	if (group != NULL) {
+		if (sg == NULL) {
+			if (groupwith != NULL) {
+				sg = session_group_new(groupwith->name);
+				session_group_add(sg, groupwith);
+			} else
+				sg = session_group_new(group);
+		}
+		session_group_add(sg, s);
 		session_group_synchronize_to(s);
 		session_select(s, RB_MIN(winlinks, &s->windows)->idx);
 	}
+	notify_session("session-created", s);

 	/*
 	 * Set the client to the new session. If a command client exists, it is
@@ -278,9 +296,10 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 		} else if (c->session != NULL)
 			c->last_session = c->session;
 		c->session = s;
-		server_client_set_key_table(c, NULL);
+		if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+			server_client_set_key_table(c, NULL);
 		status_timer_start(c);
-		notify_attached_session_changed(c);
+		notify_client("client-session-changed", c);
 		session_update_activity(s, NULL);
 		gettimeofday(&s->last_attached_time, NULL);
 		server_redraw_client(c);
@@ -299,26 +318,23 @@ cmd_new_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_SESSION_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, NULL, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, NULL, NULL);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}

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

-	if (to_free != NULL)
-		free((void *)to_free);
+	cmd_find_from_session(&fs, s, 0);
+	hooks_insert(s->hooks, item, &fs, "after-new-session");
+
+	free(to_free);
 	return (CMD_RETURN_NORMAL);

 error:
-	if (to_free != NULL)
-		free((void *)to_free);
+	free(to_free);
 	return (CMD_RETURN_ERROR);
 }
--- a/cmd-new-window.c
+++ b/cmd-new-window.c
@@ -32,7 +32,7 @@

 #define NEW_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"

-enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_new_window_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_new_window_entry = {
 	.name = "new-window",
@@ -42,29 +42,30 @@ const struct cmd_entry cmd_new_window_entry = {
 	.usage = "[-adkP] [-c start-directory] [-F format] [-n window-name] "
 		 CMD_TARGET_WINDOW_USAGE " [command]",

-	.tflag = CMD_WINDOW_INDEX,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_WINDOW_INDEX },

 	.flags = 0,
 	.exec = cmd_new_window_exec
 };

-enum cmd_retval
-cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_new_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
-	struct client		*c = cmdq->state.c;
-	int			 idx = cmdq->state.tflag.idx;
-	const char		*cmd, *path, *template, *cwd, *to_free;
-	char		       **argv, *cause, *cp;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	int			 idx = item->target.idx;
+	const char		*cmd, *path, *template, *cwd;
+	char		       **argv, *cause, *cp, *to_free = NULL;
 	int			 argc, detached;
-	struct format_tree	*ft;
 	struct environ_entry	*envent;
+	struct cmd_find_state	 fs;

 	if (args_has(args, 'a')) {
 		if ((idx = winlink_shuffle_up(s, wl)) == -1) {
-			cmdq_error(cmdq, "no free window indexes");
+			cmdq_error(item, "no free window indexes");
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -85,21 +86,19 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	}

 	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
 		envent = environ_find(s->environ, "PATH");
 	if (envent != NULL)
 		path = envent->value;

-	to_free = NULL;
 	if (args_has(args, 'c')) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, NULL, NULL);
-		cwd = to_free = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
+		cwd = args_get(args, 'c');
+		to_free = format_single(item, cwd, c, s, NULL, NULL);
+		cwd = to_free;
+	} else if (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
 	else
 		cwd = s->cwd;

@@ -111,7 +110,7 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		 * Can't use session_detach as it will destroy session if this
 		 * makes it empty.
 		 */
-		notify_window_unlinked(s, wl->window);
+		notify_session_window("window-unlinked", s, wl->window);
 		wl->flags &= ~WINLINK_ALERTFLAGS;
 		winlink_stack_remove(&s->lastw, wl);
 		winlink_remove(&s->windows, wl);
@@ -128,12 +127,13 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	wl = session_new(s, args_get(args, 'n'), argc, argv, path, cwd, idx,
 		&cause);
 	if (wl == NULL) {
-		cmdq_error(cmdq, "create window failed: %s", cause);
+		cmdq_error(item, "create window failed: %s", cause);
 		free(cause);
 		goto error;
 	}
 	if (!detached) {
 		session_select(s, wl->idx);
+		cmd_find_from_winlink(current, wl, 0);
 		server_redraw_session_group(s);
 	} else
 		server_status_session_group(s);
@@ -141,23 +141,18 @@ cmd_new_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = NEW_WINDOW_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, c, s, wl, NULL);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, wl, NULL);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}

-	if (to_free != NULL)
-		free((void *)to_free);
+	cmd_find_from_winlink(&fs, wl, 0);
+	hooks_insert(s->hooks, item, &fs, "after-new-window");
+
+	free(to_free);
 	return (CMD_RETURN_NORMAL);

 error:
-	if (to_free != NULL)
-		free((void *)to_free);
+	free(to_free);
 	return (CMD_RETURN_ERROR);
 }
--- a/cmd-paste-buffer.c
+++ b/cmd-paste-buffer.c
@@ -27,10 +27,7 @@
 * Paste paste buffer if present.
 */

-enum cmd_retval	 cmd_paste_buffer_exec(struct cmd *, struct cmd_q *);
-
-void	cmd_paste_buffer_filter(struct window_pane *,
-	    const char *, size_t, const char *, int);
+static enum cmd_retval	cmd_paste_buffer_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_paste_buffer_entry = {
 	.name = "paste-buffer",
@@ -40,17 +37,17 @@ const struct cmd_entry cmd_paste_buffer_entry = {
 	.usage = "[-dpr] [-s separator] " CMD_BUFFER_USAGE " "
 		 CMD_TARGET_PANE_USAGE,

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_paste_buffer_exec
 };

-enum cmd_retval
-cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_paste_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
+	struct window_pane	*wp = item->target.wp;
 	struct paste_buffer	*pb;
 	const char		*sepstr, *bufname, *bufdata, *bufend, *line;
 	size_t			 seplen, bufsize;
@@ -65,7 +62,7 @@ cmd_paste_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	else {
 		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			cmdq_error(item, "no buffer %s", bufname);
 			return (CMD_RETURN_ERROR);
 		}
 	}
--- a/cmd-pipe-pane.c
+++ b/cmd-pipe-pane.c
@@ -21,6 +21,7 @@

 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -32,9 +33,10 @@
 * Open pipe to redirect pane output. If already open, close first.
 */

-enum cmd_retval	 cmd_pipe_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_pipe_pane_exec(struct cmd *, struct cmdq_item *);

-void	cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);
+static void cmd_pipe_pane_write_callback(struct bufferevent *, void *);
+static void cmd_pipe_pane_error_callback(struct bufferevent *, short, void *);

 const struct cmd_entry cmd_pipe_pane_entry = {
 	.name = "pipe-pane",
@@ -43,23 +45,24 @@ const struct cmd_entry cmd_pipe_pane_entry = {
 	.args = { "ot:", 0, 1 },
 	.usage = "[-o] " CMD_TARGET_PANE_USAGE " [command]",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_pipe_pane_exec
 };

-enum cmd_retval
-cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_pipe_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	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;
 	struct format_tree	*ft;
+	sigset_t		 set, oldset;

 	/* Destroy the old pipe. */
 	old_fd = wp->pipe_fd;
@@ -67,6 +70,11 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		bufferevent_free(wp->pipe_event);
 		close(wp->pipe_fd);
 		wp->pipe_fd = -1;
+
+		if (window_pane_destroy_ready(wp)) {
+			server_destroy_pane(wp, 1);
+			return (CMD_RETURN_NORMAL);
+		}
 	}

 	/* If no pipe command, that is enough. */
@@ -84,27 +92,31 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)

 	/* Open the new pipe. */
 	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_fd) != 0) {
-		cmdq_error(cmdq, "socketpair error: %s", strerror(errno));
+		cmdq_error(item, "socketpair error: %s", strerror(errno));
 		return (CMD_RETURN_ERROR);
 	}

 	/* Expand the command. */
-	ft = format_create(cmdq, 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], time(NULL));
 	format_free(ft);

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

 		free(cmd);
 		return (CMD_RETURN_ERROR);
 	case 0:
 		/* Child process. */
+		proc_clear_signals(server_proc, 1);
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[0]);
-		clear_signals(1);

 		if (dup2(pipe_fd[1], STDIN_FILENO) == -1)
 			_exit(1);
@@ -125,13 +137,15 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		_exit(1);
 	default:
 		/* Parent process. */
+		sigprocmask(SIG_SETMASK, &oldset, NULL);
 		close(pipe_fd[1]);

 		wp->pipe_fd = pipe_fd[0];
 		wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);

-		wp->pipe_event = bufferevent_new(wp->pipe_fd,
-		    NULL, NULL, cmd_pipe_pane_error_callback, wp);
+		wp->pipe_event = bufferevent_new(wp->pipe_fd, NULL,
+		    cmd_pipe_pane_write_callback, cmd_pipe_pane_error_callback,
+		    wp);
 		bufferevent_enable(wp->pipe_event, EV_WRITE);

 		setblocking(wp->pipe_fd, 0);
@@ -141,13 +155,28 @@ cmd_pipe_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	}
 }

-void
+static void
+cmd_pipe_pane_write_callback(__unused struct bufferevent *bufev, void *data)
+{
+	struct window_pane	*wp = data;
+
+	log_debug("%%%u pipe empty", wp->id);
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
+}
+
+static void
 cmd_pipe_pane_error_callback(__unused struct bufferevent *bufev,
    __unused short what, void *data)
 {
 	struct window_pane	*wp = data;

+	log_debug("%%%u pipe error", wp->id);
+
 	bufferevent_free(wp->pipe_event);
 	close(wp->pipe_fd);
 	wp->pipe_fd = -1;
+
+	if (window_pane_destroy_ready(wp))
+		server_destroy_pane(wp, 1);
 }
--- a/cmd-queue.c
+++ b/cmd-queue.c
@@ -25,51 +25,386 @@

 #include "tmux.h"

-static enum cmd_retval	cmdq_continue_one(struct cmd_q *);
+/* Global command queue. */
+static struct cmdq_list global_queue = TAILQ_HEAD_INITIALIZER(global_queue);

-/* Create new command queue. */
-struct cmd_q *
-cmdq_new(struct client *c)
+/* Get command queue name. */
+static const char *
+cmdq_name(struct client *c)
 {
-	struct cmd_q	*cmdq;
+	static char	s[32];

-	cmdq = xcalloc(1, sizeof *cmdq);
-	cmdq->references = 1;
-	cmdq->flags = 0;
-
-	cmdq->client = c;
-	cmdq->client_exit = -1;
-
-	TAILQ_INIT(&cmdq->queue);
-	cmdq->item = NULL;
-	cmdq->cmd = NULL;
-
-	cmd_find_clear_state(&cmdq->current, NULL, 0);
-	cmdq->parent = NULL;
-
-	return (cmdq);
+	if (c == NULL)
+		return ("<global>");
+	xsnprintf(s, sizeof s, "<%p>", c);
+	return (s);
 }

-/* Free command queue */
-int
-cmdq_free(struct cmd_q *cmdq)
+/* Get command queue from client. */
+static struct cmdq_list *
+cmdq_get(struct client *c)
 {
-	if (--cmdq->references != 0) {
-		if (cmdq->flags & CMD_Q_DEAD)
-			return (1);
+	if (c == NULL)
+		return (&global_queue);
+	return (&c->queue);
+}
+
+/* Append an item. */
+void
+cmdq_append(struct client *c, struct cmdq_item *item)
+{
+	struct cmdq_list	*queue = cmdq_get(c);
+	struct cmdq_item	*next;
+
+	do {
+		next = item->next;
+		item->next = NULL;
+
+		if (c != NULL)
+			c->references++;
+		item->client = c;
+
+		item->queue = queue;
+		TAILQ_INSERT_TAIL(queue, item, entry);
+
+		item = next;
+	} while (item != NULL);
+}
+
+/* Insert an item. */
+void
+cmdq_insert_after(struct cmdq_item *after, struct cmdq_item *item)
+{
+	struct client		*c = after->client;
+	struct cmdq_list	*queue = after->queue;
+	struct cmdq_item	*next;
+
+	do {
+		next = item->next;
+		item->next = NULL;
+
+		if (c != NULL)
+			c->references++;
+		item->client = c;
+
+		item->queue = queue;
+		if (after->next != NULL)
+			TAILQ_INSERT_AFTER(queue, after->next, item, entry);
+		else
+			TAILQ_INSERT_AFTER(queue, after, item, entry);
+		after->next = item;
+
+		item = next;
+	} while (item != NULL);
+}
+
+/* Remove an 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->type == CMDQ_COMMAND)
+		cmd_list_free(item->cmdlist);
+
+	TAILQ_REMOVE(item->queue, item, entry);
+
+	free((void *)item->name);
+	free(item);
+}
+
+/* Set command group. */
+static u_int
+cmdq_next_group(void)
+{
+	static u_int	group;
+
+	return (++group);
+}
+
+/* Remove all subsequent items that match this item's group. */
+static void
+cmdq_remove_group(struct cmdq_item *item)
+{
+	struct cmdq_item	*this, *next;
+
+	this = TAILQ_NEXT(item, entry);
+	while (this != NULL) {
+		next = TAILQ_NEXT(this, entry);
+		if (this->group == item->group)
+			cmdq_remove(this);
+		this = next;
+	}
+}
+
+/* Get a command for the command queue. */
+struct cmdq_item *
+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;
+	u_int			 group = cmdq_next_group();
+	char			*tmp;
+	struct cmdq_shared	*shared;
+
+	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);
+
+	TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
+		xasprintf(&tmp, "command[%s]", cmd->entry->name);
+
+		item = xcalloc(1, sizeof *item);
+		item->name = tmp;
+		item->type = CMDQ_COMMAND;
+
+		item->group = group;
+		item->flags = flags;
+
+		item->shared = shared;
+		item->cmdlist = cmdlist;
+		item->cmd = cmd;
+
+		shared->references++;
+		cmdlist->references++;
+
+		if (first == NULL)
+			first = item;
+		if (last != NULL)
+			last->next = item;
+		last = item;
+	}
+	return (first);
+}
+
+/* Fill in flag for a command. */
+static enum cmd_retval
+cmdq_find_flag(struct cmdq_item *item, struct cmd_find_state *fs,
+    const struct cmd_entry_flag *flag)
+{
+	const char	*value;
+
+	if (flag->flag == 0) {
+		cmd_find_clear_state(fs, 0);
+		return (CMD_RETURN_NORMAL);
+	}
+
+	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);
+	}
+	return (CMD_RETURN_NORMAL);
+}
+
+/* Fire command on command queue. */
+static enum cmd_retval
+cmdq_fire_command(struct cmdq_item *item)
+{
+	struct client		*c = item->client;
+	struct cmd		*cmd = item->cmd;
+	const struct cmd_entry	*entry = cmd->entry;
+	enum cmd_retval		 retval;
+	struct cmd_find_state	*fsp, fs;
+	int			 flags;
+
+	flags = !!(cmd->flags & CMD_CONTROL);
+	cmdq_guard(item, "begin", flags);
+
+	if (item->client == NULL)
+		item->client = cmd_find_client(item, NULL, 1);
+	retval = cmdq_find_flag(item, &item->source, &entry->source);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+	retval = cmdq_find_flag(item, &item->target, &entry->target);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+
+	retval = entry->exec(cmd, item);
+	if (retval == CMD_RETURN_ERROR)
+		goto out;
+
+	if (entry->flags & CMD_AFTERHOOK) {
+		if (cmd_find_valid_state(&item->target))
+			fsp = &item->target;
+		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
+			goto out;
+		hooks_insert(fsp->s->hooks, item, fsp, "after-%s", entry->name);
+	}
+
+out:
+	item->client = c;
+	if (retval == CMD_RETURN_ERROR)
+		cmdq_guard(item, "error", flags);
+	else
+		cmdq_guard(item, "end", flags);
+	return (retval);
+}
+
+/* Get a callback for the command queue. */
+struct cmdq_item *
+cmdq_get_callback1(const char *name, cmdq_cb cb, void *data)
+{
+	struct cmdq_item	*item;
+	char			*tmp;
+
+	xasprintf(&tmp, "callback[%s]", name);
+
+	item = xcalloc(1, sizeof *item);
+	item->name = tmp;
+	item->type = CMDQ_CALLBACK;
+
+	item->group = 0;
+	item->flags = 0;
+
+	item->cb = cb;
+	item->data = data;
+
+	return (item);
+}
+
+/* Fire callback on callback queue. */
+static enum cmd_retval
+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)
+{
+	struct cmdq_list	*queue = cmdq_get(c);
+	const char		*name = cmdq_name(c);
+	struct cmdq_item	*item;
+	enum cmd_retval		 retval;
+	u_int			 items = 0;
+	static u_int		 number;
+
+	if (TAILQ_EMPTY(queue)) {
+		log_debug("%s %s: empty", __func__, name);
+		return (0);
+	}
+	if (TAILQ_FIRST(queue)->flags & CMDQ_WAITING) {
+		log_debug("%s %s: waiting", __func__, name);
 		return (0);
 	}

-	cmdq_flush(cmdq);
-	free(cmdq);
-	return (1);
+	log_debug("%s %s: enter", __func__, name);
+	for (;;) {
+		item = TAILQ_FIRST(queue);
+		if (item == NULL)
+			break;
+		log_debug("%s %s: %s (%d), flags %x", __func__, name,
+		    item->name, item->type, item->flags);
+
+		/*
+		 * Any item with the waiting flag set waits until an external
+		 * event clears the flag (for example, a job - look at
+		 * run-shell).
+		 */
+		if (item->flags & CMDQ_WAITING)
+			goto waiting;
+
+		/*
+		 * Items are only fired once, once the fired flag is set, a
+		 * waiting flag can only be cleared by an external event.
+		 */
+		if (~item->flags & CMDQ_FIRED) {
+			item->time = time(NULL);
+			item->number = ++number;
+
+			switch (item->type) {
+			case CMDQ_COMMAND:
+				retval = cmdq_fire_command(item);
+
+				/*
+				 * If a command returns an error, remove any
+				 * subsequent commands in the same group.
+				 */
+				if (retval == CMD_RETURN_ERROR)
+					cmdq_remove_group(item);
+				break;
+			case CMDQ_CALLBACK:
+				retval = cmdq_fire_callback(item);
+				break;
+			default:
+				retval = CMD_RETURN_ERROR;
+				break;
+			}
+			item->flags |= CMDQ_FIRED;
+
+			if (retval == CMD_RETURN_WAIT) {
+				item->flags |= CMDQ_WAITING;
+				goto waiting;
+			}
+			items++;
+		}
+		cmdq_remove(item);
+	}
+
+	log_debug("%s %s: exit (empty)", __func__, name);
+	return (items);
+
+waiting:
+	log_debug("%s %s: exit (wait)", __func__, name);
+	return (items);
+}
+
+/* Print a guard line. */
+void
+cmdq_guard(struct cmdq_item *item, const char *guard, int flags)
+{
+	struct client	*c = item->client;
+
+	if (c == NULL || !(c->flags & CLIENT_CONTROL))
+		return;
+
+	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
+	    (long)item->time, item->number, flags);
+	server_client_push_stdout(c);
 }

 /* Show message from command. */
 void
-cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
+cmdq_print(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
+	struct client	*c = item->client;
 	struct window	*w;
 	va_list		 ap;
 	char		*tmp, *msg;
@@ -80,7 +415,7 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
 		/* nothing */;
 	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
 		if (~c->flags & CLIENT_UTF8) {
-			vasprintf(&tmp, fmt, ap);
+			xvasprintf(&tmp, fmt, ap);
 			msg = utf8_sanitize(tmp);
 			free(tmp);
 			evbuffer_add(c->stdout_data, msg, strlen(msg));
@@ -93,7 +428,8 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
 		w = c->session->curw->window;
 		if (w->active->mode != &window_copy_mode) {
 			window_pane_reset_mode(w->active);
-			window_pane_set_mode(w->active, &window_copy_mode);
+			window_pane_set_mode(w->active, &window_copy_mode, NULL,
+			    NULL);
 			window_copy_init_for_output(w->active);
 		}
 		window_copy_vadd(w->active, fmt, ap);
@@ -104,10 +440,10 @@ cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)

 /* Show error from command. */
 void
-cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
+cmdq_error(struct cmdq_item *item, const char *fmt, ...)
 {
-	struct client	*c = cmdq->client;
-	struct cmd	*cmd = cmdq->cmd;
+	struct client	*c = item->client;
+	struct cmd	*cmd = item->cmd;
 	va_list		 ap;
 	char		*msg;
 	size_t		 msglen;
@@ -117,6 +453,8 @@ cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
 	msglen = xvasprintf(&msg, fmt, ap);
 	va_end(ap);

+	log_debug("%s: %s", __func__, msg);
+
 	if (c == NULL)
 		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
 	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
@@ -137,156 +475,3 @@ cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)

 	free(msg);
 }
-
-/* Print a guard line. */
-void
-cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
-{
-	struct client	*c = cmdq->client;
-
-	if (c == NULL || !(c->flags & CLIENT_CONTROL))
-		return;
-
-	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
-	    (long) cmdq->time, cmdq->number, flags);
-	server_client_push_stdout(c);
-}
-
-/* Add command list to queue and begin processing if needed. */
-void
-cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	cmdq_append(cmdq, cmdlist, m);
-
-	if (cmdq->item == NULL) {
-		cmdq->cmd = NULL;
-		cmdq_continue(cmdq);
-	}
-}
-
-/* Add command list to queue. */
-void
-cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
-{
-	struct cmd_q_item	*item;
-
-	item = xcalloc(1, sizeof *item);
-	item->cmdlist = cmdlist;
-	TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
-	cmdlist->references++;
-
-	if (m != NULL)
-		memcpy(&item->mouse, m, sizeof item->mouse);
-	else
-		item->mouse.valid = 0;
-}
-
-/* Process one command. */
-static enum cmd_retval
-cmdq_continue_one(struct cmd_q *cmdq)
-{
-	struct cmd	*cmd = cmdq->cmd;
-	enum cmd_retval	 retval;
-	char		*tmp;
-	int		 flags = !!(cmd->flags & CMD_CONTROL);
-
-	tmp = cmd_print(cmd);
-	log_debug("cmdq %p: %s", cmdq, tmp);
-	free(tmp);
-
-	cmdq->time = time(NULL);
-	cmdq->number++;
-
-	cmdq_guard(cmdq, "begin", flags);
-
-	if (cmd_prepare_state(cmd, cmdq, NULL) != 0)
-		goto error;
-	retval = cmd->entry->exec(cmd, cmdq);
-	if (retval == CMD_RETURN_ERROR)
-		goto error;
-
-	cmdq_guard(cmdq, "end", flags);
-	return (retval);
-
-error:
-	cmdq_guard(cmdq, "error", flags);
-	return (CMD_RETURN_ERROR);
-}
-
-/* Continue processing command queue. Returns 1 if finishes empty. */
-int
-cmdq_continue(struct cmd_q *cmdq)
-{
-	struct client		*c = cmdq->client;
-	struct cmd_q_item	*next;
-	enum cmd_retval		 retval;
-	int			 empty;
-
-	cmdq->references++;
-	notify_disable();
-
-	log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
-	    c);
-
-	empty = TAILQ_EMPTY(&cmdq->queue);
-	if (empty)
-		goto empty;
-
-	if (cmdq->item == NULL) {
-		cmdq->item = TAILQ_FIRST(&cmdq->queue);
-		cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-	} else
-		cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-
-	do {
-		while (cmdq->cmd != NULL) {
-			retval = cmdq_continue_one(cmdq);
-			if (retval == CMD_RETURN_ERROR)
-				break;
-			if (retval == CMD_RETURN_WAIT)
-				goto out;
-			if (retval == CMD_RETURN_STOP) {
-				cmdq_flush(cmdq);
-				goto empty;
-			}
-			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
-		}
-		next = TAILQ_NEXT(cmdq->item, qentry);
-
-		TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
-		cmd_list_free(cmdq->item->cmdlist);
-		free(cmdq->item);
-
-		cmdq->item = next;
-		if (cmdq->item != NULL)
-			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
-	} while (cmdq->item != NULL);
-
-empty:
-	if (cmdq->client_exit > 0)
-		cmdq->client->flags |= CLIENT_EXIT;
-	if (cmdq->emptyfn != NULL)
-		cmdq->emptyfn(cmdq);
-	empty = 1;
-
-out:
-	notify_enable();
-	cmdq_free(cmdq);
-
-	return (empty);
-}
-
-/* Flush command queue. */
-void
-cmdq_flush(struct cmd_q *cmdq)
-{
-	struct cmd_q_item	*item, *item1;
-
-	TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
-		TAILQ_REMOVE(&cmdq->queue, item, qentry);
-		cmd_list_free(item->cmdlist);
-		free(item);
-	}
-	cmdq->item = NULL;
-}
-
--- a/cmd-refresh-client.c
+++ b/cmd-refresh-client.c
@@ -24,7 +24,8 @@
 * Refresh client.
 */

-enum cmd_retval	 cmd_refresh_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_refresh_client_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_refresh_client_entry = {
 	.name = "refresh-client",
@@ -33,40 +34,42 @@ const struct cmd_entry cmd_refresh_client_entry = {
 	.args = { "C:St:", 0, 0 },
 	.usage = "[-S] [-C size] " CMD_TARGET_CLIENT_USAGE,

-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_refresh_client_exec
 };

-enum cmd_retval
-cmd_refresh_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_refresh_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct client	*c = cmdq->state.c;
+	struct client	*c;
 	const char	*size;
 	u_int		 w, h;

+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
 	if (args_has(args, 'C')) {
 		if ((size = args_get(args, 'C')) == NULL) {
-			cmdq_error(cmdq, "missing size");
+			cmdq_error(item, "missing size");
 			return (CMD_RETURN_ERROR);
 		}
 		if (sscanf(size, "%u,%u", &w, &h) != 2) {
-			cmdq_error(cmdq, "bad size argument");
+			cmdq_error(item, "bad size argument");
 			return (CMD_RETURN_ERROR);
 		}
 		if (w < PANE_MINIMUM || w > 5000 ||
 		    h < PANE_MINIMUM || h > 5000) {
-			cmdq_error(cmdq, "size too small or too big");
+			cmdq_error(item, "size too small or too big");
 			return (CMD_RETURN_ERROR);
 		}
 		if (!(c->flags & CLIENT_CONTROL)) {
-			cmdq_error(cmdq, "not a control client");
+			cmdq_error(item, "not a control client");
 			return (CMD_RETURN_ERROR);
 		}
-		if (tty_set_size(&c->tty, w, h))
-			recalculate_sizes();
+		tty_set_size(&c->tty, w, h);
+		c->flags |= CLIENT_SIZECHANGED;
+		recalculate_sizes();
 	} else if (args_has(args, 'S')) {
 		c->flags |= CLIENT_STATUSFORCE;
 		server_status_client(c);
--- a/cmd-rename-session.c
+++ b/cmd-rename-session.c
@@ -19,6 +19,7 @@
 #include <sys/types.h>

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

 #include "tmux.h"

@@ -26,7 +27,8 @@
 * Change session name.
 */

-enum cmd_retval	 cmd_rename_session_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rename_session_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_rename_session_entry = {
 	.name = "rename-session",
@@ -35,26 +37,29 @@ const struct cmd_entry cmd_rename_session_entry = {
 	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_SESSION_USAGE " new-name",

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_rename_session_exec
 };

-enum cmd_retval
-cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_session_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
+	struct session	*s = item->target.s;
 	const char	*newname;

 	newname = args->argv[0];
+	if (strcmp(newname, s->name) == 0)
+		return (CMD_RETURN_NORMAL);
+
 	if (!session_check_name(newname)) {
-		cmdq_error(cmdq, "bad session name: %s", newname);
+		cmdq_error(item, "bad session name: %s", newname);
 		return (CMD_RETURN_ERROR);
 	}
 	if (session_find(newname) != NULL) {
-		cmdq_error(cmdq, "duplicate session: %s", newname);
+		cmdq_error(item, "duplicate session: %s", newname);
 		return (CMD_RETURN_ERROR);
 	}

@@ -64,7 +69,7 @@ cmd_rename_session_exec(struct cmd *self, struct cmd_q *cmdq)
 	RB_INSERT(sessions, &sessions, s);

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

 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-rename-window.c
+++ b/cmd-rename-window.c
@@ -26,7 +26,8 @@
 * Rename a window.
 */

-enum cmd_retval	 cmd_rename_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rename_window_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_rename_window_entry = {
 	.name = "rename-window",
@@ -35,17 +36,17 @@ const struct cmd_entry cmd_rename_window_entry = {
 	.args = { "t:", 1, 1 },
 	.usage = CMD_TARGET_WINDOW_USAGE " new-name",

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_rename_window_exec
 };

-enum cmd_retval
-cmd_rename_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rename_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct winlink	*wl = item->target.wl;

 	window_set_name(wl->window, args->argv[0]);
 	options_set_number(wl->window->options, "automatic-rename", 0);
--- a/cmd-resize-pane.c
+++ b/cmd-resize-pane.c
@@ -26,9 +26,10 @@
 * Increase or decrease pane size.
 */

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

-void	cmd_resize_pane_mouse_update(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",
@@ -38,33 +39,34 @@ const struct cmd_entry cmd_resize_pane_entry = {
 	.usage = "[-DLMRUZ] [-x width] [-y height] " CMD_TARGET_PANE_USAGE " "
 		 "[adjustment]",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_resize_pane_exec
 };

-enum cmd_retval
-cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_resize_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	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 client		*c = cmdq->client;
-	struct session		*s = cmdq->state.tflag.s;
+	struct client		*c = item->client;
+	struct session		*s = item->target.s;
 	const char	       	*errstr;
 	char			*cause;
 	u_int			 adjust;
 	int			 x, y;

 	if (args_has(args, 'M')) {
-		if (cmd_mouse_window(&cmdq->item->mouse, &s) == NULL)
+		if (cmd_mouse_window(&shared->mouse, &s) == NULL)
 			return (CMD_RETURN_NORMAL);
 		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, &cmdq->item->mouse);
+		cmd_resize_pane_mouse_update(c, &shared->mouse);
 		return (CMD_RETURN_NORMAL);
 	}

@@ -84,7 +86,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	else {
 		adjust = strtonum(args->argv[0], 1, INT_MAX, &errstr);
 		if (errstr != NULL) {
-			cmdq_error(cmdq, "adjustment %s", errstr);
+			cmdq_error(item, "adjustment %s", errstr);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -93,7 +95,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		x = args_strtonum(self->args, 'x', PANE_MINIMUM, INT_MAX,
 		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "width %s", cause);
+			cmdq_error(item, "width %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -103,7 +105,7 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		y = args_strtonum(self->args, 'y', PANE_MINIMUM, INT_MAX,
 		    &cause);
 		if (cause != NULL) {
-			cmdq_error(cmdq, "height %s", cause);
+			cmdq_error(item, "height %s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -111,25 +113,24 @@ cmd_resize_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 	}

 	if (args_has(self->args, 'L'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, -adjust, 1);
 	else if (args_has(self->args, 'R'))
-		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust);
+		layout_resize_pane(wp, LAYOUT_LEFTRIGHT, adjust, 1);
 	else if (args_has(self->args, 'U'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust);
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, -adjust, 1);
 	else if (args_has(self->args, 'D'))
-		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust);
+		layout_resize_pane(wp, LAYOUT_TOPBOTTOM, adjust, 1);
 	server_redraw_window(wl->window);

 	return (CMD_RETURN_NORMAL);
 }

-void
+static void
 cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 {
 	struct winlink		*wl;
-	struct window_pane	*wp;
-	int			 found;
-	u_int			 y, ly;
+	struct window_pane	*loop, *wp_x, *wp_y;
+	u_int			 y, ly, x, lx, sx, sy, ex, ey;

 	wl = cmd_mouse_window(m, NULL);
 	if (wl == NULL) {
@@ -137,35 +138,48 @@ cmd_resize_pane_mouse_update(struct client *c, struct mouse_event *m)
 		return;
 	}

-	y = m->y;
+	y = m->y; x = m->x;
 	if (m->statusat == 0 && y > 0)
 		y--;
 	else if (m->statusat > 0 && y >= (u_int)m->statusat)
 		y = m->statusat - 1;
-	ly = m->ly;
+	ly = m->ly; lx = m->lx;
 	if (m->statusat == 0 && ly > 0)
 		ly--;
 	else if (m->statusat > 0 && ly >= (u_int)m->statusat)
 		ly = m->statusat - 1;

-	found = 0;
-	TAILQ_FOREACH(wp, &wl->window->panes, entry) {
-		if (!window_pane_visible(wp))
+	wp_x = wp_y = NULL;
+	TAILQ_FOREACH(loop, &wl->window->panes, entry) {
+		if (!window_pane_visible(loop))
 			continue;

-		if (wp->xoff + wp->sx == m->lx &&
-		    wp->yoff <= 1 + ly && wp->yoff + wp->sy >= ly) {
-			layout_resize_pane(wp, LAYOUT_LEFTRIGHT, m->x - m->lx);
-			found = 1;
-		}
-		if (wp->yoff + wp->sy == ly &&
-		    wp->xoff <= 1 + m->lx && wp->xoff + wp->sx >= m->lx) {
-			layout_resize_pane(wp, LAYOUT_TOPBOTTOM, y - ly);
-			found = 1;
-		}
+		sx = loop->xoff;
+		if (sx != 0)
+			sx--;
+		ex = loop->xoff + loop->sx;
+
+		sy = loop->yoff;
+		if (sy != 0)
+			sy--;
+		ey = loop->yoff + loop->sy;
+
+		if ((lx == sx || lx == ex) &&
+		    (ly >= sy && ly <= ey) &&
+		    (wp_x == NULL || loop->sy > wp_x->sy))
+			wp_x = loop;
+		if ((ly == sy || ly == ey) &&
+		    (lx >= sx && lx <= ex) &&
+		    (wp_y == NULL || loop->sx > wp_y->sx))
+			wp_y = loop;
 	}
-	if (found)
-		server_redraw_window(wl->window);
-	else
+	if (wp_x == NULL && wp_y == NULL) {
 		c->tty.mouse_drag_update = NULL;
+		return;
+	}
+	if (wp_x != NULL)
+		layout_resize_pane(wp_x, LAYOUT_LEFTRIGHT, x - lx, 0);
+	if (wp_y != NULL)
+		layout_resize_pane(wp_y, LAYOUT_TOPBOTTOM, y - ly, 0);
+	server_redraw_window(wl->window);
 }
--- a/cmd-respawn-pane.c
+++ b/cmd-respawn-pane.c
@@ -28,70 +28,73 @@
 * Respawn a pane (restart the command). Kill existing if -k given.
 */

-enum cmd_retval	 cmd_respawn_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_respawn_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_respawn_pane_entry = {
 	.name = "respawn-pane",
 	.alias = "respawnp",

-	.args = { "kt:", 0, -1 },
-	.usage = "[-k] " CMD_TARGET_PANE_USAGE " [command]",
+	.args = { "c:kt:", 0, -1 },
+	.usage = "[-c start-directory] [-k] " CMD_TARGET_PANE_USAGE
+	         " [command]",

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

 	.flags = 0,
 	.exec = cmd_respawn_pane_exec
 };

-enum cmd_retval
-cmd_respawn_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
+	struct window_pane	*wp = item->target.wp;
+	struct client           *c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
 	struct environ		*env;
-	const char		*path;
-	char			*cause;
+	const char		*path = NULL, *cp;
+	char			*cause, *cwd = NULL;
 	u_int			 idx;
 	struct environ_entry	*envent;

 	if (!args_has(self->args, 'k') && wp->fd != -1) {
 		if (window_pane_index(wp, &idx) != 0)
 			fatalx("index not found");
-		cmdq_error(cmdq, "pane still active: %s:%d.%u",
+		cmdq_error(item, "pane still active: %s:%d.%u",
 		    s->name, wl->idx, idx);
 		return (CMD_RETURN_ERROR);
 	}

-	env = environ_create();
-	environ_copy(global_environ, env);
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
-
 	window_pane_reset_mode(wp);
 	screen_reinit(&wp->base);
 	input_init(wp);

-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
 		envent = environ_find(s->environ, "PATH");
 	if (envent != NULL)
 		path = envent->value;

-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
+	if ((cp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, cp, c, s, NULL, NULL);
+
+	env = environ_for_session(s, 0);
+	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, cwd, env,
 	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn pane failed: %s", cause);
+		cmdq_error(item, "respawn pane failed: %s", cause);
 		free(cause);
 		environ_free(env);
+		free(cwd);
 		return (CMD_RETURN_ERROR);
 	}
+	environ_free(env);
+	free(cwd);
+
 	wp->flags |= PANE_REDRAW;
 	server_status_window(w);

-	environ_free(env);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-respawn-window.c
+++ b/cmd-respawn-window.c
@@ -27,49 +27,47 @@
 * Respawn a window (restart the command). Kill existing if -k given.
 */

-enum cmd_retval	 cmd_respawn_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_respawn_window_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_respawn_window_entry = {
 	.name = "respawn-window",
 	.alias = "respawnw",

-	.args = { "kt:", 0, -1 },
-	.usage = "[-k] " CMD_TARGET_WINDOW_USAGE " [command]",
+	.args = { "c:kt:", 0, -1 },
+	.usage = "[-c start-directory] [-k] " CMD_TARGET_WINDOW_USAGE
+	         " [command]",

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_respawn_window_exec
 };

-enum cmd_retval
-cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_respawn_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
 	struct window_pane	*wp;
+	struct client           *c = cmd_find_client(item, NULL, 1);
 	struct environ		*env;
-	const char		*path;
-	char		 	*cause;
+	const char		*path = NULL, *cp;
+	char		 	*cause, *cwd = NULL;
 	struct environ_entry	*envent;

 	if (!args_has(self->args, 'k')) {
 		TAILQ_FOREACH(wp, &w->panes, entry) {
 			if (wp->fd == -1)
 				continue;
-			cmdq_error(cmdq, "window still active: %s:%d", s->name,
+			cmdq_error(item, "window still active: %s:%d", s->name,
 			    wl->idx);
 			return (CMD_RETURN_ERROR);
 		}
 	}

-	env = environ_create();
-	environ_copy(global_environ, env);
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
-
 	wp = TAILQ_FIRST(&w->panes);
 	TAILQ_REMOVE(&w->panes, wp, entry);
 	layout_free(w);
@@ -77,22 +75,29 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 	window_pane_resize(wp, w->sx, w->sy);

-	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
 		envent = environ_find(s->environ, "PATH");
 	if (envent != NULL)
 		path = envent->value;

-	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, NULL, env,
+	if ((cp = args_get(args, 'c')) != NULL)
+		cwd = format_single(item, cp, c, s, NULL, NULL);
+
+	env = environ_for_session(s, 0);
+	if (window_pane_spawn(wp, args->argc, args->argv, path, NULL, cwd, env,
 	    s->tio, &cause) != 0) {
-		cmdq_error(cmdq, "respawn window failed: %s", cause);
+		cmdq_error(item, "respawn window failed: %s", cause);
 		free(cause);
 		environ_free(env);
+		free(cwd);
 		server_destroy_pane(wp, 0);
 		return (CMD_RETURN_ERROR);
 	}
+	environ_free(env);
+	free(cwd);
+
 	layout_init(w, wp);
 	window_pane_reset_mode(wp);
 	screen_reinit(&wp->base);
@@ -102,6 +107,5 @@ cmd_respawn_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	recalculate_sizes();
 	server_redraw_window(w);

-	environ_free(env);
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-rotate-window.c
+++ b/cmd-rotate-window.c
@@ -24,7 +24,8 @@
 * Rotate the panes in a window.
 */

-enum cmd_retval	 cmd_rotate_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_rotate_window_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_rotate_window_entry = {
 	.name = "rotate-window",
@@ -33,21 +34,24 @@ const struct cmd_entry cmd_rotate_window_entry = {
 	.args = { "Dt:U", 0, 0 },
 	.usage = "[-DU] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_rotate_window_exec
 };

-enum cmd_retval
-cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_rotate_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink		*wl = cmdq->state.tflag.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;

+	server_unzoom_window(w);
+
 	if (args_has(self->args, 'D')) {
 		wp = TAILQ_LAST(&w->panes, window_panes);
 		TAILQ_REMOVE(&w->panes, wp, entry);
@@ -74,6 +78,7 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		if ((wp = TAILQ_PREV(w->active, window_panes, entry)) == NULL)
 			wp = TAILQ_LAST(&w->panes, window_panes);
 		window_set_active_pane(w, wp);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	} else {
 		wp = TAILQ_FIRST(&w->panes);
@@ -101,6 +106,7 @@ cmd_rotate_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		if ((wp = TAILQ_NEXT(w->active, entry)) == NULL)
 			wp = TAILQ_FIRST(&w->panes);
 		window_set_active_pane(w, wp);
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
 		server_redraw_window(w);
 	}

--- a/cmd-run-shell.c
+++ b/cmd-run-shell.c
@@ -29,11 +29,11 @@
 * Runs a command without a window.
 */

-enum cmd_retval	 cmd_run_shell_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_run_shell_exec(struct cmd *, struct cmdq_item *);

-void	cmd_run_shell_callback(struct job *);
-void	cmd_run_shell_free(void *);
-void	cmd_run_shell_print(struct job *, const char *);
+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 *);

 const struct cmd_entry cmd_run_shell_entry = {
 	.name = "run-shell",
@@ -42,97 +42,94 @@ const struct cmd_entry cmd_run_shell_entry = {
 	.args = { "bt:", 1, 1 },
 	.usage = "[-b] " CMD_TARGET_PANE_USAGE " shell-command",

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

 	.flags = 0,
 	.exec = cmd_run_shell_exec
 };

 struct cmd_run_shell_data {
-	char		*cmd;
-	struct cmd_q	*cmdq;
-	int		 bflag;
-	int		 wp_id;
+	char			*cmd;
+	struct cmdq_item	*item;
+	int			 wp_id;
 };

-void
+static void
 cmd_run_shell_print(struct job *job, const char *msg)
 {
 	struct cmd_run_shell_data	*cdata = job->data;
 	struct window_pane		*wp = NULL;
+	struct cmd_find_state		 fs;

 	if (cdata->wp_id != -1)
 		wp = window_pane_find_by_id(cdata->wp_id);
 	if (wp == NULL) {
-		cmdq_print(cdata->cmdq, "%s", msg);
-		return;
+		if (cdata->item != NULL) {
+			cmdq_print(cdata->item, "%s", msg);
+			return;
+		}
+		if (cmd_find_from_nothing(&fs, 0) != 0)
+			return;
+		wp = fs.wp;
+		if (wp == NULL)
+			return;
 	}

-	if (window_pane_set_mode(wp, &window_copy_mode) == 0)
+	if (window_pane_set_mode(wp, &window_copy_mode, NULL, NULL) == 0)
 		window_copy_init_for_output(wp);
 	if (wp->mode == &window_copy_mode)
 		window_copy_add(wp, "%s", msg);
 }

-enum cmd_retval
-cmd_run_shell_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_run_shell_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
 	struct cmd_run_shell_data	*cdata;
-	char				*shellcmd;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
-	struct window_pane		*wp = cmdq->state.tflag.wp;
-	struct format_tree		*ft;
+	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			*cwd;

-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
+	if (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
 	else if (s != NULL)
 		cwd = s->cwd;
 	else
 		cwd = NULL;
-	ft = format_create(cmdq, 0);
-	format_defaults(ft, cmdq->state.c, s, wl, wp);
-	shellcmd = format_expand(ft, args->argv[0]);
-	format_free(ft);

-	cdata = xmalloc(sizeof *cdata);
-	cdata->cmd = shellcmd;
-	cdata->bflag = args_has(args, 'b');
-	cdata->wp_id = wp != NULL ? (int) wp->id : -1;
+	cdata = xcalloc(1, sizeof *cdata);
+	cdata->cmd = format_single(item, args->argv[0], c, s, wl, wp);

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

-	job_run(shellcmd, s, cwd, cmd_run_shell_callback, cmd_run_shell_free,
-	    cdata);
+	if (!args_has(args, 'b'))
+		cdata->item = item;

-	if (cdata->bflag)
+	job_run(cdata->cmd, s, cwd, NULL, cmd_run_shell_callback,
+	    cmd_run_shell_free, cdata);
+
+	if (args_has(args, 'b'))
 		return (CMD_RETURN_NORMAL);
 	return (CMD_RETURN_WAIT);
 }

-void
+static void
 cmd_run_shell_callback(struct job *job)
 {
 	struct cmd_run_shell_data	*cdata = job->data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-	char				*cmd, *msg, *line;
+	char				*cmd = cdata->cmd, *msg, *line;
 	size_t				 size;
 	int				 retcode;
-	u_int				 lines;

-	if (cmdq->flags & CMD_Q_DEAD)
-		return;
-	cmd = cdata->cmd;
-
-	lines = 0;
 	do {
 		if ((line = evbuffer_readline(job->event->input)) != NULL) {
 			cmd_run_shell_print(job, line);
 			free(line);
-			lines++;
 		}
 	} while (line != NULL);

@@ -143,7 +140,6 @@ cmd_run_shell_callback(struct job *job)
 		line[size] = '\0';

 		cmd_run_shell_print(job, line);
-		lines++;

 		free(line);
 	}
@@ -159,16 +155,15 @@ cmd_run_shell_callback(struct job *job)
 	if (msg != NULL)
 		cmd_run_shell_print(job, msg);
 	free(msg);
+
+	if (cdata->item != NULL)
+		cdata->item->flags &= ~CMDQ_WAITING;
 }

-void
+static void
 cmd_run_shell_free(void *data)
 {
 	struct cmd_run_shell_data	*cdata = data;
-	struct cmd_q			*cmdq = cdata->cmdq;
-
-	if (!cmdq_free(cmdq) && !cdata->bflag)
-		cmdq_continue(cmdq);

 	free(cdata->cmd);
 	free(cdata);
--- a/cmd-save-buffer.c
+++ b/cmd-save-buffer.c
@@ -31,7 +31,7 @@
 * Saves a paste buffer to a file.
 */

-enum cmd_retval	 cmd_save_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_save_buffer_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_save_buffer_entry = {
 	.name = "save-buffer",
@@ -40,7 +40,7 @@ const struct cmd_entry cmd_save_buffer_entry = {
 	.args = { "ab:", 1, 1 },
 	.usage = "[-a] " CMD_BUFFER_USAGE " path",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };

@@ -51,33 +51,32 @@ const struct cmd_entry cmd_show_buffer_entry = {
 	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_save_buffer_exec
 };

-enum cmd_retval
-cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_save_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->client;
-	struct session          *s;
+	struct client		*c = item->client;
 	struct paste_buffer	*pb;
-	const char		*path, *bufname, *bufdata, *start, *end, *cwd;
+	const char		*path, *bufname, *bufdata, *start, *end;
 	const char		*flags;
-	char			*msg, *file, resolved[PATH_MAX];
+	char			*msg, *file;
 	size_t			 size, used, msglen, bufsize;
 	FILE			*f;

 	if (!args_has(args, 'b')) {
 		if ((pb = paste_get_top(NULL)) == NULL) {
-			cmdq_error(cmdq, "no buffers");
+			cmdq_error(item, "no buffers");
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
 		bufname = args_get(args, 'b');
 		pb = paste_get_name(bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer %s", bufname);
+			cmdq_error(item, "no buffer %s", bufname);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -89,7 +88,7 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		path = args->argv[0];
 	if (strcmp(path, "-") == 0) {
 		if (c == NULL) {
-			cmdq_error(cmdq, "can't write to stdout");
+			cmdq_error(item, "can't write to stdout");
 			return (CMD_RETURN_ERROR);
 		}
 		if (c->session == NULL || (c->flags & CLIENT_CONTROL))
@@ -97,39 +96,27 @@ cmd_save_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		goto do_print;
 	}

-	if (c != NULL && c->session == NULL && c->cwd != NULL)
-		cwd = c->cwd;
-	else if ((s = c->session) != NULL && s->cwd != NULL)
-		cwd = s->cwd;
-	else
-		cwd = ".";
-
 	flags = "wb";
 	if (args_has(self->args, 'a'))
 		flags = "ab";

-	if (*path == '/')
-		file = xstrdup(path);
-	else
-		xasprintf(&file, "%s/%s", cwd, path);
-	if (realpath(file, resolved) == NULL &&
-	    strlcpy(resolved, file, sizeof resolved) >= sizeof resolved) {
-		cmdq_error(cmdq, "%s: %s", file, strerror(ENAMETOOLONG));
-		return (CMD_RETURN_ERROR);
-	}
-	f = fopen(resolved, flags);
-	free(file);
+	file = server_client_get_path(c, path);
+	f = fopen(file, flags);
 	if (f == NULL) {
-		cmdq_error(cmdq, "%s: %s", resolved, strerror(errno));
+		cmdq_error(item, "%s: %s", file, strerror(errno));
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}

 	if (fwrite(bufdata, 1, bufsize, f) != bufsize) {
-		cmdq_error(cmdq, "%s: write error", resolved);
+		cmdq_error(item, "%s: write error", file);
 		fclose(f);
+		free(file);
 		return (CMD_RETURN_ERROR);
 	}
+
 	fclose(f);
+	free(file);

 	return (CMD_RETURN_NORMAL);

@@ -140,7 +127,7 @@ do_stdout:

 do_print:
 	if (bufsize > (INT_MAX / 4) - 1) {
-		cmdq_error(cmdq, "buffer too big");
+		cmdq_error(item, "buffer too big");
 		return (CMD_RETURN_ERROR);
 	}
 	msg = NULL;
@@ -158,7 +145,7 @@ do_print:
 		msg = xrealloc(msg, msglen);

 		strvisx(msg, start, size, VIS_OCTAL|VIS_TAB);
-		cmdq_print(cmdq, "%s", msg);
+		cmdq_print(item, "%s", msg);

 		used += size + (end != NULL);
 	}
--- a/cmd-select-layout.c
+++ b/cmd-select-layout.c
@@ -26,7 +26,8 @@
 * Switch window to selected layout.
 */

-enum cmd_retval	 cmd_select_layout_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_layout_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_select_layout_entry = {
 	.name = "select-layout",
@@ -35,9 +36,9 @@ const struct cmd_entry cmd_select_layout_entry = {
 	.args = { "nopt:", 0, 1 },
 	.usage = "[-nop] " CMD_TARGET_WINDOW_USAGE " [layout-name]",

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };

@@ -48,9 +49,9 @@ const struct cmd_entry cmd_next_layout_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };

@@ -61,17 +62,17 @@ const struct cmd_entry cmd_previous_layout_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_select_layout_exec
 };

-enum cmd_retval
-cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_layout_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
-	struct winlink	*wl = cmdq->state.tflag.wl;
+	struct winlink	*wl = item->target.wl;
 	struct window	*w;
 	const char	*layoutname;
 	char		*oldlayout;
@@ -118,7 +119,7 @@ cmd_select_layout_exec(struct cmd *self, struct cmd_q *cmdq)

 	if (layoutname != NULL) {
 		if (layout_parse(w, layoutname) == -1) {
-			cmdq_error(cmdq, "can't set layout: %s", layoutname);
+			cmdq_error(item, "can't set layout: %s", layoutname);
 			goto error;
 		}
 		goto changed;
--- a/cmd-select-pane.c
+++ b/cmd-select-pane.c
@@ -24,16 +24,16 @@
 * Select pane.
 */

-enum cmd_retval	 cmd_select_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_select_pane_entry = {
 	.name = "select-pane",
 	.alias = "selectp",

-	.args = { "DdegLlMmP:Rt:U", 0, 0 },
-	.usage = "[-DdegLlMmRU] [-P style] " CMD_TARGET_PANE_USAGE,
+	.args = { "DdegLlMmP:RT:t:U", 0, 0 },
+	.usage = "[-DdegLlMmRU] [-P style] [-T title] " CMD_TARGET_PANE_USAGE,

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

 	.flags = 0,
 	.exec = cmd_select_pane_exec
@@ -46,42 +46,42 @@ const struct cmd_entry cmd_last_pane_entry = {
 	.args = { "det:", 0, 0 },
 	.usage = "[-de] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_select_pane_exec
 };

-enum cmd_retval
-cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct cmd_find_state	*current = &item->shared->current;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct session		*s = cmdq->state.tflag.s;
-	struct window_pane	*wp = cmdq->state.tflag.wp, *lastwp, *markedwp;
+	struct session		*s = item->target.s;
+	struct window_pane	*wp = item->target.wp, *lastwp, *markedwp;
 	const char		*style;

 	if (self->entry == &cmd_last_pane_entry || args_has(args, 'l')) {
-
-		if (wl->window->last == NULL) {
-			cmdq_error(cmdq, "no last pane");
+		lastwp = w->last;
+		if (lastwp == NULL) {
+			cmdq_error(item, "no last pane");
 			return (CMD_RETURN_ERROR);
 		}
-
 		if (args_has(self->args, 'e'))
-			w->last->flags &= ~PANE_INPUTOFF;
+			lastwp->flags &= ~PANE_INPUTOFF;
 		else if (args_has(self->args, 'd'))
-			w->last->flags |= PANE_INPUTOFF;
+			lastwp->flags |= PANE_INPUTOFF;
 		else {
 			server_unzoom_window(w);
-			window_redraw_active_switch(w, w->last);
-			if (window_set_active_pane(w, w->last)) {
+			window_redraw_active_switch(w, lastwp);
+			if (window_set_active_pane(w, lastwp)) {
+				cmd_find_from_winlink(current, wl, 0);
 				server_status_window(w);
 				server_redraw_window_borders(w);
 			}
 		}
-
 		return (CMD_RETURN_NORMAL);
 	}

@@ -112,13 +112,13 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 			style = args_get(args, 'P');
 			if (style_parse(&grid_default_cell, &wp->colgc,
 			    style) == -1) {
-				cmdq_error(cmdq, "bad style: %s", style);
+				cmdq_error(item, "bad style: %s", style);
 				return (CMD_RETURN_ERROR);
 			}
 			wp->flags |= PANE_REDRAW;
 		}
 		if (args_has(self->args, 'g'))
-			cmdq_print(cmdq, "%s", style_tostring(&wp->colgc));
+			cmdq_print(item, "%s", style_tostring(&wp->colgc));
 		return (CMD_RETURN_NORMAL);
 	}

@@ -147,15 +147,22 @@ cmd_select_pane_exec(struct cmd *self, struct cmd_q *cmdq)
 		return (CMD_RETURN_NORMAL);
 	}

+	if (args_has(self->args, 'T')) {
+	    screen_set_title(&wp->base, args_get(self->args, 'T'));
+	    server_status_window(wp->window);
+	}
+
 	if (wp == w->active)
 		return (CMD_RETURN_NORMAL);
 	server_unzoom_window(wp->window);
 	if (!window_pane_visible(wp)) {
-		cmdq_error(cmdq, "pane not visible");
+		cmdq_error(item, "pane not visible");
 		return (CMD_RETURN_ERROR);
 	}
 	window_redraw_active_switch(w, wp);
 	if (window_set_active_pane(w, wp)) {
+		cmd_find_from_winlink_pane(current, wl, wp, 0);
+		hooks_insert(s->hooks, item, current, "after-select-pane");
 		server_status_window(w);
 		server_redraw_window_borders(w);
 	}
--- a/cmd-select-window.c
+++ b/cmd-select-window.c
@@ -26,7 +26,8 @@
 * Select window by index.
 */

-enum cmd_retval	 cmd_select_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_select_window_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_select_window_entry = {
 	.name = "select-window",
@@ -35,7 +36,7 @@ const struct cmd_entry cmd_select_window_entry = {
 	.args = { "lnpTt:", 0, 0 },
 	.usage = "[-lnpT] " CMD_TARGET_WINDOW_USAGE,

-	.tflag = CMD_WINDOW,
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -48,7 +49,7 @@ const struct cmd_entry cmd_next_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -61,7 +62,7 @@ const struct cmd_entry cmd_previous_window_entry = {
 	.args = { "at:", 0, 0 },
 	.usage = "[-a] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = 0,
 	.exec = cmd_select_window_exec
@@ -74,18 +75,19 @@ const struct cmd_entry cmd_last_window_entry = {
 	.args = { "t:", 0, 0 },
 	.usage = CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

 	.flags = 0,
 	.exec = cmd_select_window_exec
 };

-enum cmd_retval
-cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_select_window_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct winlink	*wl = cmdq->state.tflag.wl;
-	struct session	*s = cmdq->state.tflag.s;
-	int		 next, previous, last, activity;
+	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 = self->entry == &cmd_next_window_entry;
 	if (args_has(self->args, 'n'))
@@ -101,22 +103,23 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		activity = args_has(self->args, 'a');
 		if (next) {
 			if (session_next(s, activity) != 0) {
-				cmdq_error(cmdq, "no next window");
+				cmdq_error(item, "no next window");
 				return (CMD_RETURN_ERROR);
 			}
 		} else if (previous) {
 			if (session_previous(s, activity) != 0) {
-				cmdq_error(cmdq, "no previous window");
+				cmdq_error(item, "no previous window");
 				return (CMD_RETURN_ERROR);
 			}
 		} else {
 			if (session_last(s) != 0) {
-				cmdq_error(cmdq, "no last window");
+				cmdq_error(item, "no last window");
 				return (CMD_RETURN_ERROR);
 			}
 		}
-
+		cmd_find_from_session(current, s, 0);
 		server_redraw_session(s);
+		hooks_insert(s->hooks, item, current, "after-select-window");
 	} else {
 		/*
 		 * If -T and select-window is invoked on same window as
@@ -124,12 +127,17 @@ cmd_select_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		 */
 		if (args_has(self->args, 'T') && wl == s->curw) {
 			if (session_last(s) != 0) {
-				cmdq_error(cmdq, "no last window");
+				cmdq_error(item, "no last window");
 				return (-1);
 			}
+			if (current->s == s)
+				cmd_find_from_session(current, s, 0);
 			server_redraw_session(s);
-		} else if (session_select(s, wl->idx) == 0)
+		} else if (session_select(s, wl->idx) == 0) {
+			cmd_find_from_session(current, s, 0);
 			server_redraw_session(s);
+		}
+		hooks_insert(s->hooks, item, current, "after-select-window");
 	}
 	recalculate_sizes();

--- a/cmd-send-keys.c
+++ b/cmd-send-keys.c
@@ -27,18 +27,18 @@
 * Send keys to client.
 */

-enum cmd_retval	 cmd_send_keys_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_send_keys_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_send_keys_entry = {
 	.name = "send-keys",
 	.alias = "send",

-	.args = { "lRMt:", 0, -1 },
-	.usage = "[-lRM] " CMD_TARGET_PANE_USAGE " key ...",
+	.args = { "lXRMN:t:", 0, -1 },
+	.usage = "[-lXRM] [-N repeat-count] " CMD_TARGET_PANE_USAGE " key ...",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_send_keys_exec
 };

@@ -49,27 +49,79 @@ const struct cmd_entry cmd_send_prefix_entry = {
 	.args = { "2t:", 0, 0 },
 	.usage = "[-2] " CMD_TARGET_PANE_USAGE,

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_send_keys_exec
 };

-enum cmd_retval
-cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
+static void
+cmd_send_keys_inject(struct client *c, struct cmdq_item *item, key_code key)
+{
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct key_table	*table;
+	struct key_binding	*bd, bd_find;
+
+	if (wp->mode == NULL || wp->mode->key_table == NULL) {
+		if (options_get_number(wp->window->options, "xterm-keys"))
+			key |= KEYC_XTERM;
+		window_pane_key(wp, NULL, s, key, NULL);
+		return;
+	}
+	table = key_bindings_get_table(wp->mode->key_table(wp), 1);
+
+	bd_find.key = (key & ~KEYC_XTERM);
+	bd = RB_FIND(key_bindings, &table->key_bindings, &bd_find);
+	if (bd != NULL) {
+		table->references++;
+		key_bindings_dispatch(bd, item, c, NULL, &item->target);
+		key_bindings_unref_table(table);
+	}
+}
+
+static enum cmd_retval
+cmd_send_keys_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct window_pane	*wp = cmdq->state.tflag.wp;
-	struct session		*s = cmdq->state.tflag.s;
-	struct mouse_event	*m = &cmdq->item->mouse;
-	const u_char		*keystr;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct window_pane	*wp = item->target.wp;
+	struct session		*s = item->target.s;
+	struct mouse_event	*m = &item->shared->mouse;
+	struct utf8_data	*ud, *uc;
+	wchar_t			 wc;
 	int			 i, literal;
 	key_code		 key;
+	u_int			 np = 1;
+	char			*cause = NULL;
+
+	if (args_has(args, 'N')) {
+		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 (args_has(args, 'X') || args->argc == 0)
+			wp->modeprefix = np;
+	}
+
+	if (args_has(args, 'X')) {
+		if (wp->mode == NULL || wp->mode->command == NULL) {
+			cmdq_error(item, "not in a mode");
+			return (CMD_RETURN_ERROR);
+		}
+		if (!m->valid)
+			wp->mode->command(wp, c, s, args, NULL);
+		else
+			wp->mode->command(wp, c, s, args, m);
+		return (CMD_RETURN_NORMAL);
+	}

 	if (args_has(args, 'M')) {
 		wp = cmd_mouse_pane(m, &s, NULL);
 		if (wp == NULL) {
-			cmdq_error(cmdq, "no mouse target");
+			cmdq_error(item, "no mouse target");
 			return (CMD_RETURN_ERROR);
 		}
 		window_pane_key(wp, NULL, s, m->key, m);
@@ -81,26 +133,36 @@ cmd_send_keys_exec(struct cmd *self, struct cmd_q *cmdq)
 			key = options_get_number(s->options, "prefix2");
 		else
 			key = options_get_number(s->options, "prefix");
-		window_pane_key(wp, NULL, s, key, NULL);
+		cmd_send_keys_inject(c, item, key);
 		return (CMD_RETURN_NORMAL);
 	}

-	if (args_has(args, 'R'))
+	if (args_has(args, 'R')) {
+		window_pane_reset_palette(wp);
 		input_reset(wp, 1);
+	}

-	for (i = 0; i < args->argc; i++) {
-		literal = args_has(args, 'l');
-		if (!literal) {
-			key = key_string_lookup_string(args->argv[i]);
-			if (key != KEYC_NONE && key != KEYC_UNKNOWN)
-				window_pane_key(wp, NULL, s, key, NULL);
-			else
-				literal = 1;
-		}
-		if (literal) {
-			for (keystr = args->argv[i]; *keystr != '\0'; keystr++)
-				window_pane_key(wp, NULL, s, *keystr, NULL);
+	for (; np != 0; np--) {
+		for (i = 0; i < args->argc; i++) {
+			literal = args_has(args, 'l');
+			if (!literal) {
+				key = key_string_lookup_string(args->argv[i]);
+				if (key != KEYC_NONE && key != KEYC_UNKNOWN)
+					cmd_send_keys_inject(c, item, key);
+				else
+					literal = 1;
+			}
+			if (literal) {
+				ud = utf8_fromcstr(args->argv[i]);
+				for (uc = ud; uc->size != 0; uc++) {
+					if (utf8_combine(uc, &wc) != UTF8_DONE)
+						continue;
+					cmd_send_keys_inject(c, item, wc);
+				}
+				free(ud);
+			}
 		}
+
 	}

 	return (CMD_RETURN_NORMAL);
--- a/cmd-set-buffer.c
+++ b/cmd-set-buffer.c
@@ -27,7 +27,7 @@
 * Add, set, append to or delete a paste buffer.
 */

-enum cmd_retval	 cmd_set_buffer_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_buffer_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_set_buffer_entry = {
 	.name = "set-buffer",
@@ -36,7 +36,7 @@ const struct cmd_entry cmd_set_buffer_entry = {
 	.args = { "ab:n:", 0, 1 },
 	.usage = "[-a] " CMD_BUFFER_USAGE " [-n new-buffer-name] data",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };

@@ -47,12 +47,12 @@ const struct cmd_entry cmd_delete_buffer_entry = {
 	.args = { "b:", 0, 0 },
 	.usage = CMD_BUFFER_USAGE,

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_buffer_exec
 };

-enum cmd_retval
-cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_buffer_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct paste_buffer	*pb;
@@ -70,7 +70,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (pb == NULL)
 			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		paste_free(pb);
@@ -81,11 +81,11 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 		if (pb == NULL)
 			pb = paste_get_top(&bufname);
 		if (pb == NULL) {
-			cmdq_error(cmdq, "no buffer");
+			cmdq_error(item, "no buffer");
 			return (CMD_RETURN_ERROR);
 		}
 		if (paste_rename(bufname, args_get(args, 'n'), &cause) != 0) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 			return (CMD_RETURN_ERROR);
 		}
@@ -93,7 +93,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	}

 	if (args->argc != 1) {
-		cmdq_error(cmdq, "no data specified");
+		cmdq_error(item, "no data specified");
 		return (CMD_RETURN_ERROR);
 	}
 	if ((newsize = strlen(args->argv[0])) == 0)
@@ -113,7 +113,7 @@ cmd_set_buffer_exec(struct cmd *self, struct cmd_q *cmdq)
 	bufsize += newsize;

 	if (paste_set(bufdata, bufsize, bufname, &cause) != 0) {
-		cmdq_error(cmdq, "%s", cause);
+		cmdq_error(item, "%s", cause);
 		free(bufdata);
 		free(cause);
 		return (CMD_RETURN_ERROR);
--- a/cmd-set-environment.c
+++ b/cmd-set-environment.c
@@ -27,7 +27,8 @@
 * Set an environment variable.
 */

-enum cmd_retval	 cmd_set_environment_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_environment_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_set_environment_entry = {
 	.name = "set-environment",
@@ -36,14 +37,14 @@ const struct cmd_entry cmd_set_environment_entry = {
 	.args = { "grt:u", 1, 2 },
 	.usage = "[-gru] " CMD_TARGET_SESSION_USAGE " name [value]",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_environment_exec
 };

-enum cmd_retval
-cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct environ	*env;
@@ -51,11 +52,11 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)

 	name = args->argv[0];
 	if (*name == '\0') {
-		cmdq_error(cmdq, "empty variable name");
+		cmdq_error(item, "empty variable name");
 		return (CMD_RETURN_ERROR);
 	}
 	if (strchr(name, '=') != NULL) {
-		cmdq_error(cmdq, "variable name contains =");
+		cmdq_error(item, "variable name contains =");
 		return (CMD_RETURN_ERROR);
 	}

@@ -67,32 +68,32 @@ cmd_set_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
+		if (item->target.s == NULL) {
 			target = args_get(args, 't');
 			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", target);
 			else
-				cmdq_error(cmdq, "no current session");
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = cmdq->state.tflag.s->environ;
+		env = item->target.s->environ;
 	}

 	if (args_has(self->args, 'u')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -u");
+			cmdq_error(item, "can't specify a value with -u");
 			return (CMD_RETURN_ERROR);
 		}
 		environ_unset(env, name);
 	} else if (args_has(self->args, 'r')) {
 		if (value != NULL) {
-			cmdq_error(cmdq, "can't specify a value with -r");
+			cmdq_error(item, "can't specify a value with -r");
 			return (CMD_RETURN_ERROR);
 		}
 		environ_clear(env, name);
 	} else {
 		if (value == NULL) {
-			cmdq_error(cmdq, "no value specified");
+			cmdq_error(item, "no value specified");
 			return (CMD_RETURN_ERROR);
 		}
 		environ_set(env, name, "%s", value);
--- a/cmd-set-hook.c
+++ b/cmd-set-hook.c
@@ -27,7 +27,7 @@
 * Set or show global or session hooks.
 */

-enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval cmd_set_hook_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_set_hook_entry = {
 	.name = "set-hook",
@@ -36,9 +36,9 @@ const struct cmd_entry cmd_set_hook_entry = {
 	.args = { "gt:u", 1, 2 },
 	.usage = "[-gu] " CMD_TARGET_SESSION_USAGE " hook-name [command]",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_hook_exec
 };

@@ -49,32 +49,41 @@ const struct cmd_entry cmd_show_hooks_entry = {
 	.args = { "gt:", 0, 1 },
 	.usage = "[-g] " CMD_TARGET_SESSION_USAGE,

-	.tflag = CMD_SESSION,
+	.target = { 't', CMD_FIND_SESSION, 0 },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_hook_exec
 };

-enum cmd_retval
-cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_hook_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	struct cmd_list	*cmdlist;
 	struct hooks	*hooks;
 	struct hook	*hook;
 	char		*cause, *tmp;
-	const char	*name, *cmd;
+	const char	*name, *cmd, *target;

 	if (args_has(args, 'g'))
 		hooks = global_hooks;
-	else
-		hooks = cmdq->state.tflag.s->hooks;
+	else {
+		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);
+		}
+		hooks = item->target.s->hooks;
+	}

 	if (self->entry == &cmd_show_hooks_entry) {
 		hook = hooks_first(hooks);
 		while (hook != NULL) {
 			tmp = cmd_list_print(hook->cmdlist);
-			cmdq_print(cmdq, "%s -> %s", hook->name, tmp);
+			cmdq_print(item, "%s -> %s", hook->name, tmp);
 			free(tmp);

 			hook = hooks_next(hook);
@@ -84,7 +93,7 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)

 	name = args->argv[0];
 	if (*name == '\0') {
-		cmdq_error(cmdq, "invalid hook name");
+		cmdq_error(item, "invalid hook name");
 		return (CMD_RETURN_ERROR);
 	}
 	if (args->argc < 2)
@@ -94,7 +103,7 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)

 	if (args_has(args, 'u')) {
 		if (cmd != NULL) {
-			cmdq_error(cmdq, "command passed to unset hook: %s",
+			cmdq_error(item, "command passed to unset hook: %s",
 			    name);
 			return (CMD_RETURN_ERROR);
 		}
@@ -103,12 +112,13 @@ cmd_set_hook_exec(struct cmd *self, struct cmd_q *cmdq)
 	}

 	if (cmd == NULL) {
-		cmdq_error(cmdq, "no command to set hook: %s", name);
+		cmdq_error(item, "no command to set hook: %s", name);
 		return (CMD_RETURN_ERROR);
 	}
-	if (cmd_string_parse(cmd, &cmdlist, NULL, 0, &cause) != 0) {
+	cmdlist = cmd_string_parse(cmd, NULL, 0, &cause);
+	if (cmdlist == NULL) {
 		if (cause != NULL) {
-			cmdq_error(cmdq, "%s", cause);
+			cmdq_error(item, "%s", cause);
 			free(cause);
 		}
 		return (CMD_RETURN_ERROR);
--- a/cmd-set-option.c
+++ b/cmd-set-option.c
@@ -27,53 +27,27 @@
 * Set an option.
 */

-enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_set_option_exec(struct cmd *, struct cmdq_item *);

-enum cmd_retval	cmd_set_option_user(struct cmd *, struct cmd_q *,
-	    const char *, const char *);
-
-int	cmd_set_option_unset(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-int	cmd_set_option_set(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-
-struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_key(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
-struct options_entry *cmd_set_option_style(struct cmd *, struct cmd_q *,
-	    const struct options_table_entry *, struct options *,
-	    const char *);
+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 = { "agoqst:uw", 1, 2 },
-	.usage = "[-agosquw] [-t target-window] option [value]",
+	.args = { "aFgoqst:uw", 1, 2 },
+	.usage = "[-aFgosquw] [-t target-window] option [value]",

-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
 };

@@ -81,369 +55,313 @@ const struct cmd_entry cmd_set_window_option_entry = {
 	.name = "set-window-option",
 	.alias = "setw",

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

-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_set_option_exec
 };

-enum cmd_retval
-cmd_set_option_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_set_option_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args				*args = self->args;
-	struct session				*s = cmdq->state.tflag.s;
-	struct winlink				*wl = cmdq->state.tflag.wl;
-	struct window				*w;
-	struct client				*c;
-	const struct options_table_entry	*oe;
-	struct options				*oo;
-	const char				*optstr, *valstr, *target;
+	struct args			*args = self->args;
+	int				 append = args_has(args, 'a');
+	struct cmd_find_state		*fs = &item->target;
+	struct client			*c, *loop;
+	struct session			*s = fs->s;
+	struct winlink			*wl = fs->wl;
+	struct window			*w;
+	enum options_table_scope	 scope;
+	struct options			*oo;
+	struct options_entry		*parent, *o;
+	char				*name, *argument, *value = NULL, *cause;
+	const char			*target;
+	int				 window, idx, already, error, ambiguous;

-	/* Get the option name and value. */
-	optstr = args->argv[0];
-	if (*optstr == '\0') {
-		cmdq_error(cmdq, "invalid option");
-		return (CMD_RETURN_ERROR);
+	/* Expand argument. */
+	c = cmd_find_client(item, NULL, 1);
+	argument = format_single(item, args->argv[0], c, s, wl, NULL);
+
+	/* Parse option name and index. */
+	name = options_match(argument, &idx, &ambiguous);
+	if (name == NULL) {
+		if (args_has(args, 'q'))
+			goto out;
+		if (ambiguous)
+			cmdq_error(item, "ambiguous option: %s", argument);
+		else
+			cmdq_error(item, "invalid option: %s", argument);
+		goto fail;
 	}
 	if (args->argc < 2)
-		valstr = NULL;
+		value = NULL;
+	else if (args_has(args, 'F'))
+		value = format_single(item, args->argv[1], c, s, wl, NULL);
 	else
-		valstr = args->argv[1];
+		value = xstrdup(args->argv[1]);

-	/* Is this a user option? */
-	if (*optstr == '@')
-		return (cmd_set_option_user(self, cmdq, optstr, valstr));
-
-	/* Find the option entry, try each table. */
-	oe = NULL;
-	if (options_table_find(optstr, &oe) != 0) {
-		if (!args_has(args, 'q')) {
-			cmdq_error(cmdq, "ambiguous option: %s", optstr);
-			return (CMD_RETURN_ERROR);
+	/*
+	 * Figure out the scope: for user options it comes from the arguments,
+	 * otherwise from the option name.
+	 */
+	if (*name == '@') {
+		window = (self->entry == &cmd_set_window_option_entry);
+		scope = options_scope_from_flags(args, window, fs, &oo, &cause);
+	} else {
+		if (options_get_only(global_options, name) != NULL)
+			scope = OPTIONS_TABLE_SERVER;
+		else if (options_get_only(global_s_options, name) != NULL)
+			scope = OPTIONS_TABLE_SESSION;
+		else if (options_get_only(global_w_options, name) != NULL)
+			scope = OPTIONS_TABLE_WINDOW;
+		else {
+			scope = OPTIONS_TABLE_NONE;
+			xasprintf(&cause, "unknown option: %s", argument);
 		}
-		return (CMD_RETURN_NORMAL);
 	}
-	if (oe == NULL) {
-		if (!args_has(args, 'q')) {
-			cmdq_error(cmdq, "unknown option: %s", optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		return (CMD_RETURN_NORMAL);
+	if (scope == OPTIONS_TABLE_NONE) {
+		if (args_has(args, 'q'))
+			goto out;
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		goto fail;
 	}

-	/* Work out the tree from the scope of the option. */
-	if (oe->scope == OPTIONS_TABLE_SERVER)
+	/* Which table should this option go into? */
+	if (scope == OPTIONS_TABLE_SERVER)
 		oo = global_options;
-	else if (oe->scope == OPTIONS_TABLE_WINDOW) {
-		if (args_has(self->args, 'g'))
-			oo = global_w_options;
-		else if (wl == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL) {
-				cmdq_error(cmdq, "no such window: %s",
-				    target);
-			} else
-				cmdq_error(cmdq, "no current window");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = wl->window->options;
-	} else if (oe->scope == OPTIONS_TABLE_SESSION) {
+	else if (scope == OPTIONS_TABLE_SESSION) {
 		if (args_has(self->args, 'g'))
 			oo = global_s_options;
 		else if (s == NULL) {
 			target = args_get(args, 't');
-			if (target != NULL) {
-				cmdq_error(cmdq, "no such session: %s",
-				    target);
-			} else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
+			if (target != NULL)
+				cmdq_error(item, "no such session: %s", target);
+			else
+				cmdq_error(item, "no current session");
+			goto fail;
 		} else
 			oo = s->options;
-	} else {
-		cmdq_error(cmdq, "unknown table");
-		return (CMD_RETURN_ERROR);
+	} else if (scope == OPTIONS_TABLE_WINDOW) {
+		if (args_has(self->args, 'g'))
+			oo = global_w_options;
+		else if (wl == NULL) {
+			target = args_get(args, 't');
+			if (target != NULL)
+				cmdq_error(item, "no such window: %s", target);
+			else
+				cmdq_error(item, "no current window");
+			goto fail;
+		} else
+			oo = wl->window->options;
 	}
+	o = options_get_only(oo, name);
+	parent = options_get(oo, name);

-	/* Unset or set the option. */
-	if (args_has(args, 'u')) {
-		if (cmd_set_option_unset(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
-	} else {
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
+	/* Check that array options and indexes match up. */
+	if (idx != -1) {
+		if (*name == '@' || options_array_size(parent, NULL) == -1) {
+			cmdq_error(item, "not an array: %s", argument);
+			goto fail;
 		}
-		if (cmd_set_option_set(self, cmdq, oe, oo, valstr) != 0)
-			return (CMD_RETURN_ERROR);
 	}

-	/* Start or stop timers if necessary. */
-	if (strcmp(oe->name, "automatic-rename") == 0) {
+	/* With -o, check this option is not already set. */
+	if (!args_has(args, 'u') && args_has(args, 'o')) {
+		if (idx == -1)
+			already = (o != NULL);
+		else {
+			if (o == NULL)
+				already = 0;
+			else
+				already = (options_array_get(o, idx) != NULL);
+		}
+		if (already) {
+			if (args_has(args, 'q'))
+				goto out;
+			cmdq_error(item, "already set: %s", argument);
+			goto fail;
+		}
+	}
+
+	/* Change the option. */
+	if (args_has(args, 'u')) {
+		if (o == NULL)
+			goto out;
+		if (idx == -1) {
+			if (oo == global_options ||
+			    oo == global_s_options ||
+			    oo == global_w_options)
+				options_default(oo, options_table_entry(o));
+			else
+				options_remove(o);
+		} else
+			options_array_set(o, idx, NULL, 0);
+	} else if (*name == '@') {
+		if (value == NULL) {
+			cmdq_error(item, "empty value");
+			goto fail;
+		}
+		options_set_string(oo, name, append, "%s", value);
+	} else if (idx == -1 && options_array_size(parent, NULL) == -1) {
+		error = cmd_set_option_set(self, item, oo, parent, value);
+		if (error != 0)
+			goto fail;
+	} else {
+		if (value == NULL) {
+			cmdq_error(item, "empty value");
+			goto fail;
+		}
+		if (o == NULL)
+			o = options_empty(oo, options_table_entry(parent));
+		if (idx == -1) {
+			if (!append)
+				options_array_clear(o);
+			options_array_assign(o, value);
+		} else if (options_array_set(o, idx, value, append) != 0) {
+			cmdq_error(item, "invalid index: %s", argument);
+			goto fail;
+		}
+	}
+
+	/* 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(oe->name, "key-table") == 0) {
-		TAILQ_FOREACH(c, &clients, entry)
-			server_client_set_key_table(c, NULL);
+	if (strcmp(name, "key-table") == 0) {
+		TAILQ_FOREACH(loop, &clients, entry)
+			server_client_set_key_table(loop, NULL);
 	}
-	if (strcmp(oe->name, "status") == 0 ||
-	    strcmp(oe->name, "status-interval") == 0)
+	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") == 0 ||
+	    strcmp(name, "status-interval") == 0)
 		status_timer_start_all();
-	if (strcmp(oe->name, "monitor-silence") == 0)
+	if (strcmp(name, "monitor-silence") == 0)
 		alerts_reset_all();
+	if (strcmp(name, "window-style") == 0 ||
+	    strcmp(name, "window-active-style") == 0) {
+		RB_FOREACH(w, windows, &windows)
+			w->flags |= WINDOW_STYLECHANGED;
+	}
+	if (strcmp(name, "pane-border-status") == 0) {
+		RB_FOREACH(w, windows, &windows)
+			layout_fix_panes(w, w->sx, w->sy);
+	}
+	RB_FOREACH(s, sessions, &sessions)
+		status_update_saved(s);

-	/* Update sizes and redraw. May not need it but meh. */
+	/*
+	 * Update sizes and redraw. May not always be necessary but do it
+	 * anyway.
+	 */
 	recalculate_sizes();
-	TAILQ_FOREACH(c, &clients, entry) {
-		if (c->session != NULL)
-			server_redraw_client(c);
+	TAILQ_FOREACH(loop, &clients, entry) {
+		if (loop->session != NULL)
+			server_redraw_client(loop);
 	}

+out:
+	free(argument);
+	free(value);
+	free(name);
 	return (CMD_RETURN_NORMAL);
+
+fail:
+	free(argument);
+	free(value);
+	free(name);
+	return (CMD_RETURN_ERROR);
 }

-/* Set user option. */
-enum cmd_retval
-cmd_set_option_user(struct cmd *self, struct cmd_q *cmdq, const char *optstr,
-    const char *valstr)
+static int
+cmd_set_option_set(struct cmd *self, struct cmdq_item *item, struct options *oo,
+    struct options_entry *parent, const char *value)
 {
-	struct args	*args = self->args;
-	struct session	*s = cmdq->state.tflag.s;
-	struct winlink	*wl = cmdq->state.tflag.wl;
-	struct options	*oo;
+	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;
+	key_code				 key;

-	if (args_has(args, 's'))
-		oo = global_options;
-	else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_set_window_option_entry) {
-		if (args_has(self->args, 'g'))
-			oo = global_w_options;
-		else
-			oo = wl->window->options;
-	} else {
-		if (args_has(self->args, 'g'))
-			oo = global_s_options;
-		else
-			oo = s->options;
-	}
-
-	if (args_has(args, 'u')) {
-		if (options_find1(oo, optstr) == NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "unknown option: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		if (valstr != NULL) {
-			cmdq_error(cmdq, "value passed to unset option: %s",
-			    optstr);
-			return (CMD_RETURN_ERROR);
-		}
-		options_remove(oo, optstr);
-	} else {
-		if (valstr == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (CMD_RETURN_ERROR);
-		}
-		if (args_has(args, 'o') && options_find1(oo, optstr) != NULL) {
-			if (!args_has(args, 'q')) {
-				cmdq_error(cmdq, "already set: %s", optstr);
-				return (CMD_RETURN_ERROR);
-			}
-			return (CMD_RETURN_NORMAL);
-		}
-		options_set_string(oo, optstr, "%s", valstr);
-	}
-	return (CMD_RETURN_NORMAL);
-}
-
-/* Unset an option. */
-int
-cmd_set_option_unset(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args	*args = self->args;
-
-	if (value != NULL) {
-		cmdq_error(cmdq, "value passed to unset option: %s", oe->name);
+	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);
 	}

-	if (args_has(args, 'g') || oo == global_options) {
-		switch (oe->type) {
-		case OPTIONS_TABLE_STRING:
-			options_set_string(oo, oe->name, "%s", oe->default_str);
-			break;
-		case OPTIONS_TABLE_STYLE:
-			options_set_style(oo, oe->name, oe->default_str, 0);
-			break;
-		default:
-			options_set_number(oo, oe->name, oe->default_num);
-			break;
-		}
-	} else
-		options_remove(oo, oe->name);
-	return (0);
-}
-
-/* Set an option. */
-int
-cmd_set_option_set(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct options_entry	*o;
-
-	switch (oe->type) {
-	case OPTIONS_TABLE_FLAG:
-	case OPTIONS_TABLE_CHOICE:
-		break;
-	default:
-		if (value == NULL) {
-			cmdq_error(cmdq, "empty value");
-			return (-1);
-		}
-	}
-
-	o = NULL;
 	switch (oe->type) {
 	case OPTIONS_TABLE_STRING:
-		o = cmd_set_option_string(self, cmdq, oe, oo, value);
-		break;
+		options_set_string(oo, oe->name, append, "%s", value);
+		return (0);
 	case OPTIONS_TABLE_NUMBER:
-		o = cmd_set_option_number(self, cmdq, oe, oo, value);
-		break;
+		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:
-		o = cmd_set_option_key(self, cmdq, oe, oo, value);
-		break;
+		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:
-		o = cmd_set_option_colour(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
+		if ((number = colour_fromstring(value)) == -1) {
+			cmdq_error(item, "bad colour: %s", value);
+			return (-1);
+		}
+		o = options_set_number(oo, oe->name, number);
+		options_style_update_new(oo, o);
+		return (0);
 	case OPTIONS_TABLE_ATTRIBUTES:
-		o = cmd_set_option_attributes(self, cmdq, oe, oo, value);
-		if (o != NULL)
-			style_update_new(oo, o->name, oe->style);
-		break;
+		if ((number = attributes_fromstring(value)) == -1) {
+			cmdq_error(item, "bad attributes: %s", value);
+			return (-1);
+		}
+		o = options_set_number(oo, oe->name, number);
+		options_style_update_new(oo, o);
+		return (0);
 	case OPTIONS_TABLE_FLAG:
-		o = cmd_set_option_flag(self, cmdq, oe, oo, value);
-		break;
+		return (cmd_set_option_flag(item, oe, oo, value));
 	case OPTIONS_TABLE_CHOICE:
-		o = cmd_set_option_choice(self, cmdq, oe, oo, value);
-		break;
+		return (cmd_set_option_choice(item, oe, oo, value));
 	case OPTIONS_TABLE_STYLE:
-		o = cmd_set_option_style(self, cmdq, oe, oo, value);
+		o = options_set_style(oo, oe->name, append, value);
+		if (o == NULL) {
+			cmdq_error(item, "bad style: %s", value);
+			return (-1);
+		}
+		options_style_update_old(oo, o);
+		return (0);
+	case OPTIONS_TABLE_ARRAY:
 		break;
 	}
-	if (o == NULL)
-		return (-1);
-	return (0);
+	return (-1);
 }

-/* Set a string option. */
-struct options_entry *
-cmd_set_option_string(struct cmd *self, __unused struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	char			*oldval, *newval;
-
-	if (args_has(args, 'a')) {
-		oldval = options_get_string(oo, oe->name);
-		xasprintf(&newval, "%s%s", oldval, value);
-	} else
-		newval = xstrdup(value);
-
-	o = options_set_string(oo, oe->name, "%s", newval);
-
-	free(newval);
-	return (o);
-}
-
-/* Set a number option. */
-struct options_entry *
-cmd_set_option_number(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	long long	 ll;
-	const char     	*errstr;
-
-	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
-	if (errstr != NULL) {
-		cmdq_error(cmdq, "value is %s: %s", errstr, value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, ll));
-}
-
-/* Set a key option. */
-struct options_entry *
-cmd_set_option_key(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	key_code	key;
-
-	key = key_string_lookup_string(value);
-	if (key == KEYC_UNKNOWN) {
-		cmdq_error(cmdq, "bad key: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, key));
-}
-
-/* Set a colour option. */
-struct options_entry *
-cmd_set_option_colour(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	int	colour;
-
-	if ((colour = colour_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad colour: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, colour));
-}
-
-/* Set an attributes option. */
-struct options_entry *
-cmd_set_option_attributes(__unused struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	int	attr;
-
-	if ((attr = attributes_fromstring(value)) == -1) {
-		cmdq_error(cmdq, "bad attributes: %s", value);
-		return (NULL);
-	}
-
-	return (options_set_number(oo, oe->name, attr));
-}
-
-/* Set a flag option. */
-struct options_entry *
-cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,
+static int
+cmd_set_option_flag(struct cmdq_item *item,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
 {
@@ -451,31 +369,28 @@ cmd_set_option_flag(__unused struct cmd *self, struct cmd_q *cmdq,

 	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 {
-		if ((value[0] == '1' && value[1] == '\0') ||
-		    strcasecmp(value, "on") == 0 ||
-		    strcasecmp(value, "yes") == 0)
-			flag = 1;
-		else if ((value[0] == '0' && value[1] == '\0') ||
-		    strcasecmp(value, "off") == 0 ||
-		    strcasecmp(value, "no") == 0)
-			flag = 0;
-		else {
-			cmdq_error(cmdq, "bad value: %s", value);
-			return (NULL);
-		}
+		cmdq_error(item, "bad value: %s", value);
+		return (-1);
 	}
-
-	return (options_set_number(oo, oe->name, flag));
+	options_set_number(oo, oe->name, flag);
+	return (0);
 }

-/* Set a choice option. */
-struct options_entry *
-cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
+static int
+cmd_set_option_choice(struct cmdq_item *item,
    const struct options_table_entry *oe, struct options *oo,
    const char *value)
 {
-	const char	**choicep;
+	const char	**cp;
 	int		  n, choice = -1;

 	if (value == NULL) {
@@ -484,42 +399,16 @@ cmd_set_option_choice(__unused struct cmd *self, struct cmd_q *cmdq,
 			choice = !choice;
 	} else {
 		n = 0;
-		for (choicep = oe->choices; *choicep != NULL; choicep++) {
+		for (cp = oe->choices; *cp != NULL; cp++) {
+			if (strcmp(*cp, value) == 0)
+				choice = n;
 			n++;
-			if (strncmp(*choicep, value, strlen(value)) != 0)
-				continue;
-
-			if (choice != -1) {
-				cmdq_error(cmdq, "ambiguous value: %s", value);
-				return (NULL);
-			}
-			choice = n - 1;
 		}
 		if (choice == -1) {
-			cmdq_error(cmdq, "unknown value: %s", value);
-			return (NULL);
+			cmdq_error(item, "unknown value: %s", value);
+			return (-1);
 		}
 	}
-
-	return (options_set_number(oo, oe->name, choice));
-}
-
-/* Set a style option. */
-struct options_entry *
-cmd_set_option_style(struct cmd *self, struct cmd_q *cmdq,
-    const struct options_table_entry *oe, struct options *oo,
-    const char *value)
-{
-	struct args		*args = self->args;
-	struct options_entry	*o;
-	int			 append;
-
-	append = args_has(args, 'a');
-	if ((o = options_set_style(oo, oe->name, value, append)) == NULL) {
-		cmdq_error(cmdq, "bad style: %s", value);
-		return (NULL);
-	}
-
-	style_update_old(oo, oe->name, &o->style);
-	return (o);
+	options_set_number(oo, oe->name, choice);
+	return (0);
 }
--- a/cmd-show-environment.c
+++ b/cmd-show-environment.c
@@ -27,11 +27,12 @@
 * Show environment.
 */

-enum cmd_retval	cmd_show_environment_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_environment_exec(struct cmd *,
+			    struct cmdq_item *);

-char	*cmd_show_environment_escape(struct environ_entry *);
-void	 cmd_show_environment_print(struct cmd *, struct cmd_q *,
-	     struct environ_entry *);
+static char	*cmd_show_environment_escape(struct environ_entry *);
+static void	 cmd_show_environment_print(struct cmd *, struct cmdq_item *,
+		     struct environ_entry *);

 const struct cmd_entry cmd_show_environment_entry = {
 	.name = "show-environment",
@@ -40,13 +41,13 @@ const struct cmd_entry cmd_show_environment_entry = {
 	.args = { "gst:", 0, 1 },
 	.usage = "[-gs] " CMD_TARGET_SESSION_USAGE " [name]",

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

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_environment_exec
 };

-char *
+static char *
 cmd_show_environment_escape(struct environ_entry *envent)
 {
 	const char	*value = envent->value;
@@ -64,31 +65,31 @@ cmd_show_environment_escape(struct environ_entry *envent)
 	return (ret);
 }

-void
-cmd_show_environment_print(struct cmd *self, struct cmd_q *cmdq,
+static void
+cmd_show_environment_print(struct cmd *self, struct cmdq_item *item,
    struct environ_entry *envent)
 {
 	char	*escaped;

 	if (!args_has(self->args, 's')) {
 		if (envent->value != NULL)
-			cmdq_print(cmdq, "%s=%s", envent->name, envent->value);
+			cmdq_print(item, "%s=%s", envent->name, envent->value);
 		else
-			cmdq_print(cmdq, "-%s", envent->name);
+			cmdq_print(item, "-%s", envent->name);
 		return;
 	}

 	if (envent->value != NULL) {
 		escaped = cmd_show_environment_escape(envent);
-		cmdq_print(cmdq, "%s=\"%s\"; export %s;", envent->name, escaped,
+		cmdq_print(item, "%s=\"%s\"; export %s;", envent->name, escaped,
 		    envent->name);
 		free(escaped);
 	} else
-		cmdq_print(cmdq, "unset %s;", envent->name);
+		cmdq_print(item, "unset %s;", envent->name);
 }

-enum cmd_retval
-cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_environment_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
 	struct environ		*env;
@@ -96,8 +97,8 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	const char		*target;

 	if ((target = args_get(args, 't')) != NULL) {
-		if (cmdq->state.tflag.s == NULL) {
-			cmdq_error(cmdq, "no such session: %s", target);
+		if (item->target.s == NULL) {
+			cmdq_error(item, "no such session: %s", target);
 			return (CMD_RETURN_ERROR);
 		}
 	}
@@ -105,30 +106,30 @@ cmd_show_environment_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(self->args, 'g'))
 		env = global_environ;
 	else {
-		if (cmdq->state.tflag.s == NULL) {
+		if (item->target.s == NULL) {
 			target = args_get(args, 't');
 			if (target != NULL)
-				cmdq_error(cmdq, "no such session: %s", target);
+				cmdq_error(item, "no such session: %s", target);
 			else
-				cmdq_error(cmdq, "no current session");
+				cmdq_error(item, "no current session");
 			return (CMD_RETURN_ERROR);
 		}
-		env = cmdq->state.tflag.s->environ;
+		env = item->target.s->environ;
 	}

 	if (args->argc != 0) {
 		envent = environ_find(env, args->argv[0]);
 		if (envent == NULL) {
-			cmdq_error(cmdq, "unknown variable: %s", args->argv[0]);
+			cmdq_error(item, "unknown variable: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
-		cmd_show_environment_print(self, cmdq, envent);
+		cmd_show_environment_print(self, item, envent);
 		return (CMD_RETURN_NORMAL);
 	}

 	envent = environ_first(env);
 	while (envent != NULL) {
-		cmd_show_environment_print(self, cmdq, envent);
+		cmd_show_environment_print(self, item, envent);
 		envent = environ_next(envent);
 	}
 	return (CMD_RETURN_NORMAL);
--- a/cmd-show-messages.c
+++ b/cmd-show-messages.c
@@ -28,7 +28,8 @@
 * Show client message log.
 */

-enum cmd_retval	 cmd_show_messages_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_messages_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_show_messages_entry = {
 	.name = "show-messages",
@@ -37,28 +38,15 @@ const struct cmd_entry cmd_show_messages_entry = {
 	.args = { "JTt:", 0, 0 },
 	.usage = "[-JT] " CMD_TARGET_CLIENT_USAGE,

-	.tflag = CMD_CLIENT,
-
-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_messages_exec
 };

-const struct cmd_entry cmd_server_info_entry = {
-	.name = "server-info",
-	.alias = "info",
+static int	cmd_show_messages_terminals(struct cmdq_item *, int);
+static int	cmd_show_messages_jobs(struct cmdq_item *, int);

-	.args = { "", 0, 0 },
-	.usage = "",
-
-	.flags = 0,
-	.exec = cmd_show_messages_exec
-};
-
-int	cmd_show_messages_terminals(struct cmd_q *, int);
-int	cmd_show_messages_jobs(struct cmd_q *, int);
-
-int
-cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
+static int
+cmd_show_messages_terminals(struct cmdq_item *item, int blank)
 {
 	struct tty_term	*term;
 	u_int		 i, n;
@@ -66,53 +54,56 @@ cmd_show_messages_terminals(struct cmd_q *cmdq, int blank)
 	n = 0;
 	LIST_FOREACH(term, &tty_terms, entry) {
 		if (blank) {
-			cmdq_print(cmdq, "%s", "");
+			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(cmdq, "Terminal %u: %s [references=%u, flags=0x%x]:",
+		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(cmdq, "%s", tty_term_describe(term, i));
+			cmdq_print(item, "%s", tty_term_describe(term, i));
 	}
 	return (n != 0);
 }

-int
-cmd_show_messages_jobs(struct cmd_q *cmdq, int blank)
+static int
+cmd_show_messages_jobs(struct cmdq_item *item, int blank)
 {
 	struct job	*job;
 	u_int		 n;

 	n = 0;
-	LIST_FOREACH(job, &all_jobs, lentry) {
+	LIST_FOREACH(job, &all_jobs, entry) {
 		if (blank) {
-			cmdq_print(cmdq, "%s", "");
+			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
-		cmdq_print(cmdq, "Job %u: %s [fd=%d, pid=%d, status=%d]",
-		    n, job->cmd, job->fd, job->pid, job->status);
+		cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
+		    n, job->cmd, job->fd, (long)job->pid, job->status);
 		n++;
 	}
 	return (n != 0);
 }

-enum cmd_retval
-cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_messages_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct client		*c = cmdq->state.c;
+	struct client		*c;
 	struct message_entry	*msg;
 	char			*tim;
 	int			 done, blank;

+	if ((c = cmd_find_client(item, args_get(args, 't'), 0)) == NULL)
+		return (CMD_RETURN_ERROR);
+
 	done = blank = 0;
-	if (args_has(args, 'T') || self->entry == &cmd_server_info_entry) {
-		blank = cmd_show_messages_terminals(cmdq, blank);
+	if (args_has(args, 'T')) {
+		blank = cmd_show_messages_terminals(item, blank);
 		done = 1;
 	}
-	if (args_has(args, 'J') || self->entry == &cmd_server_info_entry) {
-		cmd_show_messages_jobs(cmdq, blank);
+	if (args_has(args, 'J')) {
+		cmd_show_messages_jobs(item, blank);
 		done = 1;
 	}
 	if (done)
@@ -122,7 +113,7 @@ cmd_show_messages_exec(struct cmd *self, struct cmd_q *cmdq)
 		tim = ctime(&msg->msg_time);
 		*strchr(tim, '\n') = '\0';

-		cmdq_print(cmdq, "%s %s", tim, msg->msg);
+		cmdq_print(item, "%s %s", tim, msg->msg);
 	}

 	return (CMD_RETURN_NORMAL);
--- a/cmd-show-options.c
+++ b/cmd-show-options.c
@@ -27,12 +27,12 @@
 * Show options.
 */

-enum cmd_retval	 cmd_show_options_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_show_options_exec(struct cmd *, struct cmdq_item *);

-enum cmd_retval	cmd_show_options_one(struct cmd *, struct cmd_q *,
-		    struct options *, int);
-enum cmd_retval cmd_show_options_all(struct cmd *, struct cmd_q *,
-	    	    struct options *, enum options_table_scope);
+static enum cmd_retval	cmd_show_options_one(struct cmd *, struct cmdq_item *,
+			    struct options *);
+static enum cmd_retval	cmd_show_options_all(struct cmd *, struct cmdq_item *,
+		    	    struct options *);

 const struct cmd_entry cmd_show_options_entry = {
 	.name = "show-options",
@@ -41,9 +41,9 @@ const struct cmd_entry cmd_show_options_entry = {
 	.args = { "gqst:vw", 0, 1 },
 	.usage = "[-gqsvw] [-t target-session|target-window] [option]",

-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
 };

@@ -54,144 +54,137 @@ const struct cmd_entry cmd_show_window_options_entry = {
 	.args = { "gvt:", 0, 1 },
 	.usage = "[-gv] " CMD_TARGET_WINDOW_USAGE " [option]",

-	.tflag = CMD_WINDOW_CANFAIL,
+	.target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_show_options_exec
 };

-enum cmd_retval
-cmd_show_options_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args			*args = self->args;
-	struct session			*s = cmdq->state.tflag.s;
-	struct winlink			*wl = cmdq->state.tflag.wl;
+	struct cmd_find_state		*fs = &item->target;
 	struct options			*oo;
 	enum options_table_scope	 scope;
-	int				 quiet;
-	const char			*target;
+	char				*cause;
+	int				 window;

-	if (args_has(self->args, 's')) {
-		oo = global_options;
-		scope = OPTIONS_TABLE_SERVER;
-	} else if (args_has(self->args, 'w') ||
-	    self->entry == &cmd_show_window_options_entry) {
-		scope = OPTIONS_TABLE_WINDOW;
-		if (args_has(self->args, 'g'))
-			oo = global_w_options;
-		else if (wl == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL) {
-				cmdq_error(cmdq, "no such window: %s", target);
-			} else
-				cmdq_error(cmdq, "no current window");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = wl->window->options;
-	} else {
-		scope = OPTIONS_TABLE_SESSION;
-		if (args_has(self->args, 'g'))
-			oo = global_s_options;
-		else if (s == NULL) {
-			target = args_get(args, 't');
-			if (target != NULL) {
-				cmdq_error(cmdq, "no such session: %s", target);
-			} else
-				cmdq_error(cmdq, "no current session");
-			return (CMD_RETURN_ERROR);
-		} else
-			oo = s->options;
+	window = (self->entry == &cmd_show_window_options_entry);
+	scope = options_scope_from_flags(args, window, fs, &oo, &cause);
+	if (scope == OPTIONS_TABLE_NONE) {
+		cmdq_error(item, "%s", cause);
+		free(cause);
+		return (CMD_RETURN_ERROR);
 	}

-	quiet = args_has(self->args, 'q');
 	if (args->argc == 0)
-		return (cmd_show_options_all(self, cmdq, oo, scope));
+		return (cmd_show_options_all(self, item, oo));
 	else
-		return (cmd_show_options_one(self, cmdq, oo, quiet));
+		return (cmd_show_options_one(self, item, oo));
 }

-enum cmd_retval
-cmd_show_options_one(struct cmd *self, struct cmd_q *cmdq,
-    struct options *oo, int quiet)
+static void
+cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
+    struct options_entry *o, int idx)
 {
-	struct args				*args = self->args;
-	const char				*name = args->argv[0];
-	const struct options_table_entry	*oe;
-	struct options_entry			*o;
-	const char				*optval;
+	const char	*name;
+	const char	*value;
+	char		*tmp, *escaped;
+	u_int		 size, i;

-retry:
-	if (*name == '@') {
-		if ((o = options_find1(oo, name)) == NULL) {
-			if (quiet)
-				return (CMD_RETURN_NORMAL);
-			cmdq_error(cmdq, "unknown option: %s", name);
+	if (idx != -1) {
+		xasprintf(&tmp, "%s[%d]", options_name(o), idx);
+		name = tmp;
+	} else {
+		if (options_array_size(o, &size) != -1) {
+			for (i = 0; i < size; i++) {
+				if (options_array_get(o, i) == NULL)
+					continue;
+				cmd_show_options_print(self, item, o, i);
+			}
+			return;
+		}
+		tmp = NULL;
+		name = options_name(o);
+	}
+
+	value = options_tostring(o, idx, 0);
+	if (args_has(self->args, 'v'))
+		cmdq_print(item, "%s", value);
+	else if (options_isstring(o)) {
+		utf8_stravis(&escaped, value, VIS_OCTAL|VIS_TAB|VIS_NL|VIS_DQ);
+		cmdq_print(item, "%s \"%s\"", name, escaped);
+		free(escaped);
+	} else
+		cmdq_print(item, "%s %s", name, value);
+
+	free(tmp);
+}
+
+static enum cmd_retval
+cmd_show_options_one(struct cmd *self, struct cmdq_item *item,
+    struct options *oo)
+{
+	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 options_entry	*o;
+	int			 idx, ambiguous;
+	char			*name;
+
+	name = format_single(item, args->argv[0], c, s, wl, NULL);
+	o = options_match_get(oo, name, &idx, 1, &ambiguous);
+	if (o == NULL) {
+		if (args_has(args, 'q')) {
+			free(name);
+			return (CMD_RETURN_NORMAL);
+		}
+		if (ambiguous) {
+			cmdq_error(item, "ambiguous option: %s", name);
+			free(name);
 			return (CMD_RETURN_ERROR);
 		}
-		if (args_has(self->args, 'v'))
-			cmdq_print(cmdq, "%s", o->str);
-		else
-			cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
-		return (CMD_RETURN_NORMAL);
-	}
-
-	oe = NULL;
-	if (options_table_find(name, &oe) != 0) {
-		cmdq_error(cmdq, "ambiguous option: %s", name);
-		return (CMD_RETURN_ERROR);
-	}
-	if (oe == NULL) {
-		if (quiet)
+		if (*name != '@' &&
+		    options_match_get(oo, name, &idx, 0, &ambiguous) != NULL) {
+			free(name);
 			return (CMD_RETURN_NORMAL);
-		cmdq_error(cmdq, "unknown option: %s", name);
+		}
+		cmdq_error(item, "unknown option: %s", name);
+		free(name);
 		return (CMD_RETURN_ERROR);
 	}
-	if (oe->style != NULL) {
-		name = oe->style;
-		goto retry;
-	}
-	if ((o = options_find1(oo, oe->name)) == NULL)
-		return (CMD_RETURN_NORMAL);
-	optval = options_table_print_entry(oe, o, args_has(self->args, 'v'));
-	if (args_has(self->args, 'v'))
-		cmdq_print(cmdq, "%s", optval);
-	else
-		cmdq_print(cmdq, "%s %s", oe->name, optval);
+	cmd_show_options_print(self, item, o, idx);
+	free(name);
 	return (CMD_RETURN_NORMAL);
 }

-enum cmd_retval
-cmd_show_options_all(struct cmd *self, struct cmd_q *cmdq, struct options *oo,
-    enum options_table_scope scope)
+static enum cmd_retval
+cmd_show_options_all(struct cmd *self, struct cmdq_item *item,
+    struct options *oo)
 {
+	struct options_entry			 *o;
 	const struct options_table_entry	*oe;
-	struct options_entry			*o;
-	const char				*optval;
-	int					 vflag;
+	u_int					 size, idx;

 	o = options_first(oo);
 	while (o != NULL) {
-		if (*o->name == '@') {
-			if (args_has(self->args, 'v'))
-				cmdq_print(cmdq, "%s", o->str);
-			else
-				cmdq_print(cmdq, "%s \"%s\"", o->name, o->str);
+		oe = options_table_entry(o);
+		if (oe != NULL && oe->style != NULL) {
+			o = options_next(o);
+			continue;
+		}
+		if (options_array_size(o, &size) == -1)
+			cmd_show_options_print(self, item, o, -1);
+		else {
+			for (idx = 0; idx < size; idx++) {
+				if (options_array_get(o, idx) == NULL)
+					continue;
+				cmd_show_options_print(self, item, o, idx);
+			}
 		}
 		o = options_next(o);
 	}
-
-	vflag = args_has(self->args, 'v');
-	for (oe = options_table; oe->name != NULL; oe++) {
-		if (oe->style != NULL || oe->scope != scope)
-			continue;
-		if ((o = options_find1(oo, oe->name)) == NULL)
-			continue;
-		optval = options_table_print_entry(oe, o, vflag);
-		if (vflag)
-			cmdq_print(cmdq, "%s", optval);
-		else
-			cmdq_print(cmdq, "%s %s", oe->name, optval);
-	}
-
 	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-source-file.c
+++ b/cmd-source-file.c
@@ -18,7 +18,10 @@

 #include <sys/types.h>

+#include <errno.h>
+#include <glob.h>
 #include <stdlib.h>
+#include <string.h>

 #include "tmux.h"

@@ -26,73 +29,70 @@
 * Sources a configuration file.
 */

-enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_source_file_exec(struct cmd *, struct cmdq_item *);

-void		cmd_source_file_done(struct cmd_q *);
+static enum cmd_retval	cmd_source_file_done(struct cmdq_item *, void *);

 const struct cmd_entry cmd_source_file_entry = {
 	.name = "source-file",
 	.alias = "source",

-	.args = { "", 1, 1 },
-	.usage = "path",
+	.args = { "q", 1, 1 },
+	.usage = "[-q] path",

 	.flags = 0,
 	.exec = cmd_source_file_exec
 };

-enum cmd_retval
-cmd_source_file_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_source_file_exec(struct cmd *self, struct cmdq_item *item)
 {
-	struct args	*args = self->args;
-	struct cmd_q	*cmdq1;
-	char		*cause;
+	struct args		*args = self->args;
+	int			 quiet = args_has(args, 'q');
+	struct client		*c = item->client;
+	struct cmdq_item	*new_item;
+	enum cmd_retval		 retval;
+	char			*pattern, *tmp;
+	const char		*path = args->argv[0];
+	glob_t			 g;
+	u_int			 i;

-	cmdq1 = cmdq_new(cmdq->client);
-	cmdq1->emptyfn = cmd_source_file_done;
-	cmdq1->data = cmdq;
+	if (*path == '/')
+		pattern = xstrdup(path);
+	else {
+		utf8_stravis(&tmp, server_client_get_cwd(c), VIS_GLOB);
+		xasprintf(&pattern, "%s/%s", tmp, path);
+		free(tmp);
+	}
+	log_debug("%s: %s", __func__, pattern);

-	switch (load_cfg(args->argv[0], cmdq1, &cause)) {
-	case -1:
-		if (cfg_references == 0) {
-			cmdq_free(cmdq1);
-			cmdq_error(cmdq, "%s", cause);
-			free(cause);
-			return (CMD_RETURN_ERROR);
+	retval = CMD_RETURN_NORMAL;
+	if (glob(pattern, 0, NULL, &g) != 0) {
+		if (!quiet || errno != ENOENT) {
+			cmdq_error(item, "%s: %s", path, strerror(errno));
+			retval = CMD_RETURN_ERROR;
 		}
-		cfg_add_cause("%s", cause);
-		free(cause);
-		/* FALLTHROUGH */
-	case 0:
-		if (cfg_references == 0)
-			cfg_print_causes(cmdq);
-		cmdq_free(cmdq1);
-		return (CMD_RETURN_NORMAL);
+		free(pattern);
+		return (retval);
+	}
+	free(pattern);
+
+	for (i = 0; i < (u_int)g.gl_pathc; i++) {
+		if (load_cfg(g.gl_pathv[i], c, item, quiet) < 0)
+			retval = CMD_RETURN_ERROR;
+	}
+	if (cfg_finished) {
+		new_item = cmdq_get_callback(cmd_source_file_done, NULL);
+		cmdq_insert_after(item, new_item);
 	}

-	cmdq->references++;
-	cfg_references++;
-
-	cmdq_continue(cmdq1);
-	return (CMD_RETURN_WAIT);
+	globfree(&g);
+	return (retval);
 }

-void
-cmd_source_file_done(struct cmd_q *cmdq1)
+static enum cmd_retval
+cmd_source_file_done(struct cmdq_item *item, __unused void *data)
 {
-	struct cmd_q	*cmdq = cmdq1->data;
-
-	if (cmdq1->client_exit >= 0)
-		cmdq->client_exit = cmdq1->client_exit;
-
-	cmdq_free(cmdq1);
-
-	cfg_references--;
-
-	if (cmdq_free(cmdq))
-		return;
-
-	if (cfg_references == 0)
-		cfg_print_causes(cmdq);
-	cmdq_continue(cmdq);
+	cfg_print_causes(item);
+	return (CMD_RETURN_NORMAL);
 }
--- a/cmd-split-window.c
+++ b/cmd-split-window.c
@@ -32,47 +32,45 @@

 #define SPLIT_WINDOW_TEMPLATE "#{session_name}:#{window_index}.#{pane_index}"

-enum cmd_retval	 cmd_split_window_exec(struct cmd *, struct cmd_q *);
+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 = { "bc:dF:l:hp:Pt:v", 0, -1 },
-	.usage = "[-bdhvP] [-c start-directory] [-F format] "
+	.args = { "bc:dfF:l:hp:Pt:v", 0, -1 },
+	.usage = "[-bdfhvP] [-c start-directory] [-F format] "
 		 "[-p percentage|-l size] " CMD_TARGET_PANE_USAGE " [command]",

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

 	.flags = 0,
 	.exec = cmd_split_window_exec
 };

-enum cmd_retval
-cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_split_window_exec(struct cmd *self, struct cmdq_item *item)
 {
+	struct cmd_find_state	*current = &item->shared->current;
 	struct args		*args = self->args;
-	struct session		*s = cmdq->state.tflag.s;
-	struct winlink		*wl = cmdq->state.tflag.wl;
+	struct client		*c = cmd_find_client(item, NULL, 1);
+	struct session		*s = item->target.s;
+	struct winlink		*wl = item->target.wl;
 	struct window		*w = wl->window;
-	struct window_pane	*wp = cmdq->state.tflag.wp, *new_wp = NULL;
+	struct window_pane	*wp = item->target.wp, *new_wp = NULL;
 	struct environ		*env;
-	const char		*cmd, *path, *shell, *template, *cwd, *to_free;
-	char		       **argv, *cause, *new_cause, *cp;
+	const char		*cmd, *path, *shell, *template, *cwd;
+	char		       **argv, *cause, *new_cause, *cp, *to_free = NULL;
 	u_int			 hlimit;
 	int			 argc, size, percentage;
 	enum layout_type	 type;
 	struct layout_cell	*lc;
-	struct format_tree	*ft;
 	struct environ_entry	*envent;
+	struct cmd_find_state    fs;

 	server_unzoom_window(w);

-	env = environ_create();
-	environ_copy(global_environ, env);
-	environ_copy(s->environ, env);
-	server_fill_environ(s, env);
-
 	if (args->argc == 0) {
 		cmd = options_get_string(s->options, "default-command");
 		if (cmd != NULL && *cmd != '\0') {
@@ -87,14 +85,12 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 		argv = args->argv;
 	}

-	to_free = NULL;
 	if (args_has(args, 'c')) {
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, s, NULL, NULL);
-		to_free = cwd = format_expand(ft, args_get(args, 'c'));
-		format_free(ft);
-	} else if (cmdq->client != NULL && cmdq->client->session == NULL)
-		cwd = cmdq->client->cwd;
+		cwd = args_get(args, 'c');
+		to_free = format_single(item, cwd, c, s, NULL, NULL);
+		cwd = to_free;
+	} else if (item->client != NULL && item->client->session == NULL)
+		cwd = item->client->cwd;
 	else
 		cwd = s->cwd;

@@ -130,66 +126,65 @@ cmd_split_window_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (*shell == '\0' || areshell(shell))
 		shell = _PATH_BSHELL;

-	lc = layout_split_pane(wp, type, size, args_has(args, 'b'));
+	lc = layout_split_pane(wp, type, size, args_has(args, 'b'),
+	    args_has(args, 'f'));
 	if (lc == NULL) {
 		cause = xstrdup("pane too small");
 		goto error;
 	}
-	new_wp = window_add_pane(w, hlimit);
-	layout_assign_pane(lc, new_wp);
+	new_wp = window_add_pane(w, wp, args_has(args, 'b'), hlimit);
+	layout_make_leaf(lc, new_wp);

 	path = NULL;
-	if (cmdq->client != NULL && cmdq->client->session == NULL)
-		envent = environ_find(cmdq->client->environ, "PATH");
+	if (item->client != NULL && item->client->session == NULL)
+		envent = environ_find(item->client->environ, "PATH");
 	else
 		envent = environ_find(s->environ, "PATH");
 	if (envent != NULL)
 		path = envent->value;

+	env = environ_for_session(s, 0);
 	if (window_pane_spawn(new_wp, argc, argv, path, shell, cwd, env,
-	    s->tio, &cause) != 0)
+	    s->tio, &cause) != 0) {
+		environ_free(env);
 		goto error;
+	}
+	environ_free(env);

+	layout_fix_panes(w, w->sx, w->sy);
 	server_redraw_window(w);

 	if (!args_has(args, 'd')) {
 		window_set_active_pane(w, new_wp);
 		session_select(s, wl->idx);
+		cmd_find_from_session(current, s, 0);
 		server_redraw_session(s);
 	} else
 		server_status_session(s);

-	environ_free(env);
-
 	if (args_has(args, 'P')) {
 		if ((template = args_get(args, 'F')) == NULL)
 			template = SPLIT_WINDOW_TEMPLATE;
-
-		ft = format_create(cmdq, 0);
-		format_defaults(ft, cmdq->state.c, s, wl, new_wp);
-
-		cp = format_expand(ft, template);
-		cmdq_print(cmdq, "%s", cp);
+		cp = format_single(item, template, c, s, wl, new_wp);
+		cmdq_print(item, "%s", cp);
 		free(cp);
-
-		format_free(ft);
 	}
-	notify_window_layout_changed(w);
+	notify_window("window-layout-changed", w);

-	if (to_free != NULL)
-		free((void *)to_free);
+	cmd_find_from_winlink_pane(&fs, wl, new_wp, 0);
+	hooks_insert(s->hooks, item, &fs, "after-split-window");
+
+	free(to_free);
 	return (CMD_RETURN_NORMAL);

 error:
-	environ_free(env);
 	if (new_wp != NULL) {
 		layout_close_pane(new_wp);
 		window_remove_pane(w, new_wp);
 	}
-	cmdq_error(cmdq, "create pane failed: %s", cause);
+	cmdq_error(item, "create pane failed: %s", cause);
 	free(cause);

-	if (to_free != NULL)
-		free((void *)to_free);
+	free(to_free);
 	return (CMD_RETURN_ERROR);
 }
--- a/cmd-string.c
+++ b/cmd-string.c
@@ -31,14 +31,14 @@
 * Parse a command from a string.
 */

-int	 cmd_string_getc(const char *, size_t *);
-void	 cmd_string_ungetc(size_t *);
-void	 cmd_string_copy(char **, char *, size_t *);
-char	*cmd_string_string(const char *, size_t *, char, int);
-char	*cmd_string_variable(const char *, size_t *);
-char	*cmd_string_expand_tilde(const char *, size_t *);
+static int	 cmd_string_getc(const char *, size_t *);
+static void	 cmd_string_ungetc(size_t *);
+static void	 cmd_string_copy(char **, char *, size_t *);
+static char	*cmd_string_string(const char *, size_t *, char, int);
+static char	*cmd_string_variable(const char *, size_t *);
+static char	*cmd_string_expand_tilde(const char *, size_t *);

-int
+static int
 cmd_string_getc(const char *s, size_t *p)
 {
 	const u_char	*ucs = s;
@@ -48,38 +48,21 @@ cmd_string_getc(const char *s, size_t *p)
 	return (ucs[(*p)++]);
 }

-void
+static void
 cmd_string_ungetc(size_t *p)
 {
 	(*p)--;
 }

-/*
- * Parse command string. Returns -1 on error. If returning -1, cause is error
- * string, or NULL for empty command.
- */
 int
-cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
-    u_int line, char **cause)
+cmd_string_split(const char *s, int *rargc, char ***rargv)
 {
-	size_t		p;
-	int		ch, i, argc, rval;
-	char	      **argv, *buf, *t;
+	size_t		p = 0;
+	int		ch, argc = 0, append = 0;
+	char	      **argv = NULL, *buf = NULL, *t;
 	const char     *whitespace, *equals;
-	size_t		len;
+	size_t		len = 0;

-	argv = NULL;
-	argc = 0;
-
-	buf = NULL;
-	len = 0;
-
-	*cause = NULL;
-
-	*cmdlist = NULL;
-	rval = -1;
-
-	p = 0;
 	for (;;) {
 		ch = cmd_string_getc(s, &p);
 		switch (ch) {
@@ -130,50 +113,68 @@ cmd_string_parse(const char *s, struct cmd_list **cmdlist, const char *file,
 				argc--;
 				memmove(argv, argv + 1, argc * (sizeof *argv));
 			}
-			if (argc == 0)
-				goto out;
-
-			*cmdlist = cmd_list_parse(argc, argv, file, line, cause);
-			if (*cmdlist == NULL)
-				goto out;
-
-			rval = 0;
-			goto out;
+			goto done;
 		case '~':
-			if (buf == NULL) {
-				t = cmd_string_expand_tilde(s, &p);
-				if (t == NULL)
-					goto error;
-				cmd_string_copy(&buf, t, &len);
+			if (buf != NULL) {
+				append = 1;
 				break;
 			}
-			/* FALLTHROUGH */
-		default:
-			if (len >= SIZE_MAX - 2)
+			t = cmd_string_expand_tilde(s, &p);
+			if (t == NULL)
 				goto error;
-
-			buf = xrealloc(buf, len + 1);
-			buf[len++] = ch;
+			cmd_string_copy(&buf, t, &len);
+			break;
+		default:
+			append = 1;
 			break;
 		}
+		if (append) {
+			if (len >= SIZE_MAX - 2)
+				goto error;
+			buf = xrealloc(buf, len + 1);
+			buf[len++] = ch;
+		}
+		append = 0;
 	}

+done:
+	*rargc = argc;
+	*rargv = argv;
+
+	free(buf);
+	return (0);
+
 error:
-	xasprintf(cause, "invalid or unknown command: %s", s);
-
-out:
+	if (argv != NULL)
+		cmd_free_argv(argc, argv);
 	free(buf);
-
-	if (argv != NULL) {
-		for (i = 0; i < argc; i++)
-			free(argv[i]);
-		free(argv);
-	}
-
-	return (rval);
+	return (-1);
 }

-void
+struct cmd_list *
+cmd_string_parse(const char *s, const char *file, u_int line, char **cause)
+{
+	struct cmd_list	 *cmdlist = NULL;
+	int		  argc;
+	char		**argv;
+
+	*cause = NULL;
+	if (cmd_string_split(s, &argc, &argv) != 0) {
+		xasprintf(cause, "invalid or unknown command: %s", s);
+		return (NULL);
+	}
+	if (argc != 0) {
+		cmdlist = cmd_list_parse(argc, argv, file, line, cause);
+		if (cmdlist == NULL) {
+			cmd_free_argv(argc, argv);
+			return (NULL);
+		}
+	}
+	cmd_free_argv(argc, argv);
+	return (cmdlist);
+}
+
+static void
 cmd_string_copy(char **dst, char *src, size_t *len)
 {
 	size_t srclen;
@@ -187,7 +188,7 @@ cmd_string_copy(char **dst, char *src, size_t *len)
 	free(src);
 }

-char *
+static char *
 cmd_string_string(const char *s, size_t *p, char endch, int esc)
 {
 	int	ch;
@@ -245,7 +246,7 @@ error:
 	return (NULL);
 }

-char *
+static char *
 cmd_string_variable(const char *s, size_t *p)
 {
 	int			ch, fch;
@@ -314,7 +315,7 @@ error:
 	return (NULL);
 }

-char *
+static char *
 cmd_string_expand_tilde(const char *s, size_t *p)
 {
 	struct passwd		*pw;
@@ -337,7 +338,10 @@ cmd_string_expand_tilde(const char *s, size_t *p)
 		cp = user = xmalloc(strlen(s));
 		for (;;) {
 			last = cmd_string_getc(s, p);
-			if (last == EOF || last == '/' || last == ' '|| last == '\t')
+			if (last == EOF ||
+			    last == '/' ||
+			    last == ' '||
+			    last == '\t')
 				break;
 			*cp++ = last;
 		}
--- a/cmd-swap-pane.c
+++ b/cmd-swap-pane.c
@@ -26,7 +26,7 @@
 * Swap two panes.
 */

-enum cmd_retval	 cmd_swap_pane_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_swap_pane_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_swap_pane_entry = {
 	.name = "swap-pane",
@@ -35,25 +35,25 @@ const struct cmd_entry cmd_swap_pane_entry = {
 	.args = { "dDs:t:U", 0, 0 },
 	.usage = "[-dDU] " CMD_SRCDST_PANE_USAGE,

-	.sflag = CMD_PANE_MARKED,
-	.tflag = CMD_PANE,
+	.source = { 's', CMD_FIND_PANE, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_PANE, 0 },

 	.flags = 0,
 	.exec = cmd_swap_pane_exec
 };

-enum cmd_retval
-cmd_swap_pane_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_swap_pane_exec(struct cmd *self, struct cmdq_item *item)
 {
 	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;

-	dst_w = cmdq->state.tflag.wl->window;
-	dst_wp = cmdq->state.tflag.wp;
-	src_w = cmdq->state.sflag.wl->window;
-	src_wp = cmdq->state.sflag.wp;
+	dst_w = item->target.wl->window;
+	dst_wp = item->target.wp;
+	src_w = item->source.wl->window;
+	src_wp = item->source.wp;
 	server_unzoom_window(dst_w);

 	if (args_has(self->args, 'D')) {
--- a/cmd-swap-window.c
+++ b/cmd-swap-window.c
@@ -26,7 +26,7 @@
 * Swap one window with another.
 */

-enum cmd_retval	cmd_swap_window_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_swap_window_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_swap_window_entry = {
 	.name = "swap-window",
@@ -35,41 +35,47 @@ const struct cmd_entry cmd_swap_window_entry = {
 	.args = { "ds:t:", 0, 0 },
 	.usage = "[-d] " CMD_SRCDST_WINDOW_USAGE,

-	.sflag = CMD_WINDOW_MARKED,
-	.tflag = CMD_WINDOW,
+	.source = { 's', CMD_FIND_WINDOW, CMD_FIND_DEFAULT_MARKED },
+	.target = { 't', CMD_FIND_WINDOW, 0 },

 	.flags = 0,
 	.exec = cmd_swap_window_exec
 };

-enum cmd_retval
-cmd_swap_window_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_swap_window_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct session		*src, *dst;
 	struct session_group	*sg_src, *sg_dst;
 	struct winlink		*wl_src, *wl_dst;
-	struct window		*w;
+	struct window		*w_src, *w_dst;

-	wl_src = cmdq->state.sflag.wl;
-	src = cmdq->state.sflag.s;
-	sg_src = session_group_find(src);
+	wl_src = item->source.wl;
+	src = item->source.s;
+	sg_src = session_group_contains(src);

-	wl_dst = cmdq->state.tflag.wl;
-	dst = cmdq->state.tflag.s;
-	sg_dst = session_group_find(dst);
+	wl_dst = item->target.wl;
+	dst = item->target.s;
+	sg_dst = session_group_contains(dst);

 	if (src != dst && sg_src != NULL && sg_dst != NULL &&
 	    sg_src == sg_dst) {
-		cmdq_error(cmdq, "can't move window, sessions are grouped");
+		cmdq_error(item, "can't move window, sessions are grouped");
 		return (CMD_RETURN_ERROR);
 	}

 	if (wl_dst->window == wl_src->window)
 		return (CMD_RETURN_NORMAL);

-	w = wl_dst->window;
-	wl_dst->window = wl_src->window;
-	wl_src->window = w;
+	w_dst = wl_dst->window;
+	TAILQ_REMOVE(&w_dst->winlinks, wl_dst, wentry);
+	w_src = wl_src->window;
+	TAILQ_REMOVE(&w_src->winlinks, wl_src, wentry);
+
+	wl_dst->window = w_src;
+	TAILQ_INSERT_TAIL(&w_src->winlinks, wl_dst, wentry);
+	wl_src->window = w_dst;
+	TAILQ_INSERT_TAIL(&w_dst->winlinks, wl_src, wentry);

 	if (!args_has(self->args, 'd')) {
 		session_select(dst, wl_dst->idx);
--- a/cmd-switch-client.c
+++ b/cmd-switch-client.c
@@ -27,7 +27,8 @@
 * Switch client to a different session.
 */

-enum cmd_retval	 cmd_switch_client_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval	cmd_switch_client_exec(struct cmd *,
+			    struct cmdq_item *);

 const struct cmd_entry cmd_switch_client_entry = {
 	.name = "switch-client",
@@ -37,24 +38,42 @@ const struct cmd_entry cmd_switch_client_entry = {
 	.usage = "[-Elnpr] [-c target-client] [-t target-session] "
 		 "[-T key-table]",

-	.cflag = CMD_CLIENT,
-	.tflag = CMD_SESSION_WITHPANE,
+	/* -t is special */

 	.flags = CMD_READONLY,
 	.exec = cmd_switch_client_exec
 };

-enum cmd_retval
-cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_switch_client_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args		*args = self->args;
-	struct cmd_state	*state = &cmdq->state;
-	struct client		*c = state->c;
-	struct session		*s = cmdq->state.tflag.s;
+	const char		*tflag = args_get(args, 't');
+	enum cmd_find_type	 type;
+	int			 flags;
+	struct client		*c;
+	struct session		*s;
+	struct winlink		*wl;
 	struct window_pane	*wp;
-	const char		*tablename, *update;
+	const char		*tablename;
 	struct key_table	*table;

+	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(&item->target, item, tflag, type, flags) != 0)
+		return (CMD_RETURN_ERROR);
+	s = item->target.s;
+	wl = item->target.wl;
+	wp = item->target.wp;
+
 	if (args_has(args, 'r'))
 		c->flags ^= CLIENT_READONLY;

@@ -62,7 +81,7 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (tablename != NULL) {
 		table = key_bindings_get_table(tablename, 0);
 		if (table == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 		table->references++;
@@ -73,12 +92,12 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)

 	if (args_has(args, 'n')) {
 		if ((s = session_next_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find next session");
+			cmdq_error(item, "can't find next session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'p')) {
 		if ((s = session_previous_session(c->session)) == NULL) {
-			cmdq_error(cmdq, "can't find previous session");
+			cmdq_error(item, "can't find previous session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else if (args_has(args, 'l')) {
@@ -87,30 +106,30 @@ cmd_switch_client_exec(struct cmd *self, struct cmd_q *cmdq)
 		else
 			s = NULL;
 		if (s == NULL) {
-			cmdq_error(cmdq, "can't find last session");
+			cmdq_error(item, "can't find last session");
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
-		if (cmdq->client == NULL)
+		if (item->client == NULL)
 			return (CMD_RETURN_NORMAL);
-		if (state->tflag.wl != NULL) {
-			wp = state->tflag.wp;
+		if (wl != NULL) {
 			if (wp != NULL)
 				window_set_active_pane(wp->window, wp);
-			session_set_current(s, state->tflag.wl);
+			session_set_current(s, wl);
+			cmd_find_from_session(&item->shared->current, s, 0);
 		}
 	}

-	if (c != NULL && !args_has(args, 'E')) {
-		update = options_get_string(s->options, "update-environment");
-		environ_update(update, c->environ, s->environ);
-	}
+	if (!args_has(args, 'E'))
+		environ_update(s->options, c->environ, s->environ);

 	if (c->session != NULL && c->session != s)
 		c->last_session = c->session;
 	c->session = s;
-	server_client_set_key_table(c, NULL);
+	if (~item->shared->flags & CMDQ_SHARED_REPEAT)
+		server_client_set_key_table(c, NULL);
 	status_timer_start(c);
+	notify_client("client-session-changed", c);
 	session_update_activity(s, NULL);
 	gettimeofday(&s->last_attached_time, NULL);

--- a/cmd-unbind-key.c
+++ b/cmd-unbind-key.c
@@ -26,23 +26,21 @@
 * Unbind key from command.
 */

-enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmd_q *);
-enum cmd_retval	cmd_unbind_key_mode_table(struct cmd *, struct cmd_q *,
-		    key_code);
+static enum cmd_retval	cmd_unbind_key_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_unbind_key_entry = {
 	.name = "unbind-key",
 	.alias = "unbind",

-	.args = { "acnt:T:", 0, 1 },
-	.usage = "[-acn] [-t mode-table] [-T key-table] key",
+	.args = { "anT:", 0, 1 },
+	.usage = "[-an] [-T key-table] key",

-	.flags = 0,
+	.flags = CMD_AFTERHOOK,
 	.exec = cmd_unbind_key_exec
 };

-enum cmd_retval
-cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_unbind_key_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args	*args = self->args;
 	key_code	 key;
@@ -50,25 +48,22 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)

 	if (!args_has(args, 'a')) {
 		if (args->argc != 1) {
-			cmdq_error(cmdq, "missing key");
+			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(cmdq, "unknown key: %s", args->argv[0]);
+			cmdq_error(item, "unknown key: %s", args->argv[0]);
 			return (CMD_RETURN_ERROR);
 		}
 	} else {
 		if (args->argc != 0) {
-			cmdq_error(cmdq, "key given with -a");
+			cmdq_error(item, "key given with -a");
 			return (CMD_RETURN_ERROR);
 		}
 		key = KEYC_UNKNOWN;
 	}

-	if (args_has(args, 't'))
-		return (cmd_unbind_key_mode_table(self, cmdq, key));
-
 	if (key == KEYC_UNKNOWN) {
 		tablename = args_get(args, 'T');
 		if (tablename == NULL) {
@@ -77,7 +72,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 			return (CMD_RETURN_NORMAL);
 		}
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "table %s doesn't exist", tablename);
+			cmdq_error(item, "table %s doesn't exist", tablename);
 			return (CMD_RETURN_ERROR);
 		}
 		key_bindings_remove_table(tablename);
@@ -87,7 +82,7 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	if (args_has(args, 'T')) {
 		tablename = args_get(args, 'T');
 		if (key_bindings_get_table(tablename, 0) == NULL) {
-			cmdq_error(cmdq, "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'))
@@ -97,35 +92,3 @@ cmd_unbind_key_exec(struct cmd *self, struct cmd_q *cmdq)
 	key_bindings_remove(tablename, key);
 	return (CMD_RETURN_NORMAL);
 }
-
-enum cmd_retval
-cmd_unbind_key_mode_table(struct cmd *self, struct cmd_q *cmdq, key_code key)
-{
-	struct args			*args = self->args;
-	const char			*tablename;
-	const struct mode_key_table	*mtab;
-	struct mode_key_binding		*mbind, mtmp;
-
-	tablename = args_get(args, 't');
-	if ((mtab = mode_key_findtable(tablename)) == NULL) {
-		cmdq_error(cmdq, "unknown key table: %s", tablename);
-		return (CMD_RETURN_ERROR);
-	}
-
-	if (key == KEYC_UNKNOWN) {
-		while (!RB_EMPTY(mtab->tree)) {
-			mbind = RB_ROOT(mtab->tree);
-			RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-			free(mbind);
-		}
-		return (CMD_RETURN_NORMAL);
-	}
-
-	mtmp.key = key;
-	mtmp.mode = !!args_has(args, 'c');
-	if ((mbind = RB_FIND(mode_key_tree, mtab->tree, &mtmp)) != NULL) {
-		RB_REMOVE(mode_key_tree, mtab->tree, mbind);
-		free(mbind);
-	}
-	return (CMD_RETURN_NORMAL);
-}
--- a/cmd-wait-for.c
+++ b/cmd-wait-for.c
@@ -28,7 +28,7 @@
 * Block or wake a client on a named wait channel.
 */

-enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmd_q *);
+static enum cmd_retval cmd_wait_for_exec(struct cmd *, struct cmdq_item *);

 const struct cmd_entry cmd_wait_for_entry = {
 	.name = "wait-for",
@@ -41,42 +41,46 @@ const struct cmd_entry cmd_wait_for_entry = {
 	.exec = cmd_wait_for_exec
 };

+struct wait_item {
+	struct cmdq_item	*item;
+	TAILQ_ENTRY(wait_item)	 entry;
+};
+
 struct wait_channel {
 	const char	       *name;
 	int			locked;
 	int			woken;

-	TAILQ_HEAD(, cmd_q)	waiters;
-	TAILQ_HEAD(, cmd_q)	lockers;
+	TAILQ_HEAD(, wait_item)	waiters;
+	TAILQ_HEAD(, wait_item)	lockers;

 	RB_ENTRY(wait_channel)	entry;
 };
 RB_HEAD(wait_channels, wait_channel);
-struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);
+static struct wait_channels wait_channels = RB_INITIALIZER(wait_channels);

-int	wait_channel_cmp(struct wait_channel *, struct wait_channel *);
-RB_PROTOTYPE(wait_channels, wait_channel, entry, wait_channel_cmp);
-RB_GENERATE(wait_channels, wait_channel, entry, wait_channel_cmp);
+static int wait_channel_cmp(struct wait_channel *, struct wait_channel *);
+RB_GENERATE_STATIC(wait_channels, wait_channel, entry, wait_channel_cmp);

-int
+static int
 wait_channel_cmp(struct wait_channel *wc1, struct wait_channel *wc2)
 {
 	return (strcmp(wc1->name, wc2->name));
 }

-enum cmd_retval	cmd_wait_for_signal(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_wait(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_lock(struct cmd_q *, const char *,
-		    struct wait_channel *);
-enum cmd_retval	cmd_wait_for_unlock(struct cmd_q *, const char *,
-		    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_signal(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+static enum cmd_retval	cmd_wait_for_wait(struct cmdq_item *, const char *,
+			    struct wait_channel *);
+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 *);

-struct wait_channel	*cmd_wait_for_add(const char *);
-void			 cmd_wait_for_remove(struct wait_channel *wc);
+static struct wait_channel	*cmd_wait_for_add(const char *);
+static void			 cmd_wait_for_remove(struct wait_channel *);

-struct wait_channel *
+static struct wait_channel *
 cmd_wait_for_add(const char *name)
 {
 	struct wait_channel *wc;
@@ -97,7 +101,7 @@ cmd_wait_for_add(const char *name)
 	return (wc);
 }

-void
+static void
 cmd_wait_for_remove(struct wait_channel *wc)
 {
 	if (wc->locked)
@@ -113,8 +117,8 @@ cmd_wait_for_remove(struct wait_channel *wc)
 	free(wc);
 }

-enum cmd_retval
-cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
+static enum cmd_retval
+cmd_wait_for_exec(struct cmd *self, struct cmdq_item *item)
 {
 	struct args     	*args = self->args;
 	const char		*name = args->argv[0];
@@ -124,19 +128,19 @@ cmd_wait_for_exec(struct cmd *self, struct cmd_q *cmdq)
 	wc = RB_FIND(wait_channels, &wait_channels, &wc0);

 	if (args_has(args, 'S'))
-		return (cmd_wait_for_signal(cmdq, name, wc));
+		return (cmd_wait_for_signal(item, name, wc));
 	if (args_has(args, 'L'))
-		return (cmd_wait_for_lock(cmdq, name, wc));
+		return (cmd_wait_for_lock(item, name, wc));
 	if (args_has(args, 'U'))
-		return (cmd_wait_for_unlock(cmdq, name, wc));
-	return (cmd_wait_for_wait(cmdq, name, wc));
+		return (cmd_wait_for_unlock(item, name, wc));
+	return (cmd_wait_for_wait(item, name, wc));
 }

-enum cmd_retval
-cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_signal(__unused struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
 {
-	struct cmd_q	*wq, *wq1;
+	struct wait_item	*wi, *wi1;

 	if (wc == NULL)
 		wc = cmd_wait_for_add(name);
@@ -148,24 +152,26 @@ cmd_wait_for_signal(__unused struct cmd_q *cmdq, const char *name,
 	}
 	log_debug("signal wait channel %s, with waiters", wc->name);

-	TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
-		TAILQ_REMOVE(&wc->waiters, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
+	TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+		wi->item->flags &= ~CMDQ_WAITING;
+
+		TAILQ_REMOVE(&wc->waiters, wi, entry);
+		free(wi);
 	}

 	cmd_wait_for_remove(wc);
 	return (CMD_RETURN_NORMAL);
 }

-enum cmd_retval
-cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_wait(struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
 {
-	struct client	*c = cmdq->client;
+	struct client		*c = item->client;
+	struct wait_item	*wi;

 	if (c == NULL || c->session != NULL) {
-		cmdq_error(cmdq, "not able to wait");
+		cmdq_error(item, "not able to wait");
 		return (CMD_RETURN_ERROR);
 	}

@@ -179,18 +185,21 @@ cmd_wait_for_wait(struct cmd_q *cmdq, const char *name,
 	}
 	log_debug("wait channel %s not woken (%p)", wc->name, c);

-	TAILQ_INSERT_TAIL(&wc->waiters, cmdq, waitentry);
-	cmdq->references++;
+	wi = xcalloc(1, sizeof *wi);
+	wi->item = item;
+	TAILQ_INSERT_TAIL(&wc->waiters, wi, entry);

 	return (CMD_RETURN_WAIT);
 }

-enum cmd_retval
-cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_lock(struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
 {
-	if (cmdq->client == NULL || cmdq->client->session != NULL) {
-		cmdq_error(cmdq, "not able to lock");
+	struct wait_item	*wi;
+
+	if (item->client == NULL || item->client->session != NULL) {
+		cmdq_error(item, "not able to lock");
 		return (CMD_RETURN_ERROR);
 	}

@@ -198,8 +207,9 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
 		wc = cmd_wait_for_add(name);

 	if (wc->locked) {
-		TAILQ_INSERT_TAIL(&wc->lockers, cmdq, waitentry);
-		cmdq->references++;
+		wi = xcalloc(1, sizeof *wi);
+		wi->item = item;
+		TAILQ_INSERT_TAIL(&wc->lockers, wi, entry);
 		return (CMD_RETURN_WAIT);
 	}
 	wc->locked = 1;
@@ -207,21 +217,21 @@ cmd_wait_for_lock(struct cmd_q *cmdq, const char *name,
 	return (CMD_RETURN_NORMAL);
 }

-enum cmd_retval
-cmd_wait_for_unlock(struct cmd_q *cmdq, const char *name,
+static enum cmd_retval
+cmd_wait_for_unlock(struct cmdq_item *item, const char *name,
    struct wait_channel *wc)
 {
-	struct cmd_q	*wq;
+	struct wait_item	*wi;

 	if (wc == NULL || !wc->locked) {
-		cmdq_error(cmdq, "channel %s not locked", name);
+		cmdq_error(item, "channel %s not locked", name);
 		return (CMD_RETURN_ERROR);
 	}

-	if ((wq = TAILQ_FIRST(&wc->lockers)) != NULL) {
-		TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-		if (!cmdq_free(wq))
-			cmdq_continue(wq);
+	if ((wi = TAILQ_FIRST(&wc->lockers)) != NULL) {
+		wi->item->flags &= ~CMDQ_WAITING;
+		TAILQ_REMOVE(&wc->lockers, wi, entry);
+		free(wi);
 	} else {
 		wc->locked = 0;
 		cmd_wait_for_remove(wc);
@@ -234,19 +244,19 @@ void
 cmd_wait_for_flush(void)
 {
 	struct wait_channel	*wc, *wc1;
-	struct cmd_q		*wq, *wq1;
+	struct wait_item	*wi, *wi1;

 	RB_FOREACH_SAFE(wc, wait_channels, &wait_channels, wc1) {
-		TAILQ_FOREACH_SAFE(wq, &wc->waiters, waitentry, wq1) {
-			TAILQ_REMOVE(&wc->waiters, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
+		TAILQ_FOREACH_SAFE(wi, &wc->waiters, entry, wi1) {
+			wi->item->flags &= ~CMDQ_WAITING;
+			TAILQ_REMOVE(&wc->waiters, wi, entry);
+			free(wi);
 		}
 		wc->woken = 1;
-		TAILQ_FOREACH_SAFE(wq, &wc->lockers, waitentry, wq1) {
-			TAILQ_REMOVE(&wc->lockers, wq, waitentry);
-			if (!cmdq_free(wq))
-				cmdq_continue(wq);
+		TAILQ_FOREACH_SAFE(wi, &wc->lockers, entry, wi1) {
+			wi->item->flags &= ~CMDQ_WAITING;
+			TAILQ_REMOVE(&wc->lockers, wi, entry);
+			free(wi);
 		}
 		wc->locked = 0;
 		cmd_wait_for_remove(wc);
--- a/cmd.c
+++ b/cmd.c
@@ -33,9 +33,7 @@ extern const struct cmd_entry cmd_break_pane_entry;
 extern const struct cmd_entry cmd_capture_pane_entry;
 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_session_entry;
 extern const struct cmd_entry cmd_choose_tree_entry;
-extern const struct cmd_entry cmd_choose_window_entry;
 extern const struct cmd_entry cmd_clear_history_entry;
 extern const struct cmd_entry cmd_clock_mode_entry;
 extern const struct cmd_entry cmd_command_prompt_entry;
@@ -92,7 +90,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_info_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;
@@ -123,9 +120,7 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_capture_pane_entry,
 	&cmd_choose_buffer_entry,
 	&cmd_choose_client_entry,
-	&cmd_choose_session_entry,
 	&cmd_choose_tree_entry,
-	&cmd_choose_window_entry,
 	&cmd_clear_history_entry,
 	&cmd_clock_mode_entry,
 	&cmd_command_prompt_entry,
@@ -181,7 +176,6 @@ const struct cmd_entry *cmd_table[] = {
 	&cmd_select_window_entry,
 	&cmd_send_keys_entry,
 	&cmd_send_prefix_entry,
-	&cmd_server_info_entry,
 	&cmd_set_buffer_entry,
 	&cmd_set_environment_entry,
 	&cmd_set_hook_entry,
@@ -307,21 +301,74 @@ cmd_stringify_argv(int argc, char **argv)
 	return (buf);
 }

+static int
+cmd_try_alias(int *argc, char ***argv)
+{
+	struct options_entry	 *o;
+	int			  old_argc = *argc, new_argc;
+	char			**old_argv = *argv, **new_argv;
+	u_int			  size, idx;
+	int			  i;
+	size_t			  wanted;
+	const char		 *s, *cp = NULL;
+
+	o = options_get_only(global_options, "command-alias");
+	if (o == NULL || options_array_size(o, &size) == -1 || size == 0)
+		return (-1);
+
+	wanted = strlen(old_argv[0]);
+	for (idx = 0; idx < size; idx++) {
+		s = options_array_get(o, idx);
+		if (s == NULL)
+			continue;
+
+		cp = strchr(s, '=');
+		if (cp == NULL || (size_t)(cp - s) != wanted)
+			continue;
+		if (strncmp(old_argv[0], s, wanted) == 0)
+			break;
+	}
+	if (idx == size)
+		return (-1);
+
+	if (cmd_string_split(cp + 1, &new_argc, &new_argv) != 0)
+		return (-1);
+
+	*argc = new_argc + old_argc - 1;
+	*argv = xcalloc((*argc) + 1, sizeof **argv);
+
+	for (i = 0; i < new_argc; i++)
+		(*argv)[i] = xstrdup(new_argv[i]);
+	for (i = 1; i < old_argc; i++)
+		(*argv)[new_argc + i - 1] = xstrdup(old_argv[i]);
+
+	log_debug("alias: %s=%s", old_argv[0], cp + 1);
+	for (i = 0; i < *argc; i++)
+		log_debug("alias: argv[%d] = %s", i, (*argv)[i]);
+
+	cmd_free_argv(new_argc, new_argv);
+	return (0);
+}
+
 struct cmd *
 cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 {
+	const char		*name;
 	const struct cmd_entry **entryp, *entry;
 	struct cmd		*cmd;
 	struct args		*args;
 	char			 s[BUFSIZ];
-	int			 ambiguous = 0;
+	int			 ambiguous, allocated = 0;

 	*cause = NULL;
 	if (argc == 0) {
 		xasprintf(cause, "no command");
 		return (NULL);
 	}
+	name = argv[0];

+retry:
+	ambiguous = 0;
 	entry = NULL;
 	for (entryp = cmd_table; *entryp != NULL; entryp++) {
 		if ((*entryp)->alias != NULL &&
@@ -341,10 +388,17 @@ cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 		if (strcmp(entry->name, argv[0]) == 0)
 			break;
 	}
+	if ((ambiguous || entry == NULL) &&
+	    server_proc != NULL &&
+	    !allocated &&
+	    cmd_try_alias(&argc, &argv) == 0) {
+		allocated = 1;
+		goto retry;
+	}
 	if (ambiguous)
 		goto ambiguous;
 	if (entry == NULL) {
-		xasprintf(cause, "unknown command: %s", argv[0]);
+		xasprintf(cause, "unknown command: %s", name);
 		return (NULL);
 	}

@@ -364,6 +418,8 @@ cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
 		cmd->file = xstrdup(file);
 	cmd->line = line;

+	if (allocated)
+		cmd_free_argv(argc, argv);
 	return (cmd);

 ambiguous:
@@ -377,7 +433,7 @@ ambiguous:
 			break;
 	}
 	s[strlen(s) - 2] = '\0';
-	xasprintf(cause, "ambiguous command: %s, could be: %s", argv[0], s);
+	xasprintf(cause, "ambiguous command: %s, could be: %s", name, s);
 	return (NULL);

 usage:
@@ -387,179 +443,6 @@ usage:
 	return (NULL);
 }

-static int
-cmd_prepare_state_flag(char c, const char *target, enum cmd_entry_flag flag,
-    struct cmd_q *cmdq, struct cmd_q *parent)
-{
-	int			 targetflags, error;
-	struct cmd_find_state	*fs = NULL;
-	struct cmd_find_state	*current = NULL;
-	struct cmd_find_state	 tmp;
-
-	if (flag == CMD_NONE ||
-	    flag == CMD_CLIENT ||
-	    flag == CMD_CLIENT_CANFAIL)
-		return (0);
-
-	if (c == 't')
-		fs = &cmdq->state.tflag;
-	else if (c == 's')
-		fs = &cmdq->state.sflag;
-
-	if (flag == CMD_SESSION_WITHPANE) {
-		if (target != NULL && target[strcspn(target, ":.")] != '\0')
-			flag = CMD_PANE;
-		else
-			flag = CMD_SESSION;
-	}
-
-	targetflags = 0;
-	switch (flag) {
-	case CMD_SESSION:
-	case CMD_SESSION_CANFAIL:
-	case CMD_SESSION_PREFERUNATTACHED:
-		if (flag == CMD_SESSION_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_SESSION_PREFERUNATTACHED)
-			targetflags |= CMD_FIND_PREFER_UNATTACHED;
-		break;
-	case CMD_MOVEW_R:
-		flag = CMD_WINDOW_INDEX;
-		/* FALLTHROUGH */
-	case CMD_WINDOW:
-	case CMD_WINDOW_CANFAIL:
-	case CMD_WINDOW_MARKED:
-	case CMD_WINDOW_INDEX:
-		if (flag == CMD_WINDOW_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_WINDOW_MARKED)
-			targetflags |= CMD_FIND_DEFAULT_MARKED;
-		if (flag == CMD_WINDOW_INDEX)
-			targetflags |= CMD_FIND_WINDOW_INDEX;
-		break;
-	case CMD_PANE:
-	case CMD_PANE_CANFAIL:
-	case CMD_PANE_MARKED:
-		if (flag == CMD_PANE_CANFAIL)
-			targetflags |= CMD_FIND_QUIET;
-		if (flag == CMD_PANE_MARKED)
-			targetflags |= CMD_FIND_DEFAULT_MARKED;
-		break;
-	default:
-		fatalx("unknown %cflag %d", c, flag);
-	}
-
-	log_debug("%s: flag %c %d %#x", __func__, c, flag, targetflags);
-	if (parent != NULL) {
-		if (c == 't')
-			current = &parent->state.tflag;
-		else if (c == 's')
-			current = &parent->state.sflag;
-	} else {
-		error = cmd_find_current(&tmp, cmdq, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		current = &tmp;
-	}
-
-	switch (flag) {
-	case CMD_NONE:
-	case CMD_CLIENT:
-	case CMD_CLIENT_CANFAIL:
-		return (0);
-	case CMD_SESSION:
-	case CMD_SESSION_CANFAIL:
-	case CMD_SESSION_PREFERUNATTACHED:
-	case CMD_SESSION_WITHPANE:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_SESSION, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	case CMD_MOVEW_R:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_SESSION, CMD_FIND_QUIET);
-		if (error == 0)
-			break;
-		/* FALLTHROUGH */
-	case CMD_WINDOW:
-	case CMD_WINDOW_CANFAIL:
-	case CMD_WINDOW_MARKED:
-	case CMD_WINDOW_INDEX:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_WINDOW, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	case CMD_PANE:
-	case CMD_PANE_CANFAIL:
-	case CMD_PANE_MARKED:
-		error = cmd_find_target(fs, current, cmdq, target,
-		    CMD_FIND_PANE, targetflags);
-		if (error != 0 && ~targetflags & CMD_FIND_QUIET)
-			return (-1);
-		break;
-	default:
-		fatalx("unknown %cflag %d", c, flag);
-	}
-	return (0);
-}
-
-int
-cmd_prepare_state(struct cmd *cmd, struct cmd_q *cmdq, struct cmd_q *parent)
-{
-	const struct cmd_entry		*entry = cmd->entry;
-	struct cmd_state		*state = &cmdq->state;
-	char				*tmp;
-	enum cmd_entry_flag		 flag;
-	const char			*s;
-	int				 error;
-
-	tmp = cmd_print(cmd);
-	log_debug("preparing state for %s (client %p)", tmp, cmdq->client);
-	free(tmp);
-
-	state->c = NULL;
-	cmd_find_clear_state(&state->tflag, NULL, 0);
-	cmd_find_clear_state(&state->sflag, NULL, 0);
-
-	flag = cmd->entry->cflag;
-	if (flag == CMD_NONE) {
-		flag = cmd->entry->tflag;
-		if (flag == CMD_CLIENT || flag == CMD_CLIENT_CANFAIL)
-			s = args_get(cmd->args, 't');
-		else
-			s = NULL;
-	} else
-		s = args_get(cmd->args, 'c');
-	switch (flag) {
-	case CMD_CLIENT:
-		state->c = cmd_find_client(cmdq, s, 0);
-		if (state->c == NULL)
-			return (-1);
-		break;
-	default:
-		state->c = cmd_find_client(cmdq, s, 1);
-		break;
-	}
-
-	s = args_get(cmd->args, 't');
-	log_debug("preparing -t state: target %s", s == NULL ? "none" : s);
-
-	error = cmd_prepare_state_flag('t', s, entry->tflag, cmdq, parent);
-	if (error != 0)
-		return (error);
-
-	s = args_get(cmd->args, 's');
-	log_debug("preparing -s state: target %s", s == NULL ? "none" : s);
-
-	error = cmd_prepare_state_flag('s', s, entry->sflag, cmdq, parent);
-	if (error != 0)
-		return (error);
-
-	return (0);
-}
-
 char *
 cmd_print(struct cmd *cmd)
 {
@@ -600,8 +483,10 @@ cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
 	if (y < wp->yoff || y >= wp->yoff + wp->sy)
 		return (-1);

-	*xp = x - wp->xoff;
-	*yp = y - wp->yoff;
+	if (xp != NULL)
+		*xp = x - wp->xoff;
+	if (yp != NULL)
+		*yp = y - wp->yoff;
 	return (0);
 }

@@ -649,8 +534,8 @@ char *
 cmd_template_replace(const char *template, const char *s, int idx)
 {
 	char		 ch, *buf;
-	const char	*ptr;
-	int		 replaced;
+	const char	*ptr, *cp, quote[] = "\"\\$";
+	int		 replaced, quoted;
 	size_t		 len;

 	if (strchr(template, '%') == NULL)
@@ -672,9 +557,21 @@ cmd_template_replace(const char *template, const char *s, int idx)
 			}
 			ptr++;

-			len += strlen(s);
-			buf = xrealloc(buf, len + 1);
-			strlcat(buf, s, len + 1);
+			quoted = (*ptr == '%');
+			if (quoted)
+				ptr++;
+
+			buf = xrealloc(buf, len + (strlen(s) * 3) + 1);
+			for (cp = s; *cp != '\0'; cp++) {
+				if (quoted && strchr(quote, *cp) != NULL)
+					buf[len++] = '\\';
+				if (quoted && *cp == ';') {
+					buf[len++] = '\\';
+					buf[len++] = '\\';
+				}
+				buf[len++] = *cp;
+			}
+			buf[len] = '\0';
 			continue;
 		}
 		buf = xrealloc(buf, len + 2);
--- a/colour.c
+++ b/colour.c
@@ -2,6 +2,7 @@

 /*
 * Copyright (c) 2008 Nicholas Marriott <nicholas.marriott@gmail.com>
+ * Copyright (c) 2016 Avi Halachmi <avihpit@yahoo.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
@@ -24,334 +25,83 @@

 #include "tmux.h"

-/*
- * Colour to string conversion functions. Bit 8 of the colour means it is one
- * of the 256 colour palette.
- */
-
-struct colour_rgb {
-	u_char  i;
-	u_char	r;
-	u_char	g;
-	u_char	b;
-};
-
-const struct colour_rgb colour_from_256[] = {
-	{   0, 0x00, 0x00, 0x00 }, {   1, 0x00, 0x00, 0x5f },
-	{   2, 0x00, 0x00, 0x87 }, {   3, 0x00, 0x00, 0xaf },
-	{   4, 0x00, 0x00, 0xd7 }, {   5, 0x00, 0x00, 0xff },
-	{   6, 0x00, 0x5f, 0x00 }, {   7, 0x00, 0x5f, 0x5f },
-	{   8, 0x00, 0x5f, 0x87 }, {   9, 0x00, 0x5f, 0xaf },
-	{  10, 0x00, 0x5f, 0xd7 }, {  11, 0x00, 0x5f, 0xff },
-	{  12, 0x00, 0x87, 0x00 }, {  13, 0x00, 0x87, 0x5f },
-	{  14, 0x00, 0x87, 0x87 }, {  15, 0x00, 0x87, 0xaf },
-	{  16, 0x00, 0x87, 0xd7 }, {  17, 0x00, 0x87, 0xff },
-	{  18, 0x00, 0xaf, 0x00 }, {  19, 0x00, 0xaf, 0x5f },
-	{  20, 0x00, 0xaf, 0x87 }, {  21, 0x00, 0xaf, 0xaf },
-	{  22, 0x00, 0xaf, 0xd7 }, {  23, 0x00, 0xaf, 0xff },
-	{  24, 0x00, 0xd7, 0x00 }, {  25, 0x00, 0xd7, 0x5f },
-	{  26, 0x00, 0xd7, 0x87 }, {  27, 0x00, 0xd7, 0xaf },
-	{  28, 0x00, 0xd7, 0xd7 }, {  29, 0x00, 0xd7, 0xff },
-	{  30, 0x00, 0xff, 0x00 }, {  31, 0x00, 0xff, 0x5f },
-	{  32, 0x00, 0xff, 0x87 }, {  33, 0x00, 0xff, 0xaf },
-	{  34, 0x00, 0xff, 0xd7 }, {  35, 0x00, 0xff, 0xff },
-	{  36, 0x5f, 0x00, 0x00 }, {  37, 0x5f, 0x00, 0x5f },
-	{  38, 0x5f, 0x00, 0x87 }, {  39, 0x5f, 0x00, 0xaf },
-	{  40, 0x5f, 0x00, 0xd7 }, {  41, 0x5f, 0x00, 0xff },
-	{  42, 0x5f, 0x5f, 0x00 }, {  43, 0x5f, 0x5f, 0x5f },
-	{  44, 0x5f, 0x5f, 0x87 }, {  45, 0x5f, 0x5f, 0xaf },
-	{  46, 0x5f, 0x5f, 0xd7 }, {  47, 0x5f, 0x5f, 0xff },
-	{  48, 0x5f, 0x87, 0x00 }, {  49, 0x5f, 0x87, 0x5f },
-	{  50, 0x5f, 0x87, 0x87 }, {  51, 0x5f, 0x87, 0xaf },
-	{  52, 0x5f, 0x87, 0xd7 }, {  53, 0x5f, 0x87, 0xff },
-	{  54, 0x5f, 0xaf, 0x00 }, {  55, 0x5f, 0xaf, 0x5f },
-	{  56, 0x5f, 0xaf, 0x87 }, {  57, 0x5f, 0xaf, 0xaf },
-	{  58, 0x5f, 0xaf, 0xd7 }, {  59, 0x5f, 0xaf, 0xff },
-	{  60, 0x5f, 0xd7, 0x00 }, {  61, 0x5f, 0xd7, 0x5f },
-	{  62, 0x5f, 0xd7, 0x87 }, {  63, 0x5f, 0xd7, 0xaf },
-	{  64, 0x5f, 0xd7, 0xd7 }, {  65, 0x5f, 0xd7, 0xff },
-	{  66, 0x5f, 0xff, 0x00 }, {  67, 0x5f, 0xff, 0x5f },
-	{  68, 0x5f, 0xff, 0x87 }, {  69, 0x5f, 0xff, 0xaf },
-	{  70, 0x5f, 0xff, 0xd7 }, {  71, 0x5f, 0xff, 0xff },
-	{  72, 0x87, 0x00, 0x00 }, {  73, 0x87, 0x00, 0x5f },
-	{  74, 0x87, 0x00, 0x87 }, {  75, 0x87, 0x00, 0xaf },
-	{  76, 0x87, 0x00, 0xd7 }, {  77, 0x87, 0x00, 0xff },
-	{  78, 0x87, 0x5f, 0x00 }, {  79, 0x87, 0x5f, 0x5f },
-	{  80, 0x87, 0x5f, 0x87 }, {  81, 0x87, 0x5f, 0xaf },
-	{  82, 0x87, 0x5f, 0xd7 }, {  83, 0x87, 0x5f, 0xff },
-	{  84, 0x87, 0x87, 0x00 }, {  85, 0x87, 0x87, 0x5f },
-	{  86, 0x87, 0x87, 0x87 }, {  87, 0x87, 0x87, 0xaf },
-	{  88, 0x87, 0x87, 0xd7 }, {  89, 0x87, 0x87, 0xff },
-	{  90, 0x87, 0xaf, 0x00 }, {  91, 0x87, 0xaf, 0x5f },
-	{  92, 0x87, 0xaf, 0x87 }, {  93, 0x87, 0xaf, 0xaf },
-	{  94, 0x87, 0xaf, 0xd7 }, {  95, 0x87, 0xaf, 0xff },
-	{  96, 0x87, 0xd7, 0x00 }, {  97, 0x87, 0xd7, 0x5f },
-	{  98, 0x87, 0xd7, 0x87 }, {  99, 0x87, 0xd7, 0xaf },
-	{ 100, 0x87, 0xd7, 0xd7 }, { 101, 0x87, 0xd7, 0xff },
-	{ 102, 0x87, 0xff, 0x00 }, { 103, 0x87, 0xff, 0x5f },
-	{ 104, 0x87, 0xff, 0x87 }, { 105, 0x87, 0xff, 0xaf },
-	{ 106, 0x87, 0xff, 0xd7 }, { 107, 0x87, 0xff, 0xff },
-	{ 108, 0xaf, 0x00, 0x00 }, { 109, 0xaf, 0x00, 0x5f },
-	{ 110, 0xaf, 0x00, 0x87 }, { 111, 0xaf, 0x00, 0xaf },
-	{ 112, 0xaf, 0x00, 0xd7 }, { 113, 0xaf, 0x00, 0xff },
-	{ 114, 0xaf, 0x5f, 0x00 }, { 115, 0xaf, 0x5f, 0x5f },
-	{ 116, 0xaf, 0x5f, 0x87 }, { 117, 0xaf, 0x5f, 0xaf },
-	{ 118, 0xaf, 0x5f, 0xd7 }, { 119, 0xaf, 0x5f, 0xff },
-	{ 120, 0xaf, 0x87, 0x00 }, { 121, 0xaf, 0x87, 0x5f },
-	{ 122, 0xaf, 0x87, 0x87 }, { 123, 0xaf, 0x87, 0xaf },
-	{ 124, 0xaf, 0x87, 0xd7 }, { 125, 0xaf, 0x87, 0xff },
-	{ 126, 0xaf, 0xaf, 0x00 }, { 127, 0xaf, 0xaf, 0x5f },
-	{ 128, 0xaf, 0xaf, 0x87 }, { 129, 0xaf, 0xaf, 0xaf },
-	{ 130, 0xaf, 0xaf, 0xd7 }, { 131, 0xaf, 0xaf, 0xff },
-	{ 132, 0xaf, 0xd7, 0x00 }, { 133, 0xaf, 0xd7, 0x5f },
-	{ 134, 0xaf, 0xd7, 0x87 }, { 135, 0xaf, 0xd7, 0xaf },
-	{ 136, 0xaf, 0xd7, 0xd7 }, { 137, 0xaf, 0xd7, 0xff },
-	{ 138, 0xaf, 0xff, 0x00 }, { 139, 0xaf, 0xff, 0x5f },
-	{ 140, 0xaf, 0xff, 0x87 }, { 141, 0xaf, 0xff, 0xaf },
-	{ 142, 0xaf, 0xff, 0xd7 }, { 143, 0xaf, 0xff, 0xff },
-	{ 144, 0xd7, 0x00, 0x00 }, { 145, 0xd7, 0x00, 0x5f },
-	{ 146, 0xd7, 0x00, 0x87 }, { 147, 0xd7, 0x00, 0xaf },
-	{ 148, 0xd7, 0x00, 0xd7 }, { 149, 0xd7, 0x00, 0xff },
-	{ 150, 0xd7, 0x5f, 0x00 }, { 151, 0xd7, 0x5f, 0x5f },
-	{ 152, 0xd7, 0x5f, 0x87 }, { 153, 0xd7, 0x5f, 0xaf },
-	{ 154, 0xd7, 0x5f, 0xd7 }, { 155, 0xd7, 0x5f, 0xff },
-	{ 156, 0xd7, 0x87, 0x00 }, { 157, 0xd7, 0x87, 0x5f },
-	{ 158, 0xd7, 0x87, 0x87 }, { 159, 0xd7, 0x87, 0xaf },
-	{ 160, 0xd7, 0x87, 0xd7 }, { 161, 0xd7, 0x87, 0xff },
-	{ 162, 0xd7, 0xaf, 0x00 }, { 163, 0xd7, 0xaf, 0x5f },
-	{ 164, 0xd7, 0xaf, 0x87 }, { 165, 0xd7, 0xaf, 0xaf },
-	{ 166, 0xd7, 0xaf, 0xd7 }, { 167, 0xd7, 0xaf, 0xff },
-	{ 168, 0xd7, 0xd7, 0x00 }, { 169, 0xd7, 0xd7, 0x5f },
-	{ 170, 0xd7, 0xd7, 0x87 }, { 171, 0xd7, 0xd7, 0xaf },
-	{ 172, 0xd7, 0xd7, 0xd7 }, { 173, 0xd7, 0xd7, 0xff },
-	{ 174, 0xd7, 0xff, 0x00 }, { 175, 0xd7, 0xff, 0x5f },
-	{ 176, 0xd7, 0xff, 0x87 }, { 177, 0xd7, 0xff, 0xaf },
-	{ 178, 0xd7, 0xff, 0xd7 }, { 179, 0xd7, 0xff, 0xff },
-	{ 180, 0xff, 0x00, 0x00 }, { 181, 0xff, 0x00, 0x5f },
-	{ 182, 0xff, 0x00, 0x87 }, { 183, 0xff, 0x00, 0xaf },
-	{ 184, 0xff, 0x00, 0xd7 }, { 185, 0xff, 0x00, 0xff },
-	{ 186, 0xff, 0x5f, 0x00 }, { 187, 0xff, 0x5f, 0x5f },
-	{ 188, 0xff, 0x5f, 0x87 }, { 189, 0xff, 0x5f, 0xaf },
-	{ 190, 0xff, 0x5f, 0xd7 }, { 191, 0xff, 0x5f, 0xff },
-	{ 192, 0xff, 0x87, 0x00 }, { 193, 0xff, 0x87, 0x5f },
-	{ 194, 0xff, 0x87, 0x87 }, { 195, 0xff, 0x87, 0xaf },
-	{ 196, 0xff, 0x87, 0xd7 }, { 197, 0xff, 0x87, 0xff },
-	{ 198, 0xff, 0xaf, 0x00 }, { 199, 0xff, 0xaf, 0x5f },
-	{ 200, 0xff, 0xaf, 0x87 }, { 201, 0xff, 0xaf, 0xaf },
-	{ 202, 0xff, 0xaf, 0xd7 }, { 203, 0xff, 0xaf, 0xff },
-	{ 204, 0xff, 0xd7, 0x00 }, { 205, 0xff, 0xd7, 0x5f },
-	{ 206, 0xff, 0xd7, 0x87 }, { 207, 0xff, 0xd7, 0xaf },
-	{ 208, 0xff, 0xd7, 0xd7 }, { 209, 0xff, 0xd7, 0xff },
-	{ 210, 0xff, 0xff, 0x00 }, { 211, 0xff, 0xff, 0x5f },
-	{ 212, 0xff, 0xff, 0x87 }, { 213, 0xff, 0xff, 0xaf },
-	{ 214, 0xff, 0xff, 0xd7 }, { 215, 0xff, 0xff, 0xff },
-	{ 216, 0x08, 0x08, 0x08 }, { 217, 0x12, 0x12, 0x12 },
-	{ 218, 0x1c, 0x1c, 0x1c }, { 219, 0x26, 0x26, 0x26 },
-	{ 220, 0x30, 0x30, 0x30 }, { 221, 0x3a, 0x3a, 0x3a },
-	{ 222, 0x44, 0x44, 0x44 }, { 223, 0x4e, 0x4e, 0x4e },
-	{ 224, 0x58, 0x58, 0x58 }, { 225, 0x62, 0x62, 0x62 },
-	{ 226, 0x6c, 0x6c, 0x6c }, { 227, 0x76, 0x76, 0x76 },
-	{ 228, 0x80, 0x80, 0x80 }, { 229, 0x8a, 0x8a, 0x8a },
-	{ 230, 0x94, 0x94, 0x94 }, { 231, 0x9e, 0x9e, 0x9e },
-	{ 232, 0xa8, 0xa8, 0xa8 }, { 233, 0xb2, 0xb2, 0xb2 },
-	{ 234, 0xbc, 0xbc, 0xbc }, { 235, 0xc6, 0xc6, 0xc6 },
-	{ 236, 0xd0, 0xd0, 0xd0 }, { 237, 0xda, 0xda, 0xda },
-	{ 238, 0xe4, 0xe4, 0xe4 }, { 239, 0xee, 0xee, 0xee },
-};
-const struct colour_rgb colour_to_256[] = {
-	{   0, 0x00, 0x00, 0x00 }, {   1, 0x00, 0x00, 0x5f },
-	{   2, 0x00, 0x00, 0x87 }, {   3, 0x00, 0x00, 0xaf },
-	{   4, 0x00, 0x00, 0xd7 }, {   5, 0x00, 0x00, 0xff },
-	{   6, 0x00, 0x5f, 0x00 }, {   7, 0x00, 0x5f, 0x5f },
-	{   8, 0x00, 0x5f, 0x87 }, {   9, 0x00, 0x5f, 0xaf },
-	{  10, 0x00, 0x5f, 0xd7 }, {  11, 0x00, 0x5f, 0xff },
-	{  12, 0x00, 0x87, 0x00 }, {  13, 0x00, 0x87, 0x5f },
-	{  14, 0x00, 0x87, 0x87 }, {  15, 0x00, 0x87, 0xaf },
-	{  16, 0x00, 0x87, 0xd7 }, {  17, 0x00, 0x87, 0xff },
-	{  18, 0x00, 0xaf, 0x00 }, {  19, 0x00, 0xaf, 0x5f },
-	{  20, 0x00, 0xaf, 0x87 }, {  21, 0x00, 0xaf, 0xaf },
-	{  22, 0x00, 0xaf, 0xd7 }, {  23, 0x00, 0xaf, 0xff },
-	{  24, 0x00, 0xd7, 0x00 }, {  25, 0x00, 0xd7, 0x5f },
-	{  26, 0x00, 0xd7, 0x87 }, {  27, 0x00, 0xd7, 0xaf },
-	{  28, 0x00, 0xd7, 0xd7 }, {  29, 0x00, 0xd7, 0xff },
-	{  30, 0x00, 0xff, 0x00 }, {  31, 0x00, 0xff, 0x5f },
-	{  32, 0x00, 0xff, 0x87 }, {  33, 0x00, 0xff, 0xaf },
-	{  34, 0x00, 0xff, 0xd7 }, {  35, 0x00, 0xff, 0xff },
-	{ 216, 0x08, 0x08, 0x08 }, { 217, 0x12, 0x12, 0x12 },
-	{ 218, 0x1c, 0x1c, 0x1c }, { 219, 0x26, 0x26, 0x26 },
-	{ 220, 0x30, 0x30, 0x30 }, { 221, 0x3a, 0x3a, 0x3a },
-	{ 222, 0x44, 0x44, 0x44 }, { 223, 0x4e, 0x4e, 0x4e },
-	{ 224, 0x58, 0x58, 0x58 }, {  36, 0x5f, 0x00, 0x00 },
-	{  37, 0x5f, 0x00, 0x5f }, {  38, 0x5f, 0x00, 0x87 },
-	{  39, 0x5f, 0x00, 0xaf }, {  40, 0x5f, 0x00, 0xd7 },
-	{  41, 0x5f, 0x00, 0xff }, {  42, 0x5f, 0x5f, 0x00 },
-	{  43, 0x5f, 0x5f, 0x5f }, {  44, 0x5f, 0x5f, 0x87 },
-	{  45, 0x5f, 0x5f, 0xaf }, {  46, 0x5f, 0x5f, 0xd7 },
-	{  47, 0x5f, 0x5f, 0xff }, {  48, 0x5f, 0x87, 0x00 },
-	{  49, 0x5f, 0x87, 0x5f }, {  50, 0x5f, 0x87, 0x87 },
-	{  51, 0x5f, 0x87, 0xaf }, {  52, 0x5f, 0x87, 0xd7 },
-	{  53, 0x5f, 0x87, 0xff }, {  54, 0x5f, 0xaf, 0x00 },
-	{  55, 0x5f, 0xaf, 0x5f }, {  56, 0x5f, 0xaf, 0x87 },
-	{  57, 0x5f, 0xaf, 0xaf }, {  58, 0x5f, 0xaf, 0xd7 },
-	{  59, 0x5f, 0xaf, 0xff }, {  60, 0x5f, 0xd7, 0x00 },
-	{  61, 0x5f, 0xd7, 0x5f }, {  62, 0x5f, 0xd7, 0x87 },
-	{  63, 0x5f, 0xd7, 0xaf }, {  64, 0x5f, 0xd7, 0xd7 },
-	{  65, 0x5f, 0xd7, 0xff }, {  66, 0x5f, 0xff, 0x00 },
-	{  67, 0x5f, 0xff, 0x5f }, {  68, 0x5f, 0xff, 0x87 },
-	{  69, 0x5f, 0xff, 0xaf }, {  70, 0x5f, 0xff, 0xd7 },
-	{  71, 0x5f, 0xff, 0xff }, { 225, 0x62, 0x62, 0x62 },
-	{ 226, 0x6c, 0x6c, 0x6c }, { 227, 0x76, 0x76, 0x76 },
-	{ 228, 0x80, 0x80, 0x80 }, {  72, 0x87, 0x00, 0x00 },
-	{  73, 0x87, 0x00, 0x5f }, {  74, 0x87, 0x00, 0x87 },
-	{  75, 0x87, 0x00, 0xaf }, {  76, 0x87, 0x00, 0xd7 },
-	{  77, 0x87, 0x00, 0xff }, {  78, 0x87, 0x5f, 0x00 },
-	{  79, 0x87, 0x5f, 0x5f }, {  80, 0x87, 0x5f, 0x87 },
-	{  81, 0x87, 0x5f, 0xaf }, {  82, 0x87, 0x5f, 0xd7 },
-	{  83, 0x87, 0x5f, 0xff }, {  84, 0x87, 0x87, 0x00 },
-	{  85, 0x87, 0x87, 0x5f }, {  86, 0x87, 0x87, 0x87 },
-	{  87, 0x87, 0x87, 0xaf }, {  88, 0x87, 0x87, 0xd7 },
-	{  89, 0x87, 0x87, 0xff }, {  90, 0x87, 0xaf, 0x00 },
-	{  91, 0x87, 0xaf, 0x5f }, {  92, 0x87, 0xaf, 0x87 },
-	{  93, 0x87, 0xaf, 0xaf }, {  94, 0x87, 0xaf, 0xd7 },
-	{  95, 0x87, 0xaf, 0xff }, {  96, 0x87, 0xd7, 0x00 },
-	{  97, 0x87, 0xd7, 0x5f }, {  98, 0x87, 0xd7, 0x87 },
-	{  99, 0x87, 0xd7, 0xaf }, { 100, 0x87, 0xd7, 0xd7 },
-	{ 101, 0x87, 0xd7, 0xff }, { 102, 0x87, 0xff, 0x00 },
-	{ 103, 0x87, 0xff, 0x5f }, { 104, 0x87, 0xff, 0x87 },
-	{ 105, 0x87, 0xff, 0xaf }, { 106, 0x87, 0xff, 0xd7 },
-	{ 107, 0x87, 0xff, 0xff }, { 229, 0x8a, 0x8a, 0x8a },
-	{ 230, 0x94, 0x94, 0x94 }, { 231, 0x9e, 0x9e, 0x9e },
-	{ 232, 0xa8, 0xa8, 0xa8 }, { 108, 0xaf, 0x00, 0x00 },
-	{ 109, 0xaf, 0x00, 0x5f }, { 110, 0xaf, 0x00, 0x87 },
-	{ 111, 0xaf, 0x00, 0xaf }, { 112, 0xaf, 0x00, 0xd7 },
-	{ 113, 0xaf, 0x00, 0xff }, { 114, 0xaf, 0x5f, 0x00 },
-	{ 115, 0xaf, 0x5f, 0x5f }, { 116, 0xaf, 0x5f, 0x87 },
-	{ 117, 0xaf, 0x5f, 0xaf }, { 118, 0xaf, 0x5f, 0xd7 },
-	{ 119, 0xaf, 0x5f, 0xff }, { 120, 0xaf, 0x87, 0x00 },
-	{ 121, 0xaf, 0x87, 0x5f }, { 122, 0xaf, 0x87, 0x87 },
-	{ 123, 0xaf, 0x87, 0xaf }, { 124, 0xaf, 0x87, 0xd7 },
-	{ 125, 0xaf, 0x87, 0xff }, { 126, 0xaf, 0xaf, 0x00 },
-	{ 127, 0xaf, 0xaf, 0x5f }, { 128, 0xaf, 0xaf, 0x87 },
-	{ 129, 0xaf, 0xaf, 0xaf }, { 130, 0xaf, 0xaf, 0xd7 },
-	{ 131, 0xaf, 0xaf, 0xff }, { 132, 0xaf, 0xd7, 0x00 },
-	{ 133, 0xaf, 0xd7, 0x5f }, { 134, 0xaf, 0xd7, 0x87 },
-	{ 135, 0xaf, 0xd7, 0xaf }, { 136, 0xaf, 0xd7, 0xd7 },
-	{ 137, 0xaf, 0xd7, 0xff }, { 138, 0xaf, 0xff, 0x00 },
-	{ 139, 0xaf, 0xff, 0x5f }, { 140, 0xaf, 0xff, 0x87 },
-	{ 141, 0xaf, 0xff, 0xaf }, { 142, 0xaf, 0xff, 0xd7 },
-	{ 143, 0xaf, 0xff, 0xff }, { 233, 0xb2, 0xb2, 0xb2 },
-	{ 234, 0xbc, 0xbc, 0xbc }, { 235, 0xc6, 0xc6, 0xc6 },
-	{ 236, 0xd0, 0xd0, 0xd0 }, { 144, 0xd7, 0x00, 0x00 },
-	{ 145, 0xd7, 0x00, 0x5f }, { 146, 0xd7, 0x00, 0x87 },
-	{ 147, 0xd7, 0x00, 0xaf }, { 148, 0xd7, 0x00, 0xd7 },
-	{ 149, 0xd7, 0x00, 0xff }, { 150, 0xd7, 0x5f, 0x00 },
-	{ 151, 0xd7, 0x5f, 0x5f }, { 152, 0xd7, 0x5f, 0x87 },
-	{ 153, 0xd7, 0x5f, 0xaf }, { 154, 0xd7, 0x5f, 0xd7 },
-	{ 155, 0xd7, 0x5f, 0xff }, { 156, 0xd7, 0x87, 0x00 },
-	{ 157, 0xd7, 0x87, 0x5f }, { 158, 0xd7, 0x87, 0x87 },
-	{ 159, 0xd7, 0x87, 0xaf }, { 160, 0xd7, 0x87, 0xd7 },
-	{ 161, 0xd7, 0x87, 0xff }, { 162, 0xd7, 0xaf, 0x00 },
-	{ 163, 0xd7, 0xaf, 0x5f }, { 164, 0xd7, 0xaf, 0x87 },
-	{ 165, 0xd7, 0xaf, 0xaf }, { 166, 0xd7, 0xaf, 0xd7 },
-	{ 167, 0xd7, 0xaf, 0xff }, { 168, 0xd7, 0xd7, 0x00 },
-	{ 169, 0xd7, 0xd7, 0x5f }, { 170, 0xd7, 0xd7, 0x87 },
-	{ 171, 0xd7, 0xd7, 0xaf }, { 172, 0xd7, 0xd7, 0xd7 },
-	{ 173, 0xd7, 0xd7, 0xff }, { 174, 0xd7, 0xff, 0x00 },
-	{ 175, 0xd7, 0xff, 0x5f }, { 176, 0xd7, 0xff, 0x87 },
-	{ 177, 0xd7, 0xff, 0xaf }, { 178, 0xd7, 0xff, 0xd7 },
-	{ 179, 0xd7, 0xff, 0xff }, { 237, 0xda, 0xda, 0xda },
-	{ 238, 0xe4, 0xe4, 0xe4 }, { 239, 0xee, 0xee, 0xee },
-	{ 180, 0xff, 0x00, 0x00 }, { 181, 0xff, 0x00, 0x5f },
-	{ 182, 0xff, 0x00, 0x87 }, { 183, 0xff, 0x00, 0xaf },
-	{ 184, 0xff, 0x00, 0xd7 }, { 185, 0xff, 0x00, 0xff },
-	{ 186, 0xff, 0x5f, 0x00 }, { 187, 0xff, 0x5f, 0x5f },
-	{ 188, 0xff, 0x5f, 0x87 }, { 189, 0xff, 0x5f, 0xaf },
-	{ 190, 0xff, 0x5f, 0xd7 }, { 191, 0xff, 0x5f, 0xff },
-	{ 192, 0xff, 0x87, 0x00 }, { 193, 0xff, 0x87, 0x5f },
-	{ 194, 0xff, 0x87, 0x87 }, { 195, 0xff, 0x87, 0xaf },
-	{ 196, 0xff, 0x87, 0xd7 }, { 197, 0xff, 0x87, 0xff },
-	{ 198, 0xff, 0xaf, 0x00 }, { 199, 0xff, 0xaf, 0x5f },
-	{ 200, 0xff, 0xaf, 0x87 }, { 201, 0xff, 0xaf, 0xaf },
-	{ 202, 0xff, 0xaf, 0xd7 }, { 203, 0xff, 0xaf, 0xff },
-	{ 204, 0xff, 0xd7, 0x00 }, { 205, 0xff, 0xd7, 0x5f },
-	{ 206, 0xff, 0xd7, 0x87 }, { 207, 0xff, 0xd7, 0xaf },
-	{ 208, 0xff, 0xd7, 0xd7 }, { 209, 0xff, 0xd7, 0xff },
-	{ 210, 0xff, 0xff, 0x00 }, { 211, 0xff, 0xff, 0x5f },
-	{ 212, 0xff, 0xff, 0x87 }, { 213, 0xff, 0xff, 0xaf },
-	{ 214, 0xff, 0xff, 0xd7 }, { 215, 0xff, 0xff, 0xff },
-};
-
-int	colour_cmp_rgb(const void *, const void *);
-
-/* Compare function for bsearch(). */
-int
-colour_cmp_rgb(const void *lhs0, const void *rhs0)
+static int
+colour_dist_sq(int R, int G, int B, int r, int g, int b)
 {
-	const struct colour_rgb *lhs = lhs0, *rhs = rhs0;
-
-	if (lhs->r < rhs->r)
-		return (-1);
-	if (lhs->r > rhs->r)
-		return (1);
-
-	if (lhs->g < rhs->g)
-		return (-1);
-	if (lhs->g > rhs->g)
-		return (1);
-
-	if (lhs->b < rhs->b)
-		return (-1);
-	if (lhs->b > rhs->b)
-		return (1);
-
-	return (0);
+	return ((R - r) * (R - r) + (G - g) * (G - g) + (B - b) * (B - b));
 }

-/* Work out the nearest colour from the 256 colour set. */
+static int
+colour_to_6cube(int v)
+{
+	if (v < 48)
+		return (0);
+	if (v < 114)
+		return (1);
+	return ((v - 35) / 40);
+}
+
+/*
+ * Convert an RGB triplet to the xterm(1) 256 colour palette.
+ *
+ * xterm provides a 6x6x6 colour cube (16 - 231) and 24 greys (232 - 255). We
+ * map our RGB colour to the closest in the cube, also work out the closest
+ * grey, and use the nearest of the two.
+ *
+ * Note that the xterm has much lower resolution for darker colours (they are
+ * not evenly spread out), so our 6 levels are not evenly spread: 0x0, 0x5f
+ * (95), 0x87 (135), 0xaf (175), 0xd7 (215) and 0xff (255). Greys are more
+ * evenly spread (8, 18, 28 ... 238).
+ */
 int
 colour_find_rgb(u_char r, u_char g, u_char b)
 {
-	struct colour_rgb	rgb = { .r = r, .g = g, .b = b }, *found;
-	u_int			distance, lowest, colour, i;
-	int			dr, dg, db;
+	static const int	q2c[6] = { 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff };
+	int			qr, qg, qb, cr, cg, cb, d, idx;
+	int			grey_avg, grey_idx, grey;

-	found = bsearch(&rgb, colour_to_256, nitems(colour_to_256),
-	    sizeof colour_to_256[0], colour_cmp_rgb);
-	if (found != NULL)
-		return (16 + found->i);
+	/* Map RGB to 6x6x6 cube. */
+	qr = colour_to_6cube(r); cr = q2c[qr];
+	qg = colour_to_6cube(g); cg = q2c[qg];
+	qb = colour_to_6cube(b); cb = q2c[qb];

-	colour = 16;
-	lowest = UINT_MAX;
-	for (i = 0; i < 240; i++) {
-		dr = (int)colour_from_256[i].r - r;
-		dg = (int)colour_from_256[i].g - g;
-		db = (int)colour_from_256[i].b - b;
+	/* If we have hit the colour exactly, return early. */
+	if (cr == r && cg == g && cb == b)
+		return ((16 + (36 * qr) + (6 * qg) + qb) | COLOUR_FLAG_256);

-		distance = dr * dr + dg * dg + db * db;
-		if (distance < lowest) {
-			lowest = distance;
-			colour = 16 + i;
-		}
-	}
-	return (colour);
+	/* Work out the closest grey (average of RGB). */
+	grey_avg = (r + g + b) / 3;
+	if (grey_avg > 238)
+		grey_idx = 23;
+	else
+		grey_idx = (grey_avg - 3) / 10;
+	grey = 8 + (10 * grey_idx);
+
+	/* Is grey or 6x6x6 colour closest? */
+	d = colour_dist_sq(cr, cg, cb, r, g, b);
+	if (colour_dist_sq(grey, grey, grey, r, g, b) < d)
+		idx = 232 + grey_idx;
+	else
+		idx = 16 + (36 * qr) + (6 * qg) + qb;
+	return (idx | COLOUR_FLAG_256);
 }

-/* Set grid cell foreground colour. */
-void
-colour_set_fg(struct grid_cell *gc, int c)
+/* Join RGB into a colour. */
+int
+colour_join_rgb(u_char r, u_char g, u_char b)
 {
-	if (c & 0x100)
-		gc->flags |= GRID_FLAG_FG256;
-	gc->fg = c;
+	return ((((int)((r) & 0xff)) << 16) |
+	    (((int)((g) & 0xff)) << 8) |
+	    (((int)((b) & 0xff))) | COLOUR_FLAG_RGB);
 }

-/* Set grid cell background colour. */
+/* Split colour into RGB. */
 void
-colour_set_bg(struct grid_cell *gc, int c)
+colour_split_rgb(int c, u_char *r, u_char *g, u_char *b)
 {
-	if (c & 0x100)
-		gc->flags |= GRID_FLAG_BG256;
-	gc->bg = c;
+	*r = (c >> 16) & 0xff;
+	*g = (c >> 8) & 0xff;
+	*b = c & 0xff;
 }

 /* Convert colour to a string. */
@@ -359,9 +109,16 @@ const char *
 colour_tostring(int c)
 {
 	static char	s[32];
+	u_char		r, g, b;

-	if (c & 0x100) {
-		xsnprintf(s, sizeof s, "colour%d", c & ~0x100);
+	if (c & COLOUR_FLAG_RGB) {
+		colour_split_rgb(c, &r, &g, &b);
+		xsnprintf(s, sizeof s, "#%02x%02x%02x", r, g, b);
+		return (s);
+	}
+
+	if (c & COLOUR_FLAG_256) {
+		xsnprintf(s, sizeof s, "colour%u", c & 0xff);
 		return (s);
 	}

@@ -421,14 +178,14 @@ colour_fromstring(const char *s)
 		n = sscanf(s + 1, "%2hhx%2hhx%2hhx", &r, &g, &b);
 		if (n != 3)
 			return (-1);
-		return (colour_find_rgb(r, g, b) | 0x100);
+		return (colour_join_rgb(r, g, b));
 	}

 	if (strncasecmp(s, "colour", (sizeof "colour") - 1) == 0) {
 		n = strtonum(s + (sizeof "colour") - 1, 0, 255, &errstr);
 		if (errstr != NULL)
 			return (-1);
-		return (n | 0x100);
+		return (n | COLOUR_FLAG_256);
 	}

 	if (strcasecmp(s, "black") == 0 || strcmp(s, "0") == 0)
--- a/compat.h
+++ b/compat.h
@@ -17,6 +17,15 @@
 #ifndef COMPAT_H
 #define COMPAT_H

+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+
+#include <limits.h>
+#include <stdio.h>
+#include <termios.h>
+#include <wchar.h>
+
 #ifndef __GNUC__
 #define __attribute__(a)
 #endif
@@ -35,11 +44,21 @@
 #define ECHOPRT 0
 #endif

-#ifndef HAVE_BSD_TYPES
-typedef uint8_t u_int8_t;
-typedef uint16_t u_int16_t;
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
+#ifndef ACCESSPERMS
+#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
+#endif
+
+#if !defined(FIONREAD) && defined(__sun)
+#include <sys/filio.h>
+#endif
+
+#ifdef HAVE_ERR_H
+#include <err.h>
+#else
+void	err(int, const char *, ...);
+void	errx(int, const char *, ...);
+void	warn(const char *, ...);
+void	warnx(const char *, ...);
 #endif

 #ifndef HAVE_PATHS_H
@@ -50,6 +69,16 @@ typedef uint64_t u_int64_t;
 #define _PATH_DEV	"/dev/"
 #endif

+#ifndef __OpenBSD__
+#define pledge(s, p) (0)
+#endif
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#include <inttypes.h>
+#endif
+
 #ifdef HAVE_QUEUE_H
 #include <sys/queue.h>
 #else
@@ -96,12 +125,6 @@ typedef uint64_t u_int64_t;
 #include "compat/imsg.h"
 #endif

-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#include <inttypes.h>
-#endif
-
 #ifdef BROKEN_CMSG_FIRSTHDR
 #undef CMSG_FIRSTHDR
 #define CMSG_FIRSTHDR(mhdr) \
@@ -188,9 +211,19 @@ typedef uint64_t u_int64_t;
 #define flock(fd, op) (0)
 #endif

+#ifndef HAVE_EXPLICIT_BZERO
+/* explicit_bzero.c */
+void		 explicit_bzero(void *, size_t);
+#endif
+
+#ifndef HAVE_GETDTABLECOUNT
+/* getdtablecount.c */
+int		 getdtablecount(void);
+#endif
+
 #ifndef HAVE_CLOSEFROM
 /* closefrom.c */
-void	closefrom(int);
+void		 closefrom(int);
 #endif

 #ifndef HAVE_STRCASESTR
@@ -218,20 +251,53 @@ size_t	 	 strlcpy(char *, const char *, size_t);
 size_t	 	 strlcat(char *, const char *, size_t);
 #endif

+#ifndef HAVE_STRNLEN
+/* strnlen.c */
+size_t		 strnlen(const char *, size_t);
+#endif
+
+#ifndef HAVE_STRNDUP
+/* strndup.c */
+char		*strndup(const char *, size_t);
+#endif
+
+#ifndef HAVE_MEMMEM
+/* memmem.c */
+void		*memmem(const void *, size_t, const void *, size_t);
+#endif
+
 #ifndef HAVE_DAEMON
 /* daemon.c */
 int	 	 daemon(int, int);
 #endif

+#ifndef HAVE_GETPROGNAME
+/* getprogname.c */
+const char	*getprogname(void);
+#endif
+
+#ifndef HAVE_SETPROCTITLE
+/* setproctitle.c */
+void		 setproctitle(const char *, ...);
+#endif
+
 #ifndef HAVE_B64_NTOP
-/* b64_ntop.c */
-#undef b64_ntop /* for Cygwin */
+/* base64.c */
+#undef b64_ntop
+#undef b64_pton
 int		 b64_ntop(const char *, size_t, char *, size_t);
+int		 b64_pton(const char *, u_char *, size_t);
+#endif
+
+#ifndef HAVE_FDFORKPTY
+/* fdforkpty.c */
+int		 getptmfd(void);
+pid_t		 fdforkpty(int, int *, char *, struct termios *,
+		     struct winsize *);
 #endif

 #ifndef HAVE_FORKPTY
 /* forkpty.c */
-#include <sys/ioctl.h>
 pid_t		 forkpty(int *, char *, struct termios *, struct winsize *);
 #endif

@@ -261,20 +327,29 @@ int		 unsetenv(const char *);
 void		 cfmakeraw(struct termios *);
 #endif

-#ifndef HAVE_OPENAT
-/* openat.c */
-#define AT_FDCWD -100
-int		 openat(int, const char *, int, ...);
+#ifndef HAVE_FREEZERO
+/* freezero.c */
+void		 freezero(void *, size_t);
 #endif

 #ifndef HAVE_REALLOCARRAY
 /* reallocarray.c */
-void		*reallocarray(void *, size_t, size_t size);
+void		*reallocarray(void *, size_t, size_t);
 #endif

-#ifdef HAVE_GETOPT
-#include <getopt.h>
-#else
+#ifndef HAVE_RECALLOCARRAY
+/* recallocarray.c */
+void		*recallocarray(void *, size_t, size_t, size_t);
+#endif
+
+#ifdef HAVE_UTF8PROC
+/* utf8proc.c */
+int		 utf8proc_wcwidth(wchar_t);
+int		 utf8proc_mbtowc(wchar_t *, const char *, size_t);
+int		 utf8proc_wctomb(char *, wchar_t);
+#endif
+
+#ifndef HAVE_GETOPT
 /* getopt.c */
 extern int	BSDopterr;
 extern int	BSDoptind;
--- a/compat/asprintf.c
+++ b/compat/asprintf.c
@@ -14,16 +14,13 @@
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

+#include <sys/types.h>
+
 #include <stdarg.h>
 #include <stdio.h>
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#include <inttypes.h>
-#endif
 #include <string.h>

-#include "tmux.h"
+#include "compat.h"

 int
 asprintf(char **ret, const char *fmt, ...)
--- a/compat/b64_ntop.c
+++ b/compat/b64_ntop.c
@@ -1,5 +1,7 @@
+/*	$OpenBSD: base64.c,v 1.8 2015/01/16 16:48:51 deraadt Exp $	*/
+
 /*
- * Copyright (c) 1996, 1998 by Internet Software Consortium.
+ * Copyright (c) 1996 by Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
@@ -41,19 +43,18 @@
 */

 #include <sys/types.h>
-#include <sys/param.h>
 #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>

-#define Assert(Cond) if (!(Cond)) abort()
-
 static const char Base64[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static const char Pad64 = '=';
@@ -122,11 +123,16 @@ static const char Pad64 = '=';
   */

 int
-b64_ntop(uint8_t 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;
-	uint8_t input[3];
-	uint8_t output[4];
-	size_t i;
+	u_char input[3];
+	u_char output[4];
+	int i;

 	while (2 < srclength) {
 		input[0] = *src++;
@@ -138,10 +144,6 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
 		output[3] = input[2] & 0x3f;
-		Assert(output[0] < 64);
-		Assert(output[1] < 64);
-		Assert(output[2] < 64);
-		Assert(output[3] < 64);

 		if (datalength + 4 > targsize)
 			return (-1);
@@ -161,9 +163,6 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 		output[0] = input[0] >> 2;
 		output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
 		output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
-		Assert(output[0] < 64);
-		Assert(output[1] < 64);
-		Assert(output[2] < 64);

 		if (datalength + 4 > targsize)
 			return (-1);
@@ -180,3 +179,137 @@ b64_ntop(uint8_t const *src, size_t srclength, char *target, size_t targsize) {
 	target[datalength] = '\0';	/* Returned value doesn't count \0. */
 	return (datalength);
 }
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+b64_pton(src, target, targsize)
+	char const *src;
+	u_char *target;
+	size_t targsize;
+{
+	int tarindex, state, ch;
+	u_char nextbyte;
+	char *pos;
+
+	state = 0;
+	tarindex = 0;
+
+	while ((ch = (unsigned char)*src++) != '\0') {
+		if (isspace(ch))	/* Skip whitespace anywhere. */
+			continue;
+
+		if (ch == Pad64)
+			break;
+
+		pos = strchr(Base64, ch);
+		if (pos == 0) 		/* A non-base64 character. */
+			return (-1);
+
+		switch (state) {
+		case 0:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex] = (pos - Base64) << 2;
+			}
+			state = 1;
+			break;
+		case 1:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 4;
+				nextbyte = ((pos - Base64) & 0x0f) << 4;
+				if (tarindex + 1 < targsize)
+					target[tarindex+1] = nextbyte;
+				else if (nextbyte)
+					return (-1);
+			}
+			tarindex++;
+			state = 2;
+			break;
+		case 2:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex]   |=  (pos - Base64) >> 2;
+				nextbyte = ((pos - Base64) & 0x03) << 6;
+				if (tarindex + 1 < targsize)
+					target[tarindex+1] = nextbyte;
+				else if (nextbyte)
+					return (-1);
+			}
+			tarindex++;
+			state = 3;
+			break;
+		case 3:
+			if (target) {
+				if (tarindex >= targsize)
+					return (-1);
+				target[tarindex] |= (pos - Base64);
+			}
+			tarindex++;
+			state = 0;
+			break;
+		}
+	}
+
+	/*
+	 * We are done decoding Base-64 chars.  Let's see if we ended
+	 * on a byte boundary, and/or with erroneous trailing characters.
+	 */
+
+	if (ch == Pad64) {			/* We got a pad char. */
+		ch = (unsigned char)*src++;	/* Skip it, get next. */
+		switch (state) {
+		case 0:		/* Invalid = in first position */
+		case 1:		/* Invalid = in second position */
+			return (-1);
+
+		case 2:		/* Valid, means one byte of info */
+			/* Skip any number of spaces. */
+			for (; ch != '\0'; ch = (unsigned char)*src++)
+				if (!isspace(ch))
+					break;
+			/* Make sure there is another trailing = sign. */
+			if (ch != Pad64)
+				return (-1);
+			ch = (unsigned char)*src++;		/* Skip the = */
+			/* Fall through to "single trailing =" case. */
+			/* FALLTHROUGH */
+
+		case 3:		/* Valid, means two bytes of info */
+			/*
+			 * We know this char is an =.  Is there anything but
+			 * whitespace after it?
+			 */
+			for (; ch != '\0'; ch = (unsigned char)*src++)
+				if (!isspace(ch))
+					return (-1);
+
+			/*
+			 * Now make sure for cases 2 and 3 that the "extra"
+			 * bits that slopped past the last full byte were
+			 * zeros.  If we don't check them, they become a
+			 * subliminal channel.
+			 */
+			if (target && tarindex < targsize &&
+			    target[tarindex] != 0)
+				return (-1);
+		}
+	} else {
+		/*
+		 * We ended by seeing the end of the string.  Make sure we
+		 * have no partial bytes lying around.
+		 */
+		if (state != 0)
+			return (-1);
+	}
+
+	return (tarindex);
+}
--- a/compat/cfmakeraw.c
+++ b/compat/cfmakeraw.c
@@ -15,9 +15,12 @@
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

-#include <string.h>
+#include <sys/types.h>

-#include "tmux.h"
+#include <string.h>
+#include <termios.h>
+
+#include "compat.h"

 void
 cfmakeraw(struct termios *tio)
--- a/compat/closefrom.c
+++ b/compat/closefrom.c
@@ -45,7 +45,7 @@
 # endif
 #endif

-#include "tmux.h"
+#include "compat.h"

 #ifndef OPEN_MAX
 # define OPEN_MAX	256
--- a/compat/daemon-darwin.c
+++ b/compat/daemon-darwin.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+
+/*
+ * Copyright (c) 2011-2013, Chris Johnsen <chris_johnsen@pobox.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     1. Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <sys/types.h>
+
+#include <mach/mach.h>
+
+#include <Availability.h>
+#include <unistd.h>
+
+void daemon_darwin(void);
+
+#ifdef __MAC_10_10
+
+extern kern_return_t	bootstrap_look_up_per_user(mach_port_t, const char *,
+			    uid_t, mach_port_t *);
+extern kern_return_t	bootstrap_get_root(mach_port_t, mach_port_t *);
+
+void
+daemon_darwin(void)
+{
+	mach_port_t	root = MACH_PORT_NULL;
+	mach_port_t	s = MACH_PORT_NULL;
+	uid_t		uid;
+
+	uid = getuid();
+	if (bootstrap_get_root(bootstrap_port, &root) == KERN_SUCCESS &&
+	    bootstrap_look_up_per_user(root, NULL, uid, &s) == KERN_SUCCESS &&
+	    task_set_bootstrap_port(mach_task_self(), s) == KERN_SUCCESS &&
+	    mach_port_deallocate(mach_task_self(), bootstrap_port) == KERN_SUCCESS)
+		bootstrap_port = s;
+}
+
+#else
+
+void
+daemon_darwin(void)
+{
+}
+
+#endif
--- a/compat/daemon.c
+++ b/compat/daemon.c
@@ -28,11 +28,17 @@
 * SUCH DAMAGE.
 */

+#include <sys/types.h>
+
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>

-#include "tmux.h"
+#include "compat.h"
+
+#ifdef __APPLE__
+extern void daemon_darwin(void);
+#endif

 int
 daemon(int nochdir, int noclose)
@@ -61,5 +67,9 @@ daemon(int nochdir, int noclose)
 		if (fd > 2)
 			(void)close (fd);
 	}
+
+#ifdef __APPLE__
+	daemon_darwin();
+#endif
 	return (0);
 }
--- a/compat/err.c
+++ b/compat/err.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2017 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 <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "compat.h"
+
+void
+err(int eval, const char *fmt, ...)
+{
+	va_list	 ap;
+	int	 saved_errno = errno;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	va_end(ap);
+
+	fprintf(stderr, "%s\n", strerror(saved_errno));
+	exit(eval);
+}
+
+void
+errx(int eval, const char *fmt, ...)
+{
+	va_list	 ap;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL)
+		vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
+	putc('\n', stderr);
+	exit(eval);
+}
+
+void
+warn(const char *fmt, ...)
+{
+	va_list	 ap;
+	int	 saved_errno = errno;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	va_end(ap);
+
+	fprintf(stderr, "%s\n", strerror(saved_errno));
+}
+
+void
+warnx(const char *fmt, ...)
+{
+	va_list	 ap;
+
+	fprintf(stderr, "%s: ", getprogname());
+
+	va_start(ap, fmt);
+	if (fmt != NULL)
+		vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
+	putc('\n', stderr);
+}
--- a/compat/explicit_bzero.c
+++ b/compat/explicit_bzero.c
@@ -0,0 +1,15 @@
+/*	$OpenBSD: explicit_bzero.c,v 1.4 2015/08/31 02:53:57 guenther Exp $ */
+/*
+ * Public domain.
+ * Written by Matthew Dempsky.
+ */
+
+#include <string.h>
+
+#include "compat.h"
+
+void
+explicit_bzero(void *buf, size_t len)
+{
+	memset(buf, 0, len);
+}
--- a/compat/fdforkpty.c
+++ b/compat/fdforkpty.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017 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 <limits.h>
+
+#include "compat.h"
+
+int
+getptmfd(void)
+{
+	return (INT_MAX);
+}
+
+pid_t
+fdforkpty(__unused int ptmfd, int *master, char *name, struct termios *tio,
+    struct winsize *ws)
+{
+	return (forkpty(master, name, tio, ws));
+}
--- a/compat/fgetln.c
+++ b/compat/fgetln.c
@@ -22,7 +22,7 @@
 #include <stdlib.h>
 #include <errno.h>

-#include "tmux.h"
+#include "compat.h"

 char *
 fgetln(FILE *fp, size_t *len)
--- a/compat/forkpty-aix.c
+++ b/compat/forkpty-aix.c
@@ -23,10 +23,14 @@
 #include <unistd.h>
 #include <errno.h>

-#include "tmux.h"
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);

 pid_t
-forkpty(int *master, unused char *name, struct termios *tio, struct winsize *ws)
+forkpty(int *master, __unused char *name, struct termios *tio,
+    struct winsize *ws)
 {
 	int	slave = -1, fd, pipe_fd[2];
 	char   *path, dummy;
--- a/compat/forkpty-hpux.c
+++ b/compat/forkpty-hpux.c
@@ -22,7 +22,10 @@
 #include <stropts.h>
 #include <unistd.h>

-#include "tmux.h"
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);

 pid_t
 forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
--- a/compat/forkpty-sunos.c
+++ b/compat/forkpty-sunos.c
@@ -21,9 +21,13 @@
 #include <stdlib.h>
 #include <strings.h>
 #include <stropts.h>
+#include <termios.h>
 #include <unistd.h>

-#include "tmux.h"
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);

 pid_t
 forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
--- a/compat/fparseln.c
+++ b/compat/fparseln.c
@@ -38,7 +38,7 @@
 #include <string.h>
 #include <stdlib.h>

-#include "tmux.h"
+#include "compat.h"

 /*
 * fparseln() specific operation flags.
--- a/compat/freezero.c
+++ b/compat/freezero.c
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2017 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 "compat.h"
+
+void
+freezero(void *ptr, size_t size)
+{
+	if (ptr != NULL) {
+		memset(ptr, 0, size);
+		free(ptr);
+	}
+}
--- a/compat/getdtablecount.c
+++ b/compat/getdtablecount.c
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2017 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 <glob.h>
+#include <unistd.h>
+
+#include "compat.h"
+
+void fatal(const char *, ...);
+void fatalx(const char *, ...);
+
+#ifdef HAVE_PROC_PID
+int
+getdtablecount(void)
+{
+	char	path[PATH_MAX];
+	glob_t	g;
+	int	n;
+
+	if (snprintf(path, sizeof path, "/proc/%ld/fd/*", (long)getpid()) < 0)
+		fatal("snprintf overflow");
+	switch (glob(path, 0, NULL, &g)) {
+	case GLOB_NOMATCH:
+		return (0);
+	case 0:
+		break;
+	default:
+		fatal("glob(\"%s\") failed", path);
+	}
+	n = g.gl_pathc;
+	globfree(&g);
+	return (n);
+}
+#else
+int
+getdtablecount(void)
+{
+	return (0);
+}
+#endif
--- a/compat/getopt.c
+++ b/compat/getopt.c
@@ -29,7 +29,7 @@

 /* OPENBSD ORIGINAL: lib/libc/stdlib/getopt.c */

-#include "tmux.h"
+#include "compat.h"

 #include <stdio.h>
 #include <stdlib.h>
@@ -84,7 +84,8 @@ BSDgetopt(int nargc, char *const *nargv, const char *ostr)
 			++BSDoptind;
 		if (BSDopterr && *ostr != ':')
 			(void)fprintf(stderr,
-			    "%s: unknown option -- %c\n", __progname, BSDoptopt);
+			    "%s: unknown option -- %c\n", getprogname(),
+			    BSDoptopt);
 		return (BADCH);
 	}
 	if (*++oli != ':') {			/* don't need argument */
@@ -102,7 +103,7 @@ BSDgetopt(int nargc, char *const *nargv, const char *ostr)
 			if (BSDopterr)
 				(void)fprintf(stderr,
 				    "%s: option requires an argument -- %c\n",
-				    __progname, BSDoptopt);
+				    getprogname(), BSDoptopt);
 			return (BADCH);
 		}
 		else				/* white space */
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`Please read https://raw.githubusercontent.com/tmux/tmux/master/CONTRIBUTING`